Session 0ET6vYDvmzmV

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

The working copy has no changes.
Working copy  (@) : rkqkzwmo e8fbf605 (empty) (no description set)
Parent commit (@-): spyyzvyy 3f3ae768 fix/recall-failure-synthesis | fix(recall): validate recovery metadata
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.

rkqkzwmozkxz e8fbf605d765379e541ce09cd5f2f9b8c126d883 parents=3f3ae768fde5b08b5c8e5dced647e361fddfd5aa conflict=false empty=true description=
spyyzvyyyqxs 3f3ae768fde5b08b5c8e5dced647e361fddfd5aa parents=b61b086186cb6a2219bdd40c96a0bba602dae3b2 conflict=false empty=false description=fix(recall): validate recovery metadata
pxrvwsvvkmpo 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 conflict=false empty=false description=feat(cch): add seeds for Claude Code up to 2.1.272 (#1780)

0bb7846a803d07be809d2cbd5220ad78aa8503c56eddb3efcd5c5dea8c29beed  -

A packages/gateway/src/codex-rate-limits.ts
M packages/gateway/src/pipeline.ts
M packages/gateway/src/recall.ts
M packages/gateway/src/stream/openai-responses.ts
M packages/gateway/src/translate/openai-responses.ts
M packages/gateway/test/codex-usage-metadata.test.ts
M packages/gateway/test/openai-responses-recall-aware-stream.test.ts
M packages/gateway/test/pipeline-streaming.test.ts
M packages/gateway/test/recall-buffered-transaction.test.ts
M packages/gateway/test/recall-exhaustion.test.ts
M packages/gateway/test/recall.test.ts

/home/byk/Code/opencode-lore-recall-recovery/quality/REVIEW.md
/home/byk/Code/opencode-lore-recall-recovery/package.json
/home/byk/Code/opencode-lore-recall-recovery/AGENTS.md
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/package.json

<path>/home/byk/Code/opencode-lore-recall-recovery/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-recall-recovery/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-recall-recovery/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-recall-recovery/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": ...

packages/gateway/src/codex-rate-limits.ts           | 120 ++++
packages/gateway/src/pipeline.ts                    | 409 +++++++++++----
packages/gateway/src/recall.ts                      | 132 +++-
packages/gateway/src/stream/openai-responses.ts     |  74 +-
packages/gateway/src/translate/openai-responses.ts  |   5 +-
packages/gateway/test/codex-usage-metadata.test.ts  | 133 +++-
...est/openai-responses-recall-aware-stream.test.ts |  68 ++
packages/gateway/test/pipeline-streaming.test.ts    | 440 +++++++++++++---
...gateway/test/recall-buffered-transaction.test.ts | 597 +++++++++++++++++++++-
packages/gateway/test/recall-exhaustion.test.ts     |  51 +-
packages/gateway/test/recall.test.ts                | 297 +++++++++-
11 files changed, 2105 insertions(+), 221 deletions(-)

Added regular file packages/gateway/src/codex-rate-limits.ts:
        1: export const MAX_CODEX_RATE_LIMIT_EVENTS = 64;
        2: export const MAX_CODEX_RATE_LIMIT_BYTES = 16 * 1024;
        3: 
        4: const encoder = new TextEncoder();
        5: 
        6: const CATEGORY = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
        7: const DECIMAL = /^(?:0|[1-9][0-9]{0,23})(?:\.[0-9]{1,12})?$/;
        8: 
        9: function isRecord(value: unknown): value is Record<string, unknown> {
       10:   return value !== null && typeof value === "object" && !Array.isArray(value);
       11: }
       12: 
       13: function category(value: unknown): string | undefined {
       14:   return typeof value === "string" && CATEGORY.test(value) ? value : undefined;
       15: }
       16: 
       17: function rateLimit(value: unknown): Record<string, unknown> | undefined {
       18:   if (!isRecord(value)) return undefined;
       19:   const result: Record<string, unknown> = {};
       20:   if (
    ...

Modified regular file packages/gateway/src/pipeline.ts:
    ...
 213  213:   responsesDoneItemMatchesAdded,
 214  214:   responsesTerminalItemMatches,
 215  215:   normalizeCodexResponsesEvent,
      216:   assertSuccessfulResponsesCompletion,
 216  217:   ResponsesTerminalError,
 217  218:   type ResponsesAccState,
 218  219: } from "./stream/openai-responses";
 219  220: import {
      221:   appendCodexRateLimitEvent,
      222:   sanitizeCodexRateLimitEvents,
      223: } from "./codex-rate-limits";
      224: import {
 220  225:   accumulateOpenAISSEStream,
 221  226:   translateAnthropicStreamToOpenAI,
 222  227: } from "./stream/openai";
    ...
 233  238:   safeTokenSum,
 234  239:   validateOpenAIUsage,
 235  240:   validateResponsesUsage,
      241:   validateAnthropicUsage,
      242:   validateGeminiUsageMetadata,
 236  243: } from "./usage-validation";
 237  244: import {
 238  245:   accumulateSSEResponse,
    ... ...

Modified regular file packages/gateway/src/recall.ts:
    ...
1115 1115:       input: { query, scope, id, ids, detailOffset, detailLimit },
1116 1116:       coverage: recall.coverage,
1117 1117:     };
1118     :   } catch (e) {
     1118:   } catch {
1119 1119:     if (signal?.aborted) throw signal.reason;
1120     :     log.error("gateway recall execution failed:", e);
     1120:     const diagnostic = new Error("gateway recall execution failed");
     1121:     diagnostic.name = "RecallExecutionError";
     1122:     log.error(diagnostic);
1121 1123:     return {
1122 1124:       result: "Recall search failed. The memory system encountered an error.",
1123 1125:       input: { query, scope, id, ids, detailOffset, detailLimit },
    ...
1325 1327:   };
1326 1328: }
1327 1329: 
     1330: const RECALL_RECOVERY_INSTRUCTION =
     1331:   "Continue the user's task using the accepted recall results and the context already available. ...

