Dashboard › opencode-lore › Session 0RQ1BQtnnPJd
0RQ1BQtnnPJdC4hpYStrict READ-ONLY security/privacy 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; expected 2 files. Verify immutable integrity before/after. Attack terminal-only/done-only reasoning injection, malformed/gapped/oversized arrays/fields, absent lifecycle, recall/nested recall side effects, private content into wire/callback/log/persistence, high-cardinality CPU amplification, identity collisions, sparse Codex terminal omission, continuation shifts, retries/cancel/backpressure. Verify only lifecycle-backed summaries/content survive; nonempty contradictions fail; final output_text.done authority unchanged; indexed maps preserve strict matching and order/reference behavior; high-cardinality test doesn't bypass production. Assess fail-first/mutations supplied. Focused tests allowed; exhaustive separate. Report PASS/CONCERN/MUST-FIX exact current file:line and residual risk. 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>
<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. ...
No files found
<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: ...
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.
rtwyxzrrqnqspzypxtymnolzwmpnnumv b9feb17a1feb58a72a080cca0e493130427c506f parents=1ff66d14757b98d3ec7bdb8012104d1f10b292b8 conflict=false empty=false description=fix(responses): reject untracked Codex reasoning uyznyvwtuxrkvnppulnwlpryssrywsrt 1ff66d14757b98d3ec7bdb8012104d1f10b292b8 parents=2cbf40060c67df229731cf1b9e34d5bf22ec2145 conflict=false empty=false description=fix(responses): validate Codex reasoning summaries pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 conflict=false empty=false description=feat(cch): add seeds for Claude Code up to 2.1.272 (#1780)
7ac4f48eccfae80091d2cfffa627f461fd139af80e3a6face24d9dd1f4a47d7f -
039a197d0175430e2adac51ffbc52a9d42e26b2afb528028f612c57b1251e9ce -
caf10519f08fc9a396b3413617f4e9fca740f3c87c196455e56791d51709a354 -
...output truncated...
Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0ab27b3b3001JYnGGQLkkNO18Y
) {
throw new Error("duplicate Responses item identity");
}
- for (const [existingIndex, existing] of state.rawItems) {
- if (
- existingIndex !== outputIndex &&
- (existing.id === finalCallId || existing.call_id === finalCallId)
- ) {
- throw new Error("duplicate Responses item identity");
- }
- }
finalFunctionIdentity = { callId: finalCallId, name: finalName };
}
const declaredType = declared?.type;
@@ -8743,9 +8734,10 @@
lifecycle.content.set(contentIndex, contentState);
}
if (
- event.startsWith("response.reasoning_summary") &&
+ reasoningSummaryEvent &&
(!Number.isSafeInteger(parsed.summary_index) ||
- (parsed.summary_index as number) < 0)
+ (parsed.summary_index as ...
M packages/gateway/src/pipeline.ts M packages/gateway/test/openai-responses-recall-aware-stream.test.ts
diff --git a/packages/gateway/src/pipeline.ts b/packages/gateway/src/pipeline.ts
index 004e03b3e2..60b7e2621b 100644
--- a/packages/gateway/src/pipeline.ts
+++ b/packages/gateway/src/pipeline.ts
@@ -7875,6 +7875,8 @@
): Response {
const recallDiagnostics = createRecallDiagnostics(!opts.noStore);
let state = makeResponsesAccState();
+ const maxSSEFrames = opts.maxSSEFrames ?? DEFAULT_MAX_SSE_FRAMES;
+ const maxSparseIndex = Math.min(maxSSEFrames, DEFAULT_MAX_SSE_FRAMES);
const syntheticIdentities = new Set<string>();
const referenceIdentities = new Set<string>();
const outputIdentities = new Set<string>();
@@ -7944,7 +7946,7 @@
normalizationState,
event,
parsed,
- Math.min(maxSSEFrames, DEFAULT_MAX_SSE_FRAMES),
+ maxSparseIndex,
);
return normalizationState;
};
@@ -7989,6 +7991,11 @@
if (!Array.isArray(parts)) {
throw new Error(`Responses ${description} must be an array`);
}
+ if (parts.length > ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path> <type>file</type> <content> 7800: rollback: () => void; 7801: }) => void; 7802: sessionID?: string; 7803: /** Emergency ceiling for the request-owned recall chain. */ 7804: maxRecallExecutions?: number; 7805: /** @deprecated Use `maxRecallExecutions`. */ 7806: maxRecallDepth?: number; 7807: noStore?: boolean; 7808: maxDeferredBytes?: number; 7809: maxHiddenRecallBytes?: number; 7810: maxRetainedStateBytes?: number; 7811: maxStreamBytes?: number; 7812: maxSSEFrames?: number; 7813: validation?: "public" | "codex"; 7814: /** Caller abort combined with the stream's client-disconnect controller. */ 7815: signal?: AbortSignal; 7816: /** Absolute request deadline inherited from the foreground abort scope. */ 7817: recallDeadlineAt?: number; 7818: /** 7819: * Reissue the byte-stable principal request after a pre-output ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
8400: if (lifecycle?.outputDone && event !== "response.output_item.added") {
8401: throw new Error(
8402: `Responses event after output_item.done for index ${outputIndex}`,
8403: );
8404: }
8405: if (event === "response.output_item.added") {
8406: if (state.rawItems.has(outputIndex)) {
8407: throw new Error(`duplicate Responses output_index ${outputIndex}`);
8408: }
8409: const item = parsed.item as Record<string, unknown> | undefined;
8410: const sparseCodexFunction =
8411: opts.validation === "codex" && item?.type === "function_call";
8412: if (
8413: !item ||
8414: typeof item.type !== "string" ||
8415: !isSupportedResponsesOutputItemType(item.type) ||
8416: !isValidResponsesReasoningEncryptedContent(item) ||
8417: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9100: event: string,
9101: parsed: Record<string, unknown>,
9102: ): void => {
9103: if (
9104: !normalizationState ||
9105: event === "response.output_item.added" ||
9106: event === "response.output_item.done"
9107: ) {
9108: return;
9109: }
9110: const outputIndex = parsed.output_index;
9111: if (!Number.isSafeInteger(outputIndex) || (outputIndex as number) < 0)
9112: return;
9113: const index = outputIndex as number;
9114: if (acc.rawItems.has(index)) return;
9115: const normalizedRaw = normalizationState.rawItems.get(index);
9116: if (!normalizedRaw) return;
9117: const seedItem = { ...normalizedRaw };
9118: outputIndexForEvent(
9119: "response.output_item.added",
9120: { output_index: index, item: seedItem },
9121: acc,
9122: );
9123: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
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) ordinaryToolEmitted = true;
10103: afterEnqueue?.();
10104: });
10105: const safeClose = (): void => {
10106: cleanupAbort();
10107: if (cancelled) return;
10108: try {
10109: controller.close();
10110: } catch {
10111: // Already closed/cancelled
10112: }
10113: };
10114: const ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11220: if (retryFollowUp) {
11221: continuationFailureCategory = "follow_up_setup";
11222: follow = await settleFollowUp(
11223: continuationFollowUpInput,
11224: );
11225: continuationFailureCategory = "follow_up_protocol";
11226: continue;
11227: }
11228: const mergeContinuation = (): void => {
11229: for (const item of contState.rawItems.values()) {
11230: const itemIdentities = [item.id, item.call_id].filter(
11231: (value): value is string =>
11232: typeof value === "string" && value.length > 0,
11233: );
11234: ...
Found 8 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts: 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 15413: maxFrames: DEFAULT_MAX_SSE_FRAMES,
Found 4 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts: Line 215: normalizeCodexResponsesEvent, Line 7945: normalizeCodexResponsesEvent( /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/stream/anthropic.ts: Line 58: export const DEFAULT_MAX_SSE_FRAMES = 100_000;
Found 21 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts:
Line 582: export function applyResponsesEvent(
Line 671: case "response.output_text.done": {
Line 810: // response.reasoning_summary_*, etc.) — ignored for accumulation
Line 974: event === "response.output_text.done" ||
Line 1108: case "response.output_text.done":
Line 1167: event === "response.output_text.done" ||
Line 1205: event === "response.output_text.done" ||
Line 1722: case "response.output_text.done":
Line 1768: if (event === "response.output_text.done") {
Line 2009: event === "response.output_text.done" ||
Line 2025: event === "response.output_text.done" ||
Line 2106: event === "response.output_text.done" ||
Line 2124: event === "response.output_text.done" ||
Line 2128: kind: event === "response.output_text.done" ? ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
520:
521: function completeCodexMessageSnapshot(
522: snapshot: Record<string, unknown>,
523: outputIndex: number,
524: terminalContentParts: ReadonlyMap<
525: string,
526: { kind: "text" | "refusal"; value: string }
527: >,
528: ): Record<string, unknown> {
529: if (snapshot.type !== "message" || snapshot.content !== undefined) {
530: return snapshot;
531: }
532: const finalizedContent = finalizedResponsesMessageContent(
533: outputIndex,
534: terminalContentParts,
535: ).map((part) =>
536: part.kind === "text"
537: ? { type: "output_text", text: part.value }
538: : { type: "refusal", refusal: part.value },
539: );
540: return finalizedContent.length > 0
541: ? { ...snapshot, content: finalizedContent }
542: : snapshot;
543: }
544:
545: /** Validated unsuccessful terminal, carrying usage ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1640: malformedResponsesEvent();
1641: }
1642: if (
1643: parsed.content_index !== undefined &&
1644: (!Number.isSafeInteger(parsed.content_index) ||
1645: (parsed.content_index as number) < 0 ||
1646: (parsed.content_index as number) >= maxSparseIndex)
1647: ) {
1648: malformedResponsesEvent();
1649: }
1650: if (
1651: parsed.sequence_number !== undefined &&
1652: (!Number.isSafeInteger(parsed.sequence_number) ||
1653: (parsed.sequence_number as number) < 0)
1654: ) {
1655: malformedResponsesEvent();
1656: }
1657: if (parsed.item_id !== undefined && typeof parsed.item_id !== "string") {
1658: malformedResponsesEvent();
1659: }
1660:
1661: if (
1662: event === "response.created" ||
1663: event === "response.in_progress" ||
1664: event === "response.failed" ||
1665: ...
rtwyxzrrqnqspzypxtymnolzwmpnnumv b9feb17a1feb58a72a080cca0e493130427c506f fix(responses): reject untracked Codex reasoning --- uyznyvwtuxrkvnppulnwlpryssrywsrt 1ff66d14757b98d3ec7bdb8012104d1f10b292b8 fix(responses): validate Codex reasoning summaries ---
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
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:
2083: test("accepts reasoning summaries with summary_index", async () => {
2084: let completedResponse: GatewayResponse | undefined;
2085: const client = streamResponsesRecallAware(
2086: streamFrom([
2087: created("resp_summary", "gpt-5.6-terra"),
2088: sseEvent("response.output_item.added", {
2089: output_index: 0,
2090: item: { type: "reasoning", id: "rs_summary" },
2091: }),
2092: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
2620: } finally {
2621: findIndexSpy.mockRestore();
2622: iteratorSpy.mockRestore();
2623: }
2624: });
2625:
2626: test("rejects an oversized output_item.added reasoning summary before seeding lifecycle state", async () => {
2627: const summary = reasoningSummaryParts(
2628: Array.from(
2629: { length: 17 },
2630: (_, index) => `oversized added summary ${index}`,
2631: ),
2632: );
2633: const client = streamResponsesRecallAware(
2634: streamFrom([
2635: created("resp_oversized_added_summary", "gpt-5.6-terra"),
2636: sseEvent("response.output_item.added", {
2637: output_index: 0,
2638: item: {
2639: type: "reasoning",
2640: id: "rs_oversized_added_summary",
2641: summary,
2642: ...
Found 2 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts: Line 349: export function responsesDoneItemMatchesAdded( Line 401: export function responsesTerminalItemMatches(
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
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: actualPart[field].startsWith(value)
321: );
322: }
323: return sparseValueExtends(actualPart[field], value);
324: });
325: });
326: }
327:
328: function terminalTextPartsMatch(actual: unknown, streamed: unknown): boolean {
329: if (!Array.isArray(actual) || !Array.isArray(streamed)) return false;
330: if (actual.length !== streamed.length) return false;
331: return ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
250: if (typeof type !== "string" || typeof status !== "string") return false;
251: return OUTPUT_ITEM_STATUSES_BY_TYPE[type]?.[phase]?.has(status) ?? false;
252: }
253:
254: function recordExtends(
255: actual: Record<string, unknown>,
256: streamed: Record<string, unknown>,
257: ignored: ReadonlySet<string> = new Set(),
258: ): boolean {
259: return Object.entries(streamed).every(
260: ([field, value]) =>
261: ignored.has(field) || terminalValueExtends(actual[field], value),
262: );
263: }
264:
265: function terminalValueExtends(actual: unknown, streamed: unknown): boolean {
266: if (streamed === undefined) return true;
267: if (Array.isArray(streamed)) {
268: if (!Array.isArray(actual) || actual.length !== streamed.length) {
269: return false;
270: }
271: return streamed.every((value, index) =>
272: ...
Found 4 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 2709: "rejects forged reasoning summary event names on the %s stream",
Line 5045: sseEvent("response.reasoning_text.delta", {
Line 5051: sseEvent("response.reasoning_text.done", {
Line 5135: sseEvent("response.reasoning_text.done", {
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
4930: item_id: "msg_part_order",
4931: content_index: 0,
4932: part: { type: "output_text", text: "evil" },
4933: }) +
4934: sseEvent("response.content_part.done", {
4935: output_index: 0,
4936: item_id: "msg_part_order",
4937: content_index: 0,
4938: part: { type: "output_text", text: "safe" },
4939: }),
4940: },
4941: ])("rejects $name", async ({ events }) => {
4942: const client = streamResponsesRecallAware(
4943: streamFrom([
4944: created("resp_part_order", "gpt-5.6-terra"),
4945: sseEvent("response.output_item.added", {
4946: output_index: 0,
4947: item: { type: "message", id: "msg_part_order", role: "assistant" },
4948: }),
4949: events,
4950: ...
Found 83 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/llm-adapter.test.ts:
Line 2219: `event: response.output_text.done\ndata: ${JSON.stringify({
Line 2333: event("response.output_text.done", {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/pipeline-streaming.test.ts:
Line 197: responsesEvent("response.output_text.done", {
Line 2832: it("persists a project binding made authoritative by curate", async () => {
Line 5366: "x-lore-session-id": "authoritative-canonical-session",
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 191: sseEvent("response.output_text.done", {
Line 1472: sseEvent("response.output_text.done", {
Line 1504: sseEvent("response.output_text.done", {
Line 3349: sseEvent("response.output_text.done", {
Line 3392: sseEvent("response.output_text.done", {
...
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, existing.call_id].filter(
- (value): value is string =>
- typeof value === "string" && value.length > 0,
- ),
- );
- if (
- existingIndex !== outputIndex &&
- newIdentities.some((identity) => existingIdentities.has(identity))
- ) {
- throw new ...
packages/gateway/src/pipeline.ts | 329 ++++--- ...est/openai-responses-recall-aware-stream.test.ts | 963 +++++++++++++++++++++- 2 files changed, 1189 insertions(+), 103 deletions(-) packages/gateway/src/pipeline.ts | 144 +++++++++----- ...est/openai-responses-recall-aware-stream.test.ts | 224 ++++++++++++++++++++++ 2 files changed, 321 insertions(+), 47 deletions(-)
<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). ...
RUN v4.1.8 /home/byk/Code/opencode-lore-codex-reasoning
Test Files 1 passed (1)
Tests 229 passed (229)
Start at 17:11:06
Duration 30.80s (transform 13.80s, setup 3.12s, import 21.08s, tests 5.48s, environment 0ms)
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/batch-queue.test.ts:
Line 1259: test("malformed batch JSON logs a body-independent diagnostic", async () => {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/cli-doctor-contract.test.ts:
Line 6: * - Human mode renders inventory + diagnostics + summary line.
Line 149: test("human mode renders the three sections: inventory, diagnostics, summary", async () => {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/cli-check-vec.test.ts:
Line 67: describe("--check-vec CLI diagnostic", () => {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/llm-adapter.test.ts:
Line 165: test("keeps diagnostic error bodies capped at 64 KiB", async () => {
Line 195: test("replacement-decodes malformed diagnostic UTF-8", async () => {
Line 251: test("empty worker diagnostics never include response values", () => {
...
diff --git a/packages/gateway/test/openai-responses-recall-aware-stream.test.ts b/packages/gateway/test/openai-responses-recall-aware-stream.test.ts
index bb78dda4a3..8aca8ec10b 100644
--- a/packages/gateway/test/openai-responses-recall-aware-stream.test.ts
+++ b/packages/gateway/test/openai-responses-recall-aware-stream.test.ts
@@ -2399,6 +2399,230 @@
},
);
+ test("rejects a terminal-only principal reasoning summary before recall execution", async () => {
+ const privateSummary = "private terminal-only principal summary";
+ const args = JSON.stringify({ query: "must not execute" });
+ let recalls = 0;
+ let followUps = 0;
+ const client = streamResponsesRecallAware(
+ streamFrom([
+ created("resp_terminal_only_principal_summary", "gpt-5.6-terra"),
+ sseEvent("response.output_item.added", {
+ output_index: 0,
+ item: { type: "reasoning", id: "rs_terminal_only_principal" },
+ }),
+ ...
Found 5 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/anthropic.ts:
Line 150: export async function* parseSSEStream(
Line 155: frameCounter?: { count: number };
Line 176: const frameCounter = opts.frameCounter ?? { count: 0 };
Line 198: frameCounter.count++;
Line 199: if (frameCounter.count > maxFrames) {
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/anthropic.ts</path>
<type>file</type>
<content>
40: /** Format a single named SSE event for sending to the client. */
41: export function formatSSEEvent(eventType: string, data: string): string {
42: return `event: ${eventType}\ndata: ${data}\n\n`;
43: }
44:
45: // ---------------------------------------------------------------------------
46: // SSE parsing
47: // ---------------------------------------------------------------------------
48:
49: type StreamChunkRead = Awaited<
50: ReturnType<ReadableStreamDefaultReader<Uint8Array>["read"]>
51: >;
52:
53: /**
54: * Foreground and worker SSE streams share this finite frame ceiling. The byte
55: * ceilings bound retained data, while this independently bounds parser work for
56: * tiny frames (including blank and comment-only frames). ...
Found 2 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 7794: export function streamResponsesRecallAware(
Line 18747: streamResponsesRecallAware(upstreamResponse, {
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18680: rollbackRecallPersistence();
18681: if (
18682: requestGeneration !== streamingPostResponseGeneration ||
18683: sessionSignal.aborted
18684: ) {
18685: dropStreamingFinalizer();
18686: return;
18687: }
18688: accountUnsuccessfulResponse(
18689: resp,
18690: sessionState.sessionID,
18691: sessionState.resolvedConversationTTL,
18692: genAiSpan,
18693: endGenAiSpan,
18694: () => {
18695: sessionState._dirty = true;
18696: },
18697: );
18698: },
18699: dropStreamingFinalizer,
18700: true,
18701: requestCredentialFingerprint(req.rawHeaders, config) ?? ...
+ test.each(["empty", "omitted"] as const)(
+ test.each(["empty", "omitted"] as const)(
+ test.each(["empty", "omitted"] as const)(
+ test.each(["empty", "omitted"] as const)(
+ test("rejects a terminal-only principal reasoning summary before recall execution", async () => {
+ test("rejects a terminal-only continuation reasoning summary before nested recall execution", async () => {
+ test("reconciles high-cardinality Codex output with linear map iteration", async () => {
+ test("rejects an oversized output_item.added reasoning summary before seeding lifecycle state", async () => {
+ test("rejects an oversized done-only output_item.done reasoning summary before seeding lifecycle state", async () => {
+ test.each(["principal", "continuation"] as const)(
+ test.each(["principal", "continuation"] as const)(
+ test.each([
+ test("rejects a non-empty Codex terminal reasoning summary contradiction", async () => {
Found 100 matches (more matches available)
/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 279: created("resp_cancel_terminal", "gpt-5.6-terra") +
Line 280: completed("resp_cancel_terminal", {
Line 290: cancel() {
Line 313: await reader.cancel();
Line 414: test.each(["failed", "cancelled"])(
Line 737: retryPrincipal: async () => {
Line 757: test("does not retry a pre-output principal resource limit", async () => {
Line 764: retryPrincipal: async () => {
Line 850: retryPrincipal: async ({ attempt }) => {
Line 854: created("resp_principal_retry", "gpt-5.6-terra"),
Line 856: completed("resp_principal_retry"),
Line 876: "retrying principal Responses stream after read transport ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
6835: }),
6836: runFollowUp: async () => ({
6837: reader: (followUps++ === 0
6838: ? firstFollowUp
6839: : secondFollowUp
6840: ).body!.getReader(),
6841: }),
6842: },
6843: );
6844:
6845: const out = await drain(client);
6846: expect(out).toContain(PUBLIC_RECALL_ERROR);
6847: expect(out).not.toContain(firstEvent);
6848: expect(out).not.toContain(secondEvent);
6849: expect(failures).toEqual(["resource_limit"]);
6850: });
6851:
6852: test("does not double-charge transactional output when retrying a continuation", async () => {
6853: const extension = `event: extension\ndata: ${"x".repeat(600 * 1024)}\n\n`;
6854: const droppedFollowUp = new Response(
6855: new ReadableStream<Uint8Array>({
6856: start(controller) ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
7090: out.match(/^event: response\.function_call_arguments\.delta$/gm),
7091: ).toHaveLength(1);
7092: const deltaFrame = out
7093: .split("\n\n")
7094: .find((frame) =>
7095: frame.startsWith("event: response.function_call_arguments.delta\n"),
7096: );
7097: expect(deltaFrame).toBeDefined();
7098: const deltaData = deltaFrame?.slice(deltaFrame.indexOf("data: ") + 6);
7099: expect(JSON.parse(deltaData ?? "")).toMatchObject({
7100: output_index: 1,
7101: item_id: "fc_sparse_0",
7102: delta: sparseArguments,
7103: });
7104: expect(out).not.toContain(PUBLIC_RECALL_ERROR);
7105: });
7106:
7107: test("stops reading upstream while the client applies backpressure", async () => {
7108: const encoder = new TextEncoder();
7109: const events = [
7110: ...
Found 4 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 2265: { type: "summary_text", text: "first continuation summary" },
Line 2266: { type: "summary_text", text: "second continuation summary" },
Line 2334: "reconstructs a %s sparse Codex terminal summary after matching continuation added and done items",
Line 2338: const summary = reasoningSummaryParts(["continuation summary"]);
<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: ...
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. rtwyxzrrqnqspzypxtymnolzwmpnnumv b9feb17a1feb58a72a080cca0e493130427c506f parents=1ff66d14757b98d3ec7bdb8012104d1f10b292b8 conflict=false empty=false uyznyvwtuxrkvnppulnwlpryssrywsrt 1ff66d14757b98d3ec7bdb8012104d1f10b292b8 parents=2cbf40060c67df229731cf1b9e34d5bf22ec2145 conflict=false empty=false pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 conflict=false empty=false M packages/gateway/src/pipeline.ts M ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18570: protocol: effectiveProtocol,
18571: model: req.model,
18572: sessionID: sessionState.sessionID,
18573: stopReason: currentResp.stopReason,
18574: outputTokens: emptyOutputTokens,
18575: recallDepth,
18576: });
18577: }
18578: const recallHeaders =
18579: recallDepth > 0 ? { "x-lore-recall-invoked": "true" } : undefined;
18580: return nonStreamHttpResponse(
18581: shouldInjectWarning
18582: ? injectContextWarning(currentResp, warningText)
18583: : currentResp,
18584: req.protocol,
18585: req.stream,
18586: recallHeaders,
18587: longContext,
18588: );
18589: };
18590: const finishWithRecall = async (resp: GatewayResponse): Promise<Response> => {
18591: try {
18592: const response = await ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
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: type: "opaque",
832: responsesItem: true,
833: raw: {
834: ...
Found 9 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 36: log.registerSink(silentLogSink);
Line 722: log.registerSink({
Line 785: log.registerSink({
Line 824: log.registerSink({
Line 890: log.registerSink({
Line 943: log.registerSink({
Line 1151: log.registerSink({
Line 8773: log.registerSink({
Line 9290: log.registerSink({
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1510: } else if (outputIndex === undefined) {
1511: outputIndex = soleCodexItem(codexItemSet(state, kind));
1512: if (outputIndex === undefined) malformedResponsesEvent();
1513: }
1514:
1515: const normalized = state.items.get(outputIndex);
1516: if (!normalized) {
1517: if (itemId === undefined || state.rawItems.has(outputIndex)) {
1518: malformedResponsesEvent();
1519: }
1520: createImplicitCodexItem(state, outputIndex, itemId, kind);
1521: } else if (normalized.type !== kind) {
1522: malformedResponsesEvent();
1523: } else if (itemId !== undefined) {
1524: bindCodexItemId(state, outputIndex, itemId);
1525: }
1526: parsed.output_index = outputIndex;
1527: }
1528:
1529: function normalizeCodexItemEvent(
1530: state: ResponsesAccState,
1531: event: "response.output_item.added" | ...
Done-only reasoning data self-validates and reaches recall/persistence.
response.output_item.done synthesizes its own added lifecycle while retaining reasoning summary and content (packages/gateway/src/pipeline.ts:8362-8387). Those same values seed lifecycle state (:8497-8509) and then validate against themselves (:9003-9090). Codex terminal omission remains accepted (:9433-9569).
A small done-only reasoning item containing private text, followed by a recall and a terminal event that omits the reasoning item, therefore:
:11562-11573);onRecall through recallAcc (:10620-10645);onComplete and post-response persistence (:11479-11547, :18603-18655).The oversized done-only test only covers arrays above the limit (packages/gateway/test/openai-responses-recall-aware-stream.test.ts:2671-2705). It never tests a valid-sized done-only injection.
Strip reasoning summary/content before synthesizing lifecycle state, or track independent provenance and reject values supplied only by the done event. Add principal and continuation regressions covering recall suppression, wire, callback, logs, and persistence.
Reasoning content still bypasses lifecycle validation.
An added reasoning item with empty content followed by output_item.done with new nonempty content passes because content validation runs only when lifecycle.content.size > 0 (packages/gateway/src/pipeline.ts:9045-9090). Terminal omission then hides the contradiction.
Unknown reasoning-content aliases also pass. Only summary events have an exact allowlist (:8339-8348); content handling uses broad startsWith and endsWith checks (:8594-8734). The Codex normalizer has no rejecting default for unknown event names (packages/gateway/src/stream/openai-responses.ts:1708-1742). For example, ...