Modified regular file packages/gateway/src/stream/openai-responses.ts:
    ...
  34   34:   safeTokenSum,
  35   35:   validateResponsesUsage,
  36   36: } from "../usage-validation";
       37: import { appendCodexRateLimitEvent } from "../codex-rate-limits";
  37   38: 
  38   39: // ---------------------------------------------------------------------------
  39   40: // Stream accumulator — shared per-event core
    ...
 251  252:   return OUTPUT_ITEM_STATUSES_BY_TYPE[type]?.[phase]?.has(status) ?? false;
 252  253: }
 253  254: 
      255: export function assertSuccessfulResponsesCompletion(
      256:   response: Record<string, unknown>,
      257: ): void {
      258:   const usage = validateResponsesUsage(
      259:     response.usage,
      260:     "malformed Responses usage",
      261:   );
      262:   if (
      263:     response.status !== "completed" ||
      264:     !isNonEmptyString(response.id) ||
      265:     !isNonEmptyString(response.model) ||
      266:     ...

Modified regular file packages/gateway/src/translate/openai-responses.ts:
    ...
  21   21:   GatewayTool,
  22   22:   GatewayUsage,
  23   23: } from "./types";
       24: import { sanitizeCodexRateLimitEvents } from "../codex-rate-limits";
  24   25: import {
  25   26:   blocksToText,
  26   27:   forwardClientHeaders,
    ...
1278 1279: 
1279 1280:       // Buffered Codex responses still carry subscription windows and credits.
1280 1281:       // These values are independent of the token usage Lore may rescale.
1281     :       for (const quota of resp.codexRateLimits ?? []) {
     1282:       for (const quota of sanitizeCodexRateLimitEvents(
     1283:         resp.codexRateLimits ?? [],
     1284:       )) {
1282 1285:         emit("codex.rate_limits", quota);
1283 1286:       }
1284 1287: 
    ...

Modified regular file packages/gateway/test/codex-usage-metadata.test.ts:
    ...
   7    7: } from "../src/stream/openai-responses";
   8    8: import { buildOpenAIResponsesResponse } from "../src/translate/openai-responses";
   9    9: 
       10: const MAX_CODEX_RATE_LIMIT_EVENTS = 64;
       11: const MAX_CODEX_RATE_LIMIT_BYTES = 16 * 1024;
       12: 
  10   13: const limits = {
  11   14:   type: "codex.rate_limits",
  12   15:   plan_type: "pro",
    ...
 150  153:     expect(quotaEvents(await response.text())).toEqual([limits]);
 151  154:   });
 152  155: 
      156:   test.each(["buffered", "passthrough"] as const)(
      157:     "%s projection rebuilds quota metadata from the private allowlist",
      158:     async (mode) => {
      159:       const sentinel = "private diagnostic\nforged log line";
      160:       const hostile = {
      161:         ...limits,
      162:         plan_type: sentinel,
      163:         metered_limit_name: sentinel,
      164:         ...

Modified regular file packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
    ...
 230  230:     expect(out).not.toContain("response.failed");
 231  231:   });
 232  232: 
      233:   test("bounds Codex quota metadata across the principal and continuation", async () => {
      234:     const quota = (index: number) =>
      235:       sseEvent("codex.rate_limits", {
      236:         metered_limit_name: `bucket_${index}`,
      237:         rate_limits: {
      238:           primary: {
      239:             used_percent: index,
      240:             window_minutes: 300,
      241:             reset_at: 2000000000 + index,
      242:           },
      243:         },
      244:       });
      245:     const principalQuotas = Array.from({ length: 40 }, (_, index) => [
      246:       quota(index),
      247:       quota(index),
      248:     ]).flat();
      249:     const continuationQuotas = Array.from({ length: 40 }, (_, index) => [
      250:       ...

Modified regular file packages/gateway/test/pipeline-streaming.test.ts:
    ...
  58   58:   resetPipelineState,
  59   59:   scheduleStreamingPostResponseForTest,
  60   60:   setPipelinePreUpstreamPauseForTest,
       61:   setPipelineResponseReadFailureForTest,
  61   62:   setMaxActivePipelineRequestsForTest,
  62   63:   setMaxDetachedPipelineRequestsForTest,
  63   64:   setPipelineResetSettleTimeoutForTest,
    ...
 519  520:     }
 520  521:   });
 521  522: 
 522     :   it("accounts typed failed JSON recall follow-up usage in the fallback turn", async () => {
 523     :     clearAllCosts();
 524     :     let call = 0;
 525     :     setUpstreamInterceptor(async () => {
 526     :       call++;
 527     :       if (call === 1) {
      523:   it.each([
      524:     "tool",
      525:     "malformed",
      526:     "repeated-recall",
      527:     "overflow",
      528:     "failed-overflow",
      529:     "recall-plus-text",
      530:     "reasoning-only",
      531:   ...

Modified regular file packages/gateway/test/recall-buffered-transaction.test.ts:
    ...
  26   26:   recallAnchorContext,
  27   27:   MAX_RECALL_STORE_ENTRIES,
  28   28: } from "../src/recall";
       29: import { _setTestVertexTokenProvider } from "../src/vertex-auth";
  29   30: 
  30   31: afterEach(async () => {
  31   32:   setUpstreamInterceptor(undefined);
    ...
  37   38:   productiveRecallIds = undefined;
  38   39:   vi.restoreAllMocks();
  39   40:   resetWorkerHealth();
       41:   _setTestVertexTokenProvider(null);
  40   42: });
  41   43: 
  42   44: test.each(["absent", "different-bucket"] as const)(
    ...
 112  114:   },
 113  115: );
 114  116: 
      117: test("buffered Codex recovery preserves accepted, failed, and recovered quota updates in order", async () => {
      118:   knowledge();
      119:   const alias = crypto.randomUUID();
      120:   const req = request("openai-responses", alias, true);
      121:   setUpstreamInterceptor(async () =>
      ...

Modified regular file packages/gateway/test/recall-exhaustion.test.ts:
    ...
 230  230:       "refusal",
 231  231:       "unfinished",
 232  232:     ] as const)("final result %s", async (mode) => {
      233:       const requiresRecovery =
      234:         !stream &&
      235:         (mode === "recall" ||
      236:           mode === "failed" ||
      237:           mode === "reasoning" ||
      238:           mode === "unfinished");
 233  239:       let recallCalls = 0;
 234  240:       vi.mocked(executeRecall).mockImplementation(async () => {
 235  241:         recallCalls++;
    ... ...

Modified regular file packages/gateway/test/recall.test.ts:
    ...
   9    9:  *  - Response stripping
  10   10:  */
  11   11: import { describe, test, expect, vi } from "vitest";
       12: import { log } from "@loreai/core";
  12   13: import {
  13   14:   LORE_COMMIT_REMINDER,
  14   15:   accumulateOpenAINonStreamJSON,
    ...
  28   29:   hasOtherToolUse,
  29   30:   clientHasRecallTool,
  30   31:   buildRecallFollowUpRequest,
       32:   buildRecallRecoveryRequest,
  31   33:   runRecallFollowUpStreaming,
  32   34:   runRecallFollowUpJSON,
  33   35:   runRecallFollowUpStreamAccumulated,
       36:   runRecallRecovery,
  34   37:   type RecallFollowUpCtx,
  35   38:   buildRecallMarker,
  36   39:   buildRecallAnchor,
    ...
 269  272:       "Recall search failed. The memory system encountered an error.",
 270  273:     );
 271  274:   });
      275: 
      276:   test("logs malformed recall input through a fixed error envelope", async () => {
      277:     const ...

Found 16 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts:
  Line 1567: export interface RecallFollowUpError {

  Line 1590: ): Promise<RecallFollowUpStreaming | RecallFollowUpError> {

  Line 1643: ): Promise<RecallFollowUpJSON | RecallFollowUpError> {

  Line 1659: ): Promise<RecallFollowUpJSON | RecallFollowUpError> {

  Line 1715: ): Promise<RecallFollowUpJSON | RecallFollowUpError> {

  Line 1731: ): Promise<RecallFollowUpJSON | RecallFollowUpError> {

  Line 1777: ): Promise<RecallFollowUpJSON | RecallFollowUpError> {


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 7519:                   errorBody: streamingFollowUp.detail,

  Line 18600:           errorBody: jsonFollowUp.detail,


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/server.ts:
  Line 569:       detail: embeddings.detail,

  Line 574:       detail: ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
7440:               // Build (stream:true) + forward + assert-SSE + get reader in one
7441:               // coupled call so the follow-up's stream flag can never diverge
7442:               // from how the continuation is consumed (parseSSEStream below).
7443:               // Disable conversation caching on the follow-up: the appended
7444:               // recall result makes the prefix diverge from the next real turn,
7445:               // so the cache write would be wasted money.
7446:               const streamingRecallCtx: RecallFollowUpCtx = {
7447:                 forward: (r, signal) =>
7448:                   forwardToUpstream(
7449:                     r,
7450:                     recallContext.config,
7451:                     undefined,
7452:                     {
7453:                       ...recallContext.cacheOptions,
7454:                       ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18540:       // is consumed.
18541:       //
18542:       // openai-codex (ChatGPT) MANDATES streaming: its `/backend-api/codex/
18543:       // responses` backend rejects `stream: false` with
18544:       // `400 {"detail":"Stream must be set to true"}`. A plain stream:false
18545:       // JSON follow-up therefore 400s on every Codex recall continuation. For
18546:       // codex we force the follow-up to stream and accumulate its SSE body back
18547:       // into a non-streaming continuation, so the recall loop below is
18548:       // unchanged. Every other backend keeps the stream:false JSON follow-up
18549:       // (the standard Responses API and Chat Completions both accept it).
18550:       log.info(
18551:         `recall (non-stream, depth=${recallDepth}, codex=${followUpRequiresStream}): executing follow-up for session ${sessionState.sessionID.slice(0, ...

Found 4 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 2585: export function captureToolPairing400(input: {

  Line 7517:                 captureToolPairing400({

  Line 18206:     captureToolPairing400({

  Line 18598:         captureToolPairing400({

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
2520:  *
2521:  * 🔴 Re-anchors (via reanchorExistingDelta, preserving each block's content AND
2522:  * its `mut` signature) — it does NOT delete. Deleting the blocks here wiped the
2523:  * surfaced-set history, so a fresh delta produced on the SAME turn re-derived
2524:  * the ENTIRE cumulative pin→DB wall from the frozen baseline. As background
2525:  * consolidation tombstoned/edited more pinned entries over a session, that wall
2526:  * kept growing, so every compression+change turn re-rendered a larger
2527:  * deep-prefix block and busted the conversation cache — the regrowth churn
2528:  * #1013 only trimmed. Re-anchoring keeps advanceSurfacedKeys intact, so the
2529:  * append that follows contributes ONLY the genuinely-new increment (or nothing). ...

Found 17 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/server.ts:
  Line 56:   handleRequest,

  Line 61: } from "./pipeline";

  Line 494:     const result = await handleRequest(gatewayReq, config);

  Line 617:     return withoutCors(await handleRequest(gatewayReq, config));

  Line 671:     return withoutCors(await handleRequest(gatewayReq, config));

  Line 704:     return withoutCors(await handleRequest(gatewayReq, config));

  Line 739:     return withoutCors(await handleRequest(gatewayReq, config));


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 865: export function setPipelineResponseReadFailureForTest(

  Line 16332:   // workers, and use the order assigned synchronously in handleRequest so an

  Line 19994: async function handleRequestForTenant(

  Line 20015:       handleRequestInner(

  Line 20036: async function handleRequestInner(

  Line 20206: export async function handleRequest(

  Line 20210:   if ...

spyyzvyyyqxs 3f3ae768fde5b08b5c8e5dced647e361fddfd5aa fix(recall): validate recovery metadata
mmmktlwmwuts b61b086186cb6a2219bdd40c96a0bba602dae3b2 fix(recall): harden failure synthesis
mvtnxtlyooxq 9258a29630b9897346bdba48d90a443879e5b87d fix(recall): synthesize after recall failure
pxrvwsvvkmpo 2cbf40060c67df229731cf1b9e34d5bf22ec2145 feat(cch): add seeds for Claude Code up to 2.1.272 (#1780)

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1120:     case "response.output_text.delta":
1121:       if (!validOutputIndex || typeof parsed.delta !== "string") malformed();
1122:       if (item?.type !== "text") malformed();
1123:       break;
1124:     case "response.output_text.done":
1125:       if (!validOutputIndex || typeof parsed.text !== "string") malformed();
1126:       if (item?.type !== "text") malformed();
1127:       break;
1128:     case "response.refusal.delta":
1129:       if (!validOutputIndex || typeof parsed.delta !== "string") malformed();
1130:       if (item?.type !== "text") malformed();
1131:       break;
1132:     case "response.refusal.done":
1133:       if (!validOutputIndex || typeof parsed.refusal !== "string") malformed();
1134:       if (item?.type !== "text") malformed();
1135:       break;
1136:     case "response.function_call_arguments.delta":
1137:       if ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1870: function validateFailureTerminal(parsed: Record<string, unknown>): void {
1871:   if (!isRecord(parsed.response) || parsed.response.status !== "failed") {
1872:     throw new Error("malformed Responses terminal event");
1873:   }
1874:   const error = parsed.response.error;
1875:   if (error !== undefined && error !== null) {
1876:     if (!isRecord(error)) throw new Error("malformed Responses terminal event");
1877:     for (const field of ["type", "code", "message"] as const) {
1878:       if (error[field] !== undefined && typeof error[field] !== "string") {
1879:         throw new Error("malformed Responses terminal event");
1880:       }
1881:     }
1882:   }
1883: }
1884: 
1885: /**
1886:  * Accumulate an OpenAI Responses API SSE stream into a GatewayResponse. ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11950:     "proxy-authorization",
11951:     "set-cookie",
11952:     "set-cookie2",
11953:     "te",
11954:     "trailer",
11955:     "transfer-encoding",
11956:     "upgrade",
11957:   ]) {
11958:     headers.delete(name);
11959:   }
11960:   if (truncated) headers.set("x-lore-body-truncated", "true");
11961:   return new Response(body, {
11962:     status: response.status,
11963:     statusText: response.statusText,
11964:     headers,
11965:   });
11966: }
11967: 
11968: /** Parsed usage from a buffered response that lacks a valid completion. */
11969: class NonStreamCompletionError extends Error {
11970:   constructor(readonly response: GatewayResponse) {
11971:     super("upstream response did not complete");
11972:     this.name = "NonStreamCompletionError";
11973:   }
11974: }
11975: 
11976: export async function accumulateNonStreamResponse(
11977:   ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
12383: // Anthropic non-stream JSON → GatewayResponse: use shared parseAnthropicResponseJSON
12384: const accumulateAnthropicNonStreamJSON = parseAnthropicResponseJSON;
12385: 
12386: export function accumulateOpenAINonStreamJSON(
12387:   json: Record<string, unknown>,
12388: ): GatewayResponse {
12389:   const content: GatewayContentBlock[] = [];
12390:   if (json.choices !== undefined && !Array.isArray(json.choices)) {
12391:     throw new Error("malformed OpenAI response choice");
12392:   }
12393:   const choices = json.choices as Array<Record<string, unknown>> | undefined;
12394:   const logicalChoiceIndices = new Set<number>();
12395:   for (let position = 0; position < (choices?.length ?? 0); position++) {
12396:     const choice = choices?.[position];
12397:     if (!choice || typeof choice !== "object" || Array.isArray(choice)) {
12398:       throw new ...

Found 21 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/llm-adapter.ts:
  Line 80:   validateAnthropicUsage,

  Line 81:   validateGeminiUsageMetadata,

  Line 2137:   const usageMetadata = validateGeminiUsageMetadata(

  Line 2404:   validateAnthropicUsage(data.usage, {


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/usage-validation.ts:
  Line 55: export function validateAnthropicUsage(

  Line 149: export function validateOpenAIUsage(

  Line 259: export function validateGeminiUsageMetadata(


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 241:   validateAnthropicUsage,

  Line 242:   validateGeminiUsageMetadata,

  Line 12321:     const usage = validateGeminiUsageMetadata(

  Line 12362:   validateAnthropicUsage(json.usage, {


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/gemini.ts:
  Line 32: import { safeTokenSum, validateGeminiUsageMetadata } from ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/usage-validation.ts</path>
<type>file</type>
<content>
1: /** Runtime validation for provider-reported token usage. */
2: 
3: export function isRecord(value: unknown): value is Record<string, unknown> {
4:   return !!value && typeof value === "object" && !Array.isArray(value);
5: }
6: 
7: function invalid(message: string): never {
8:   throw new Error(message);
9: }
10: 
11: function tokenCount(
12:   value: unknown,
13:   message: string,
14:   allowNull = false,
15: ): number | undefined {
16:   if (value === undefined || (allowNull && value === null)) return undefined;
17:   if (!Number.isSafeInteger(value) || (value as number) < 0) invalid(message);
18:   return value as number;
19: }
20: 
21: /** Add validated token counts without allowing a safe-integer overflow. ...

Found 11 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai.ts:
  Line 87:     strict?: boolean;

  Line 477: export async function accumulateOpenAISSEStream(

  Line 482:     strict?: boolean;

  Line 486:     consumeUntilDone?: boolean;

  Line 829:       if (terminalSeen && !opts.consumeUntilDone) break;

  Line 838:   if (opts.consumeUntilDone && !doneSeen) {


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:
  Line 2395:     throw new Error("missing terminal response status");

  Line 2761:   opts: { strict?: boolean; signal?: AbortSignal } = {},


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/gemini.ts:
  Line 51:     strict?: boolean;

  Line 317:   opts: { strict?: boolean; signal?: AbortSignal } = {},


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/anthropic.ts:
  Line 1967:     strict?: boolean;

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai.ts</path>
<type>file</type>
<content>
460:   });
461: }
462: 
463: /**
464:  * Accumulate a streaming OpenAI Chat Completions SSE response into a
465:  * GatewayResponse.
466:  *
467:  * Reads EVERY `data:` chunk and merges the incremental `choices[0].delta`
468:  * fields (text + tool-call fragments) into a single response — so a
469:  * multi-chunk stream is reconstructed faithfully. This is the correct reader
470:  * for a non-streaming request whose provider replied with SSE anyway (the
471:  * ChatGPT/Copilot backend, DeepSeek): taking only the last `data:` line would
472:  * drop all but the final delta.
473:  *
474:  * OpenAI SSE chunk shape:
475:  *   data: {"id":"...","choices":[{"delta":{"content":"..."},"finish_reason":null}]}
476:  */
477: export async function accumulateOpenAISSEStream(
478:   upstreamResponse: Response,
479:   opts: {
480:     signal?: AbortSignal;
481:     ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai.ts</path>
<type>file</type>
<content>
835:   if (opts.stopAtTerminal && !terminalSeen) {
836:     throw new Error("missing OpenAI finish_reason terminal");
837:   }
838:   if (opts.consumeUntilDone && !doneSeen) {
839:     throw new Error("missing OpenAI [DONE] terminal");
840:   }
841:   if (opts.strict && Array.from(toolCalls.values()).some((tc) => !tc.id)) {
842:     throw new Error("malformed OpenAI stream event");
843:   }
844:   if (
845:     opts.strict &&
846:     Array.from(validatedToolCalls.values()).some((call) => !call.id)
847:   ) {
848:     throw new Error("malformed OpenAI stream event");
849:   }
850: 
851:   const content: GatewayContentBlock[] = [];
852:   // Thinking precedes text (Anthropic ordering). ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/openai-responses.ts</path>
<type>file</type>
<content>
1170:   if (!resp.rawOutputItems) {
1171:     for (const block of resp.content) {
1172:       if (block.type === "text") {
1173:         textContent += block.text;
1174:       } else if (block.type === "tool_use") {
1175:         functionCalls.push({
1176:           type: "function_call",
1177:           id: `fc_${block.id}`,
1178:           call_id: block.id,
1179:           name: block.name,
1180:           arguments: JSON.stringify(block.input),
1181:           status: "completed",
1182:         });
1183:       }
1184:     }
1185: 
1186:     if (textContent) {
1187:       output.push({
1188:         type: "message",
1189:         id: `msg_${resp.id}`,
1190:         role: "assistant",
1191:         status: "completed",
1192:         content: [
1193:           {
1194:             type: "output_text",
1195:             text: textContent,
1196:        ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/openai-responses.ts</path>
<type>file</type>
<content>
1100:           role: msg.role === "assistant" ? "assistant" : "user",
1101:           content: [
1102:             {
1103:               type: msg.role === "assistant" ? "output_text" : "input_text",
1104:               text: block.text,
1105:             },
1106:           ],
1107:         });
1108:       } else if (block.type === "tool_use") {
1109:         appendItem({
1110:           type: "function_call",
1111:           call_id: block.id,
1112:           name: block.name,
1113:           arguments: JSON.stringify(block.input),
1114:         });
1115:       } else if (block.type === "tool_result") {
1116:         // Responses API function_call_output.output is a string — use the
1117:         // text projection. ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
15080:   const controller = new AbortController();
15081:   activeForegroundAbortControllers.add(controller);
15082:   const abort = (reason?: unknown) => {
15083:     if (!controller.signal.aborted) controller.abort(reason);
15084:   };
15085:   const onCallerAbort = () => abort(caller?.reason);
15086:   caller?.addEventListener("abort", onCallerAbort, { once: true });
15087:   if (caller?.aborted) onCallerAbort();
15088:   const deadlineAt = Date.now() + FOREGROUND_REQUEST_TIMEOUT_MS;
15089:   const timer = setTimeout(
15090:     () =>
15091:       abort(new DOMException("foreground request timed out", "TimeoutError")),
15092:     FOREGROUND_REQUEST_TIMEOUT_MS,
15093:   );
15094:   return {
15095:     signal: controller.signal,
15096:     abort,
15097:     deadlineAt,
15098:     dispose: () => {
15099:       ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18680:     }
18681:     const recallHeaders =
18682:       recallDepth > 0 ? { "x-lore-recall-invoked": "true" } : undefined;
18683:     return nonStreamHttpResponse(
18684:       shouldInjectWarning
18685:         ? injectContextWarning(currentResp, warningText)
18686:         : currentResp,
18687:       req.protocol,
18688:       req.stream,
18689:       recallHeaders,
18690:       longContext,
18691:     );
18692:   };
18693:   const finishWithRecall = async (resp: GatewayResponse): Promise<Response> => {
18694:     try {
18695:       const response = await awaitForeground(finalizeWithRecall(resp));
18696:       bufferedRecallDiagnostics.finish(response.ok ? "completed" : "failed");
18697:       return finishForeground(response);
18698:     } catch (error) {
18699:       rollbackRecallPersistence();
18700:       bufferedRecallDiagnostics.finish(
18701:         ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18774:   function finishUnsuccessfulStreaming(resp: GatewayResponse): void {
18775:     if (streamingFinalizerRegistered) return;
18776:     streamingFinalizerRegistered = true;
18777:     scheduleStreamingPostResponse(
18778:       sessionState.sessionID,
18779:       requestGeneration,
18780:       async () => {
18781:         await downstreamSettled;
18782:         await new Promise<void>((resolve) => setImmediate(resolve));
18783:         rollbackRecallPersistence();
18784:         if (
18785:           requestGeneration !== streamingPostResponseGeneration ||
18786:           sessionSignal.aborted
18787:         ) {
18788:           dropStreamingFinalizer();
18789:           return;
18790:         }
18791:         accountUnsuccessfulResponse(
18792:           resp,
18793:           sessionState.sessionID,
18794:           ...

Found 6 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 18091:   const dropStreamingFinalizer = (): void => {

  Line 18716:           dropStreamingFinalizer();

  Line 18720:           dropStreamingFinalizer();

  Line 18769:       dropStreamingFinalizer,

  Line 18788:           dropStreamingFinalizer();

  Line 18802:       dropStreamingFinalizer,

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18020: 
18021:     if (delay > 0) {
18022:       // Cap delay to avoid pushing the next request past the cache TTL boundary.
18023:       // Use prevRequestTime (the request before this one) to compute how much
18024:       // of the cache TTL window has already been consumed.
18025:       const ttlMs = resolvedConversationTTL === "1h" ? 3_600_000 : 300_000;
18026:       const elapsed = sessionState.prevRequestTime
18027:         ? Date.now() - sessionState.prevRequestTime
18028:         : 0; // first request — no prior timing, full TTL available
18029:       const maxSafe = Math.max(0, (ttlMs - elapsed) * 0.5) / 1000;
18030:       const actualDelay = Math.min(delay, maxSafe);
18031: 
18032:       if (actualDelay > 0.5) {
18033:         // don't bother sleeping < 500ms
18034:         log.info(
18035:           `budget-throttle: sleeping ${actualDelay.toFixed(1)}s ` ...

Found 1 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/abort-race.ts:
  Line 6: export function promiseAgainstAbort<T>(

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/abort-race.ts</path>
<type>file</type>
<content>
1: /**
2:  * Settle a Response-producing operation against an AbortSignal even when the
3:  * underlying implementation ignores that signal. Late responses are drained
4:  * by cancellation and late rejections stay observed.
5:  */
6: export function promiseAgainstAbort<T>(
7:   start: () => Promise<T>,
8:   signal?: AbortSignal,
9:   onLateResolve?: (value: T) => void,
10: ): Promise<T> {
11:   if (!signal) return start();
12:   signal.throwIfAborted();
13: 
14:   return new Promise<T>((resolve, reject) => {
15:     let settled = false;
16:     const cleanup = (): void => signal.removeEventListener("abort", onAbort);
17:     const onAbort = (): void => {
18:       if (settled) return;
19:       settled = true;
20:       cleanup();
21:       reject(signal.reason);
22:     };
23: 
24:     signal.addEventListener("abort", onAbort, { once: true });
25:     if ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts</path>
<type>file</type>
<content>
1460:     cancelAndReleaseReader(reader, probeSignal.reason);
1461:     if (!preserveReplay) {
1462:       try {
1463:         void replay.cancel(probeSignal.reason).catch(() => {});
1464:       } catch {
1465:         // Both tee branches are best-effort and must never delay the caller.
1466:       }
1467:     }
1468:   }
1469:   throw new Error(
1470:     `recall follow-up expected SSE but got "${ct}" and a non-SSE body`,
1471:   );
1472: }
1473: 
1474: async function readResponseTextLimited(
1475:   response: Response,
1476:   maxBytes = 500,
1477:   signal?: AbortSignal,
1478: ): Promise<string> {
1479:   const reader = response.body?.getReader();
1480:   if (!reader) return "";
1481:   const decoder = new TextDecoder();
1482:   let text = "";
1483:   let readBytes = 0;
1484:   try {
1485:     while (readBytes < maxBytes) {
1486:       ...

Found 5 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 6965:     FOREGROUND_REQUEST_TIMEOUT_MS,

  Line 11825:   foregroundErrorBodyTimeoutMs = timeoutMs ?? FOREGROUND_ERROR_BODY_TIMEOUT_MS;

  Line 15039: const FOREGROUND_REQUEST_TIMEOUT_MS = 300_000;

  Line 15088:   const deadlineAt = Date.now() + FOREGROUND_REQUEST_TIMEOUT_MS;

  Line 15092:     FOREGROUND_REQUEST_TIMEOUT_MS,

Found 46 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/usage-validation.ts:
  Line 238:   "cachedContentTokenCount",

  Line 295:     counts.cachedContentTokenCount !== undefined &&

  Line 297:       counts.cachedContentTokenCount > counts.promptTokenCount)

  Line 304:     counts.cachedContentTokenCount,


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/types.ts:
  Line 270:     prompt_cache_key?: string;


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/openai.ts:
  Line 747:     if (cache?.cacheTools && tools.length > 0) {

  Line 749:       lastTool.cache_control = ephemeralCacheControl(cache.systemTTL);

  Line 842:     if (cache?.systemTTL) {

  Line 849:             cache_control: ephemeralCacheControl(cache.systemTTL),

  Line 942:   //     (via `systemTTL`); the conversation breakpoint must never overwrite it,

  Line 1018:         // matching how Anthropic anchors its distilled prefix at ...

Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cli-signal-lifecycle.test.ts:
  Line 122:       "authenticated shutdown closes a stalled partial HTTP connection",


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cli-logs-contract.test.ts:
  Line 259:       // Strip any signal handlers the legacy installed.


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/compact-endpoint.test.ts:
  Line 123:         "x-lore-session-id": "unknown-stalled-session",


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cli-doctor-contract.test.ts:
  Line 12:  * isNpmPackageInstalledSafe) so the test runs hermetically without

  Line 30:   opencodeInstalled: boolean;

  Line 56:   opencodeInstalled: true,

  Line 73:     isNpmPackageInstalledSafe: () => fakeState.opencodeInstalled,

  Line 141:     fakeState.opencodeInstalled = ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall.test.ts</path>
<type>file</type>
<content>
1420: 
1421:   test("settles on abort when follow-up setup ignores its signal", async () => {
1422:     const controller = new AbortController();
1423:     const ctx: RecallFollowUpCtx = {
1424:       forward: () => new Promise(() => {}),
1425:       parseJSON: () => {
1426:         throw new Error("should not be called");
1427:       },
1428:     };
1429:     const pending = runRecallFollowUpStreaming(
1430:       ctx,
1431:       makeRequest(),
1432:       resp,
1433:       "recall results",
1434:       recallBlock,
1435:       controller.signal,
1436:     );
1437:     controller.abort(new DOMException("client disconnected", "AbortError"));
1438:     await expect(pending).rejects.toMatchObject({ name: "AbortError" });
1439:   });
1440: 
1441:   test.each(["abort", "timeout"] as const)(
1442:     "%s cancels both branches of a pending SSE content probe without ...

Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cli-bundle-smoke.test.ts:
  Line 167:       // a `Try: lore login` recovery command.


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cache-warmer.test.ts:
  Line 667:     // A partial is a body-divergence DEFECT, not a recovery: it must NOT clear

  Line 962:     // model these hit the recovery branch and were ignored.


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/llm-adapter.test.ts:
  Line 3272: // Data-policy 404 detection + :free auto-recovery


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/invariant-judge.test.ts:
  Line 213: describe("invariant worker recovery", () => {


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/install-script.test.ts:
  Line 918:   it("fails closed without publishing a profile when recovery claims are ambiguous", () => {

  Line 936:       "Refusing ambiguous ...

Found 1 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts:
  Line 1191: export function isUsableRecallContinuation(resp: GatewayResponse): boolean {

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts</path>
<type>file</type>
<content>
1135: /** Wire protocol used for a recall follow-up upstream response. */
1136: export type RecallProtocol =
1137:   | "anthropic"
1138:   | "openai"
1139:   | "openai-responses"
1140:   | "vertex"
1141:   | "gemini";
1142: 
1143: /**
1144:  * Injected upstream dependencies for recall follow-up execution.
1145:  *
1146:  * Passed by the pipeline so `recall.ts` never imports `pipeline.ts`
1147:  * (avoids a circular dependency). `forward` wraps `forwardToUpstream`
1148:  * — callers should disable conversation caching on the follow-up;
1149:  * `parseJSON` wraps `accumulateNonStreamResponse`.
1150:  */
1151: export interface RecallFollowUpCtx {
1152:   /** Forward a follow-up request upstream and return the raw response. */
1153:   forward: (
1154:     req: GatewayRequest,
1155:     signal?: AbortSignal,
1156:   ) => Promise<{ response: Response; effectiveProtocol: ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
6460:       `auth/upstream mismatch: GitHub OAuth token (gho_) routed to ${upstreamUrlForLog(effectiveUpstreamBase)} — ` +
6461:         `provider: ${providerID ?? "none"}`,
6462:     );
6463:   }
6464: 
6465:   if (effectiveProtocol === "openai-responses") {
6466:     // Inject LTM into system prompt for non-Anthropic paths.
6467:     // Anthropic handles LTM via separate system blocks in buildAnthropicRequest;
6468:     // OpenAI paths receive a single system string, so we concatenate here.
6469:     const ltmParts = [cache?.stableLtmSystem].filter(Boolean);
6470:     const reqWithLtm = ltmParts.length
6471:       ? {
6472:           ...req,
6473:           system: [req.system, ...ltmParts].filter(Boolean).join("\n\n"),
6474:         }
6475:       : req;
6476:     const result = buildOpenAIResponsesUpstreamRequest(
6477:       reqWithLtm,
6478:       ...

Found 1 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 11881: export async function readForegroundBody(

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11785:       );
11786:       if (keepaliveTimer) clearTimeout(keepaliveTimer);
11787:       if (activeReader) cancelAndReleaseReader(activeReader, signal.reason);
11788:       else
11789:         void currentPrincipalResponse.body
11790:           ?.cancel(signal.reason)
11791:           .catch(() => {});
11792:     },
11793:   });
11794: 
11795:   return new Response(stream, {
11796:     status: 200,
11797:     headers: {
11798:       "content-type": "text/event-stream",
11799:       "cache-control": "no-cache",
11800:       connection: "keep-alive",
11801:     },
11802:   });
11803: }
11804: 
11805: /**
11806:  * Accumulate a non-streaming upstream response into a GatewayResponse. ...

Found 6 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall-continuation-failure.ts:
  Line 41: export function reportRecallContinuationFailure(


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 369:   reportRecallContinuationFailure,

  Line 7695:             reportRecallContinuationFailure(err.category);

  Line 10079:           reportRecallContinuationFailure(category);

  Line 18285:       if (report) reportRecallContinuationFailure(category);

  Line 18478:         reportRecallContinuationFailure(category);

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall-continuation-failure.ts</path>
<type>file</type>
<content>
1: export const RECALL_CONTINUATION_FAILURE_CATEGORIES = [
2:   "recall_execution",
3:   "follow_up_setup",
4:   "follow_up_transport",
5:   "follow_up_protocol",
6:   "follow_up_failed",
7:   "follow_up_missing_output",
8:   "follow_up_incomplete_arguments",
9:   "parallel_recall",
10:   "nested_recall_incomplete",
11:   "nested_recall_execution",
12:   "depth_exhausted",
13:   "missing_recall_block",
14:   "resource_limit",
15:   "delivery",
16:   "unexpected",
17: ] as const;
18: 
19: export type RecallContinuationFailureCategory =
20:   (typeof RECALL_CONTINUATION_FAILURE_CATEGORIES)[number];
21: 
22: type RecallContinuationFailureHook = (
23:   category: RecallContinuationFailureCategory,
24: ) => void;
25: 
26: let failureHook: RecallContinuationFailureHook | undefined;
27: 
28: export class RecallContinuationFailure extends Error {
29:   ...

---
spyyzvyyyqxsoqruslxomwuznzstkrtr
3f3ae768fde5b08b5c8e5dced647e361fddfd5aa
fix(recall): validate recovery metadata

---
mmmktlwmwutsllyyuvzvtsnpyryytryp
b61b086186cb6a2219bdd40c96a0bba602dae3b2
fix(recall): harden failure synthesis

---
mvtnxtlyooxqllwtzlowurpkwknoqouy
9258a29630b9897346bdba48d90a443879e5b87d
fix(recall): synthesize after recall failure

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10215:                   "Responses retained state exceeded byte limit",
10216:                 );
10217:               }
10218:               const implicitItem = state.rawItems.get(outputIndex);
10219:               if (
10220:                 opts.validation === "codex" &&
10221:                 event !== "response.output_item.added" &&
10222:                 event !== "response.output_item.done" &&
10223:                 implicitItem?.type === "function_call" &&
10224:                 implicitItem.name === ""
10225:               ) {
10226:                 unresolvedToolIndices.add(outputIndex);
10227:               }
10228:             }
10229: 
10230:             let resolvingRecallTool = false;
10231:             let resolvingVisibleTool = false;
10232:             // Detect recall and unresolved sparse function-call identities. ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11430:                 }
11431:               }
11432:               if (
11433:                 !(await safeEnqueue(
11434:                   encoder.encode(buildTerminal(visibleResp)),
11435:                   () => {
11436:                     terminalDelivered = true;
11437:                     const successful =
11438:                       state.terminalEvent === "response.completed";
11439:                     let transactionSettled = false;
11440:                     const transaction = {
11441:                       commit: () => {
11442:                         if (transactionSettled) return;
11443:                         try {
11444:                           for (const commit of pendingCommits) commit();
11445:                           transactionSettled = true;
11446:                           pendingCommits.length = 0;
11447:                           ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10835:                             ) {
10836:                               contUnresolvedToolIndices.add(ci);
10837:                             }
10838:                           }
10839:                           let resolvingRecallTool = false;
10840:                           let resolvingVisibleTool = false;
10841:                           if (
10842:                             (ce === "response.output_item.added" ||
10843:                               ce === "response.output_item.done") &&
10844:                             ci !== undefined
10845:                           ) {
10846:                             const item = cparsed.item as
10847:                               | Record<string, unknown>
10848:                               | undefined;
10849:                             if (
10850:                               item?.type === "function_call" ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11100:                           (error instanceof Error &&
11101:                             /^SSE stream exceeded \d+ frame limit$/.test(
11102:                               error.message,
11103:                             ))
11104:                         ) {
11105:                           throw new RecallContinuationFailure("resource_limit");
11106:                         }
11107:                         if (
11108:                           error instanceof SSEStreamTransportError &&
11109:                           !continuationFollowUpInput.finalRecallRound &&
11110:                           recallContinuationTransportRetries <
11111:                             maxRecallContinuationTransportRetries
11112:                         ) {
11113:                           recallContinuationTransportRetries++;
11114:                           ...

Found 8 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 10624:                     let continuationRetryBaseline = {

  Line 11115:                             continuationRetryBaseline.transactionalEvents;

  Line 11117:                             continuationRetryBaseline.transactionalBytes;

  Line 11119:                             continuationRetryBaseline.retainedStateBytes;

  Line 11121:                             continuationRetryBaseline.hiddenRecallBytes;

  Line 11123:                           for (const identity of continuationRetryBaseline.outputIdentities) {

  Line 11127:                           for (const identity of continuationRetryBaseline.referenceIdentities) {

  Line 11367:                       continuationRetryBaseline = {

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10570:                     executed.anchorText,
10571:                     syntheticId,
10572:                   ),
10573:                 );
10574:                 if (otherToolSeen) {
10575:                   state.items.set(recall.outputIndex, {
10576:                     type: "text",
10577:                     id: `msg_${state.id || "lore"}_${recall.outputIndex}`,
10578:                     text: executed.anchorText,
10579:                   });
10580:                   queueTransactional(anchorChunk);
10581:                   for (const deferred of deferredEvents) {
10582:                     queueTransactional(deferred.chunk);
10583:                   }
10584:                 } else {
10585:                   queueTransactional(anchorChunk);
10586:                   for (const deferred of deferredEvents) {
10587:                     ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11335:                             encoder.encode(
11336:                               emitTextItem(
11337:                                 shiftedRecallIndex,
11338:                                 nextExecuted.anchorText,
11339:                               ),
11340:                             ),
11341:                           );
11342:                         }
11343:                       }
11344:                       flushHeldContinuation();
11345:                       for (const index of contRecallIndices) {
11346:                         recallIndices.add(shiftedOutputIndex(index, contIndex));
11347:                       }
11348:                       mergeContinuation();
11349:                       if (continuationFollowUpInput.finalRecallRound)
11350:                         log.info("recall final continuation: completed");
11351:                     ...

Found 7 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/codex-rate-limits.ts:
  Line 68:   if (!isRecord(value) || value.type !== "codex.rate_limits") return undefined;

  Line 69:   const result: Record<string, unknown> = { type: "codex.rate_limits" };


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/openai-responses.ts:
  Line 1285:         emit("codex.rate_limits", quota);


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 11083:                             (ce !== "codex.rate_limits" || publicCodexRateLimit)

  Line 11490:             if (event === "codex.rate_limits" && !publicCodexRateLimit) {


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:
  Line 618:     case "codex.rate_limits": {

  Line 2380:         if (event !== "codex.rate_limits" || acceptedCodexRateLimit) {

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/anthropic.ts</path>
<type>file</type>
<content>
1680:       if (
1681:         typeof block.thinking !== "string" ||
1682:         (block.signature !== undefined && typeof block.signature !== "string")
1683:       ) {
1684:         malformedAnthropicStream();
1685:       }
1686:       break;
1687:     case "redacted_thinking":
1688:       if (typeof block.data !== "string") malformedAnthropicStream();
1689:       break;
1690:     case "tool_use":
1691:       if (
1692:         typeof block.id !== "string" ||
1693:         typeof block.name !== "string" ||
1694:         !isRecord(block.input)
1695:       ) {
1696:         malformedAnthropicStream();
1697:       }
1698:       break;
1699:     case "server_tool_use":
1700:       if (
1701:         typeof block.id !== "string" ||
1702:         typeof block.name !== "string" ||
1703:         block.input === undefined
1704:       ) {
1705:         ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/index.ts</path>
<type>file</type>
<content>
1: /**
2:  * Lore Gateway — package entry point.
3:  *
4:  * Library exports for programmatic use, plus `runCli()` for the CLI binary.
5:  *
6:  * Library usage:
7:  *   import { startServer, loadConfig } from "@loreai/gateway";
8:  *
9:  * CLI usage (via bin wrapper):
10:  *   lore start
11:  *   lore run claude
12:  */
13: import "../instrument";
14: import { fileURLToPath } from "node:url";
15: 
16: // ---------------------------------------------------------------------------
17: // Library API
18: // ---------------------------------------------------------------------------
19: 
20: export { loadConfig, DEFAULT_PORTS, DEFAULT_PORT } from "./config";
21: export type { GatewayConfig } from "./config";
22: export { startServer } from "./server";
23: export { handleRequest, resetPipelineState } from "./pipeline";
24: export { readPortFile } from "./portfile";
25: ...

Found 4 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/server.ts:
  Line 155: function errorResponseWithoutCors(

  Line 169: function errorResponse(


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 19968: function errorResponse(status: number, message: string): Response {


/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/api.ts:
  Line 68: function errorResponse(

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
19945:       });
19946:     }
19947:     if (req.protocol === "gemini") {
19948:       return translateAnthropicStreamToGemini(anthropicSSE, {
19949:         signal: req.signal,
19950:       });
19951:     }
19952:     return anthropicSSE;
19953:   }
19954: 
19955:   return nonStreamHttpResponse(
19956:     resp,
19957:     req.protocol,
19958:     req.stream,
19959:     undefined,
19960:     requestEnablesLongContext(req),
19961:   );
19962: }
19963: 
19964: // ---------------------------------------------------------------------------
19965: // Error response builder
19966: // ---------------------------------------------------------------------------
19967: 
19968: function errorResponse(status: number, message: string): Response {
19969:   return new Response(
19970:     JSON.stringify({
19971:       type: "error",
19972:       error: {
19973:         type: ...

The working copy has no changes.
Working copy  (@) : rkqkzwmo e8fbf605 (empty) (no description set)
Parent commit (@-): spyyzvyy 3f3ae768 fix/recall-failure-synthesis | fix(recall): validate recovery metadata
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.

rkqkzwmozkxz e8fbf605d765379e541ce09cd5f2f9b8c126d883 parents=3f3ae768fde5b08b5c8e5dced647e361fddfd5aa conflict=false empty=true description=
spyyzvyyyqxs 3f3ae768fde5b08b5c8e5dced647e361fddfd5aa parents=b61b086186cb6a2219bdd40c96a0bba602dae3b2 conflict=false empty=false description=fix(recall): validate recovery metadata
pxrvwsvvkmpo 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 conflict=false empty=false description=feat(cch): add seeds for Claude Code up to 2.1.272 (#1780)

0bb7846a803d07be809d2cbd5220ad78aa8503c56eddb3efcd5c5dea8c29beed  -

A packages/gateway/src/codex-rate-limits.ts
M packages/gateway/src/pipeline.ts
M packages/gateway/src/recall.ts
M packages/gateway/src/stream/openai-responses.ts
M packages/gateway/src/translate/openai-responses.ts
M packages/gateway/test/codex-usage-metadata.test.ts
M packages/gateway/test/openai-responses-recall-aware-stream.test.ts
M packages/gateway/test/pipeline-streaming.test.ts
M packages/gateway/test/recall-buffered-transaction.test.ts
M packages/gateway/test/recall-exhaustion.test.ts
M packages/gateway/test/recall.test.ts

Found 12 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
  Line 7845:     retryPrincipal?: (input: {

  Line 7900:   const publicCodexRateLimits: Array<Record<string, unknown>> = [];

  Line 10041:         let principalRetrySucceededReported = false;

  Line 10266:                   publicCodexRateLimits,

  Line 10438:                 !principalRetrySucceededReported

  Line 10440:                 principalRetrySucceededReported = true;

  Line 10874:                                 publicCodexRateLimits,

  Line 11531:                 opts.retryPrincipal !== undefined &&

  Line 11559:               const retryPrincipal = opts.retryPrincipal;

  Line 11560:               if (!retryPrincipal) throw error;

  Line 11564:                 retryResponse = await retryPrincipal({

  Line 18866:               retryPrincipal: async ({ signal }) => {

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9990:           afterEnqueue?.();
9991:           return true;
9992:         };
9993:         const enqueuePrincipal = async (
9994:           chunk: Uint8Array,
9995:           emitsOrdinaryTool = false,
9996:           afterEnqueue?: () => void,
9997:         ): Promise<boolean> =>
9998:           safeEnqueue(chunk, () => {
9999:             principalEventEmitted = true;
10000:             if (emitsOrdinaryTool) ordinaryToolEmitted = true;
10001:             afterEnqueue?.();
10002:           });
10003:         const safeClose = (): void => {
10004:           cleanupAbort();
10005:           if (cancelled) return;
10006:           try {
10007:             controller.close();
10008:           } catch {
10009:             // Already closed/cancelled
10010:           }
10011:         };
10012:         const safeError = (error: unknown): void => {
10013:           ...

<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11515:         try {
11516:           for (;;) {
11517:             try {
11518:               await runPrincipalAttempt();
11519:               break;
11520:             } catch (error) {
11521:               const isPrincipalTransportFailure =
11522:                 error instanceof SSEStreamTransportError &&
11523:                 !principalReadFinished &&
11524:                 !continuationAttempted;
11525:               const shouldRetryPrincipal =
11526:                 isPrincipalTransportFailure &&
11527:                 error.kind === "read" &&
11528:                 !principalEventEmitted &&
11529:                 !ordinaryToolEmitted &&
11530:                 !signal.aborted &&
11531:                 opts.retryPrincipal !== undefined &&
11532:                 principalTransportRetries < maxPrincipalTransportRetries;
11533:               if ...