Session 1WOHBDvviEvs

<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-embedding-runtime</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-embedding-runtime/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. ...

No files found

<path>/home/byk/Code/opencode-lore-embedding-runtime/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-embedding-runtime/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. ...

Working copy changes:
A packages/core/src/cgroup-memory.ts
M packages/core/src/embedding/local.ts
M packages/core/src/embedding/pool.ts
M packages/core/src/embedding-cap.ts
M packages/core/src/embedding-worker-types.ts
M packages/core/src/embedding-worker.ts
M packages/core/src/embedding.ts
M packages/core/src/ort-native.ts
A packages/core/test/cgroup-memory.test.ts
M packages/core/test/embedding-cap.test.ts
M packages/core/test/embedding-pool-memory.test.ts
M packages/core/test/embedding-pool.test.ts
M packages/core/test/embedding-wasm-fallback.test.ts
M packages/core/test/embedding-worker-stdio.test.ts
M packages/core/test/embedding-worker-types.test.ts
M packages/core/test/ort-native.test.ts
M packages/gateway/script/bundle.ts
M packages/gateway/script/ort-platform-package.ts
M packages/gateway/test/bundle-exports.test.ts
M packages/gateway/test/ort-platform-package.test.ts
Working copy  (@) : tmzmtlss 01e1ee40 fix/embedding-runtime-admission | fix(core): correct embedding runtime ...

tmzmtlsspstn 01e1ee401324aea61a6bf3a33ae56a344b7034c9 parents=2cbf40060c67df229731cf1b9e34d5bf22ec2145 conflict=false empty=false
pxrvwsvvkmpo 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 conflict=false empty=false

packages/core/src/cgroup-memory.ts
packages/core/src/embedding/local.ts
packages/core/src/embedding/pool.ts
packages/core/src/embedding-cap.ts
packages/core/src/embedding-worker-types.ts
packages/core/src/embedding-worker.ts
packages/core/src/embedding.ts
packages/core/src/ort-native.ts
packages/core/test/cgroup-memory.test.ts
packages/core/test/embedding-cap.test.ts
packages/core/test/embedding-pool-memory.test.ts
packages/core/test/embedding-pool.test.ts
packages/core/test/embedding-wasm-fallback.test.ts
packages/core/test/embedding-worker-stdio.test.ts
packages/core/test/embedding-worker-types.test.ts
packages/core/test/ort-native.test.ts
packages/gateway/script/bundle.ts
packages/gateway/script/ort-platform-package.ts
packages/gateway/test/bundle-exports.test.ts
packages/gateway/test/ort-platform-package.test.ts

eb8a9bc8e2c921d3f055314aa87581b3df0fc5b32955f44b4b51e4a3c5e5a1b6  -

/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool-memory.test.ts
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap-persistence.test.ts
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/local.ts</path>
<type>file</type>
<content>
1: /** Local ONNX embedding worker lifecycle. */
2: 
3: import { freemem } from "node:os";
4: import { readLinuxCgroupMemoryHeadroomBytes } from "../cgroup-memory";
5: import { db } from "../db";
6: import * as log from "../log";
7: import { vendorModelInfo } from "../embedding-vendor";
8: import { nativeIntraOpThreads } from "../ort-native";
9: import {
10:   MIN_EMBED_TOKENS,
11:   MODEL_MAX_TOKENS,
12:   backoffEmbedCap,
13:   clampFreeToContainerLimit,
14:   memoryModelEmbedCap,
15:   reconcileEmbedCap,
16:   reprobeEmbedCap,
17:   resolveMemoryHeadroom,
18:   shouldReprobeEmbedCap,
19:   type PersistedEmbedCap,
20: } from "../embedding-cap";
21: import {
22:   EMBED_OOM_EXIT_CODE,
23:   isMissingLocalStackError,
24:   isWasmFatalError,
25:   type EmbedRequest,
26:   type WorkerInbound,
27:   type WorkerOutbound,
28:   type WorkerInitData,
29: } from ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/local.ts</path>
<type>file</type>
<content>
1001:     }
1002:     try {
1003:       await this.ensureWorker();
1004:     } catch {
1005:       // Synchronous respawn failure — nothing else will settle these requests
1006:       // (the local embed path has no timeout). Reject them here.
1007:       for (const [, p] of this.pendingRequests) {
1008:         p.reject(
1009:           new LocalProviderUnavailableError(
1010:             "embedding worker respawn failed after WASM fallback",
1011:           ),
1012:         );
1013:       }
1014:       this.pendingRequests.clear();
1015:       return;
1016:     }
1017:     // Re-read through a cast: TS still has `this.worker` narrowed to null from
1018:     // the `this.worker = null` above (it can't see that ensureWorker() reassigns
1019:     // it across the await), so a direct read would be typed `never`.
1020:     const worker = this.worker as ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/pool.ts</path>
<type>file</type>
<content>
1: /** Host-owned queue and pool for local embedding workers. */
2: 
3: import { createHash } from "node:crypto";
4: import { freemem } from "node:os";
5: import { config } from "../config";
6: import * as log from "../log";
7: import {
8:   DEFAULT_MAX_EMBED_POOL,
9:   EMBED_POOL_ABS_MAX,
10:   PER_WORKER_MEM_BUDGET_BYTES,
11:   clampFreeToContainerLimit,
12: } from "../embedding-cap";
13: import {
14:   EmbeddingQueueCapacityError,
15:   EmbeddingRequestAbortedError,
16:   EmbeddingWorkerWatchdogError,
17:   type EmbeddingProvider,
18:   LocalProviderUnavailableError,
19:   WORKER_SHUTDOWN_TIMEOUT_MS,
20:   isRecallEmbed,
21: } from "./contract";
22: import {
23:   LocalProvider,
24:   availableMemoryHeadroom,
25:   clearLocalProviderLatch,
26:   constrainedMemoryLimit,
27:   localEmbeddingState,
28: } from "./local";
29: import { OwnedRetirements } from ...

Found 44 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts:
  Line 1547:   // desiredEmbedPoolSize) would mask it via the worker count. Guards the


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts:
  Line 10:   PER_WORKER_MEM_BUDGET_BYTES,

  Line 16:   desiredEmbedPoolSize,

  Line 111:     expect(PER_WORKER_MEM_BUDGET_BYTES).toBe(

  Line 114:     expect(PER_WORKER_MEM_BUDGET_BYTES).toBe(1536 * MB);

  Line 115:     expect(desiredEmbedPoolSize(3 * GB - 1)).toBe(1);

  Line 116:     expect(desiredEmbedPoolSize(3 * GB)).toBe(2);

  Line 123:     expect(desiredEmbedPoolSize(clamped)).toBe(1);

  Line 125:     expect(desiredEmbedPoolSize(7 * GB)).toBe(DEFAULT_MAX_EMBED_POOL);

  Line 144:       expect(desiredEmbedPoolSize(clamped)).toBe(

  Line 145:         desiredEmbedPoolSize(hostFree),

  Line 392: describe("desiredEmbedPoolSize", () => {

  Line 395:     expect(desiredEmbedPoolSize(0)).toBe(1);

 ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-cap.ts</path>
<type>file</type>
<content>
1: /**
2:  * Adaptive token-cap math for local ONNX embedding inference.
3:  *
4:  * Local inference OOMs on long inputs: the O(L²) attention tensor for a long
5:  * sequence blows the WASM heap, and because WASM linear memory never shrinks,
6:  * an in-process retry cannot recover. We instead cap the input sequence length
7:  * up-front and adapt that cap to the host — start from a memory-aware estimate,
8:  * and on each OOM lower the cap ×0.7 and respawn the worker on a fresh heap.
9:  *
10:  * This module holds the pure, dependency-free math so it can be unit-tested in
11:  * isolation. The stateful pieces (persistence, worker lifecycle, telemetry)
12:  * live in embedding.ts.
13:  */
14: 
15: /** Floor token cap. ...

diff --git a/packages/core/src/embedding/local.ts b/packages/core/src/embedding/local.ts
index 5c5e7e600f..32f4307b4d 100644
--- a/packages/core/src/embedding/local.ts
+++ b/packages/core/src/embedding/local.ts
@@ -1,6 +1,7 @@
 /** Local ONNX embedding worker lifecycle. */
 
 import { freemem } from "node:os";
+import { readLinuxCgroupMemoryHeadroomBytes } from "../cgroup-memory";
 import { db } from "../db";
 import * as log from "../log";
 import { vendorModelInfo } from "../embedding-vendor";
@@ -13,6 +14,7 @@
   memoryModelEmbedCap,
   reconcileEmbedCap,
   reprobeEmbedCap,
+  resolveMemoryHeadroom,
   shouldReprobeEmbedCap,
   type PersistedEmbedCap,
 } from "../embedding-cap";
@@ -76,6 +78,11 @@
   testHostFreememBytes = bytes;
 }
 
+let testAvailableMemoryBytes: number | null = null;
+export function _setAvailableMemoryForTest(bytes: number | null): void {
+  testAvailableMemoryBytes = bytes;
+}
+
 /**
  * The process's cgroup memory LIMIT in bytes (not free-within-limit), or ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/cgroup-memory.ts</path>
<type>file</type>
<content>
1: import { readFileSync } from "node:fs";
2: import { posix } from "node:path";
3: 
4: interface CgroupMembership {
5:   version: 1 | 2;
6:   path: string;
7: }
8: 
9: interface CgroupMemoryFiles {
10:   version: 1 | 2;
11:   directory: string;
12:   mountPoint: string;
13:   root: string;
14: }
15: 
16: type ReadTextFile = (path: string) => string;
17: 
18: function readTextFile(path: string): string {
19:   return readFileSync(path, "utf8");
20: }
21: 
22: function decodeProcPath(value: string): string | null {
23:   const decoded = value.replace(/\\([0-7]{3})/g, (_match, octal: string) =>
24:     String.fromCharCode(Number.parseInt(octal, 8)),
25:   );
26:   if (!decoded.startsWith("/") || decoded.includes("\0")) return null;
27:   if (decoded.split("/").includes("..")) return null;
28:   return posix.normalize(decoded);
29: }
30: 
31: function ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/cgroup-memory.ts</path>
<type>file</type>
<content>
180:             const limit = readLimit(readText(posix.join(directory, limitFile)));
181:             if (limit === undefined) return undefined;
182:             if (Number.isFinite(limit)) {
183:               const candidate = Math.max(0, limit - usage);
184:               headroom =
185:                 headroom === undefined
186:                   ? candidate
187:                   : Math.min(headroom, candidate);
188:             }
189:           }
190:         } catch {
191:           // The cgroup v2 root cannot itself be resource-controlled and may omit
192:           // memory.current/high/max. Every descendant boundary still must be
193:           // readable so sibling usage is never subtracted from the wrong scope.
194:           if (
195:             files.version === 2 &&
196:             directory === files.mountPoint &&
197:             files.root ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts</path>
<type>file</type>
<content>
1: import { describe, it, expect } from "vitest";
2: import {
3:   BACKFILL_MIN_AUTO_DUTY,
4:   BACKFILL_THROTTLE_MAX_SLEEP_MS,
5:   DEFAULT_MAX_EMBED_POOL,
6:   EMBED_POOL_ABS_MAX,
7:   EMBED_WORKER_RESIDENT_RESERVE_BYTES,
8:   MIN_EMBED_TOKENS,
9:   MODEL_MAX_TOKENS,
10:   PER_WORKER_MEM_BUDGET_BYTES,
11:   EMBED_TOKEN_CEILING,
12:   backfillThrottleSleepMs,
13:   backoffEmbedCap,
14:   clampEmbedCap,
15:   clampFreeToContainerLimit,
16:   desiredEmbedPoolSize,
17:   memoryModelEmbedCap,
18:   reconcileEmbedCap,
19:   reprobeEmbedCap,
20:   resolveBackfillCpuDuty,
21:   resolveMemoryHeadroom,
22:   shouldReprobeEmbedCap,
23: } from "../src/embedding-cap";
24: 
25: const GB = 1024 * 1024 * 1024;
26: const MB = 1024 * 1024;
27: 
28: describe("clampFreeToContainerLimit", () => {
29:   it("is a no-op when unconstrained (constrained <= 0)", () => {
30:     // ...

Found 36 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-self-heal.test.ts:
  Line 11: // It re-probes recoverable causes on a slow cadence but never the terminal

  Line 28:   it("primes on the first call, then re-probes a recoverable latch after the interval", () => {

  Line 33:     // First call primes the clock — no re-probe yet.

  Line 45:   it("never re-probes the terminal missing-stack cause", () => {

  Line 49:     // Even long after the interval, a missing stack is never re-probed.


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding.test.ts:
  Line 361:   // the OPTIMISTIC pre-probe state (isAvailable() === true). Without this


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts:
  Line 19:   reprobeEmbedCap,

  Line 277:   it("re-probes upward via the model when memory has materially grown", () => {

  Line 305:   it("never re-probes up to or past a persisted known-bad cap ...

Found 1 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/pool.ts:
  Line 292:     const provider = new LocalProvider(

 RUN  v4.1.8 /home/byk/Code/opencode-lore-embedding-runtime

 ❯ packages/core/test/embedding-cap.test.ts (62 tests | 1 failed) 44ms
     × always accepts finite Node headroom without a hard limit 11ms
 ❯ packages/core/test/embedding-pool-memory.test.ts (5 tests | 1 failed) 1881ms
     × uses the token floor when cgroup accounting fails without a hard limit 9ms

⎯⎯⎯⎯⎯⎯⎯ Failed Tests 2 ⎯⎯⎯⎯⎯⎯⎯

 FAIL  packages/core/test/embedding-cap.test.ts > resolveMemoryHeadroom > always accepts finite Node headroom without a hard limit
AssertionError: expected undefined to be 7516192768 // Object.is equality

- Expected:
7516192768

+ Received:
undefined

 ❯ packages/core/test/embedding-cap.test.ts:102:57
    100|
    101|   it("always accepts finite Node headroom without a hard limit", () =>…
    102|     expect(resolveMemoryHeadroom(0, undefined, 7 * GB)).toBe(7 * GB);
       |                                                         ^
    103|     expect(resolveMemoryHeadroom(Number.NaN, ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/owned-retirements.ts</path>
<type>file</type>
<content>
1: /** Own asynchronous retirement operations until they settle. */
2: export class OwnedRetirements<Owner extends object> {
3:   private readonly active = new Set<Promise<void>>();
4:   private readonly owners = new WeakSet<Owner>();
5:   private readonly errors: unknown[] = [];
6: 
7:   get size(): number {
8:     return this.active.size;
9:   }
10: 
11:   track(operation: Promise<void>): Promise<void> {
12:     const active = this.active;
13:     const errors = this.errors;
14:     let tracked: Promise<void>;
15:     tracked = operation
16:       .then(
17:         () => {},
18:         (error: unknown) => {
19:           errors.push(error);
20:         },
21:       )
22:       .finally(() => active.delete(tracked));
23:     active.add(tracked);
24:     return operation;
25:   }
26: 
27:   /** Start at most one retirement operation for an owned resource. ...

Found 10 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-worker.ts:
  Line 54:  * Main-thread-owned input token cap (see `WorkerInitData.maxTokens`). Every

  Line 61: const maxTokens = init.maxTokens ?? 2048;

  Line 457:   // raw .ts and can't value-import ort-native — see maxTokens above), a strict

  Line 628:  * Only texts exceeding `maxTokens` chars are checked — at worst-case

  Line 631: function truncateTexts(texts: string[], maxTokens: number): string[] {

  Line 635:     if (text.length <= maxTokens) return text;

  Line 639:     if (ids.length <= maxTokens) return text;

  Line 640:     return tk.decode(ids.slice(0, maxTokens), {

  Line 771:     const effectiveMax = req.maxTokens ?? maxTokens;

  Line 787:       const effectiveMax = req.maxTokens ?? maxTokens;

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-worker.ts</path>
<type>file</type>
<content>
40: }
41: const port = parentPort;
42: 
43: const init = workerData as WorkerInitData;
44: const { modelId, dimensions, vendorModel } = init;
45: // Force the bundled WASM ONNX Runtime, skipping native-addon resolution (see
46: // WorkerInitData.forceWasm). Set by the main thread only when respawning after a
47: // native worker posted `init-needs-wasm` (#1379). Default false = prefer native.
48: const forceWasm = init.forceWasm ?? false;
49: // Snapshot of the host's stderr-silence state (see WorkerInitData). When true,
50: // every diagnostic below stays off stderr so it can't corrupt the host's TUI.
51: const stderrSilenced = init.stderrSilenced ?? false;
52: 
53: /**
54:  * Main-thread-owned input token cap (see `WorkerInitData.maxTokens`). ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-worker.ts</path>
<type>file</type>
<content>
620: }
621: 
622: // ---------------------------------------------------------------------------
623: // Embed processing
624: // ---------------------------------------------------------------------------
625: 
626: /**
627:  * Truncate texts to a maximum number of tokens using the real tokenizer.
628:  * Only texts exceeding `maxTokens` chars are checked — at worst-case
629:  * ~1 char/token, shorter texts can never exceed the limit.
630:  */
631: function truncateTexts(texts: string[], maxTokens: number): string[] {
632:   const tk = tokenizer;
633:   if (!tk) return texts;
634:   return texts.map((text) => {
635:     if (text.length <= maxTokens) return text;
636:     // Exclude [CLS]/[SEP] special tokens so ids.length reflects pure content
637:     // token count — otherwise the 2 extra tokens skew the limit check.
638:     const ids = tk.encode(text, { ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool-memory.test.ts</path>
<type>file</type>
<content>
1: import { afterEach, beforeEach, describe, expect, it } from "vitest";
2: import { EventEmitter } from "node:events";
3: import type { Worker } from "node:worker_threads";
4: import {
5:   embed,
6:   _persistEmbedCap,
7:   _resetLocalProviderProbe,
8:   _restoreProvider,
9:   _saveAndClearProvider,
10:   _setConstrainedMemoryForTest,
11:   _setContainerFreeForTest,
12:   _setAvailableMemoryForTest,
13:   _setEmbedPoolSizeForTest,
14:   _setPoolFreememForTest,
15:   _setTestWorkerFactory,
16: } from "../src/embedding";
17: import {
18:   MIN_EMBED_TOKENS,
19:   backoffEmbedCap,
20:   memoryModelEmbedCap,
21: } from "../src/embedding-cap";
22: import { EMBED_OOM_EXIT_CODE } from "../src/embedding-worker-types";
23: 
24: // Regression suite for the embedding-pool OOM that SIGKILLed the whole gateway
25: // (Onur's report): the pool grew to N workers, ...

Found 15 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool-memory.test.ts:
  Line 19:   backoffEmbedCap,

  Line 241:       backoffEmbedCap(first.maxTokens),


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts:
  Line 13:   backoffEmbedCap,

  Line 177: describe("backoffEmbedCap", () => {

  Line 179:     expect(backoffEmbedCap(MODEL_MAX_TOKENS)).toBe(Math.round(8192 * 0.7)); // 5734

  Line 180:     expect(backoffEmbedCap(1000)).toBe(700);

  Line 184:     expect(backoffEmbedCap(MIN_EMBED_TOKENS)).toBe(MIN_EMBED_TOKENS);

  Line 186:     expect(backoffEmbedCap(300)).toBe(MIN_EMBED_TOKENS);

  Line 193:       const next = backoffEmbedCap(cap);

  Line 201:     expect(backoffEmbedCap(cap)).toBe(MIN_EMBED_TOKENS);


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-oom-recovery.test.ts:
  Line 18:   backoffEmbedCap,

  Line 143:     ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap-persistence.test.ts</path>
<type>file</type>
<content>
1: import { describe, it, expect, beforeEach } from "vitest";
2: import { db } from "../src/db";
3: import { _persistEmbedCap, _readPersistedEmbedCap } from "../src/embedding";
4: 
5: // Mirrors EMBED_CAP_KV_KEY in embedding.ts (private). Only used to seed corrupt
6: // rows for the guard tests below.
7: const KV_KEY = "lore:embedding_cap";
8: 
9: function writeRaw(value: string): void {
10:   db()
11:     .query(
12:       "INSERT INTO kv_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?",
13:     )
14:     .run(KV_KEY, value, value);
15: }
16: 
17: describe("embedding cap persistence", () => {
18:   beforeEach(() => {
19:     db().query("DELETE FROM kv_meta WHERE key = ?").run(KV_KEY);
20:   });
21: 
22:   it("returns null when no cap is persisted", () => {
23:     expect(_readPersistedEmbedCap()).toBeNull();
24:   ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
720:     await flush();
721:     expect(fakes).toHaveLength(3);
722:     expect(fakes[2].embedIds).toHaveLength(1);
723:     fakes[0].completeNext();
724:     fakes[2].completeNext();
725:     await Promise.all([firstQueued, secondQueued]);
726:   });
727: 
728:   it("normalizes an initialization watchdog at the readiness boundary", async () => {
729:     _setEmbedPoolSizeForTest(1);
730:     _setEmbeddingWorkerWatchdogsForTest(10, 60_000);
731:     installFakeWorkers();
732: 
733:     const outcome = await settle(ensureEmbeddingReady({ deadlineMs: 1_000 }));
734:     expect(outcome.ok).toBe(false);
735:     if (!outcome.ok) {
736:       expect(outcome.err).toBeInstanceOf(LocalProviderUnavailableError);
737:       expect(outcome.err).not.toBeInstanceOf(EmbeddingWorkerWatchdogError);
738:       expect((outcome.err as Error & { cause?: unknown ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
1: import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
2: import { EventEmitter } from "node:events";
3: import type { Worker } from "node:worker_threads";
4: import {
5:   embed,
6:   embedInTokenBatches,
7:   EmbeddingQueueCapacityError,
8:   EmbeddingRequestAbortedError,
9:   EmbeddingWorkerWatchdogError,
10:   ensureEmbeddingReady,
11:   isAvailable,
12:   LocalProviderUnavailableError,
13:   recallEmbedsInFlight,
14:   resetProvider,
15:   shutdownProvider,
16:   _configuredEmbedPoolSize,
17:   _getLocalInitRetryAtForTest,
18:   _resetLocalProviderProbe,
19:   _resetProviderShutdownTrackingForTest,
20:   _restoreProvider,
21:   _saveAndClearProvider,
22:   _setConstrainedMemoryForTest,
23:   _setAvailableMemoryForTest,
24:   _setEmbedPoolSizeForTest,
25:   _setEmbeddingWorkerWatchdogsForTest,
26:   ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-oom-recovery.test.ts</path>
<type>file</type>
<content>
1: import { afterEach, beforeEach, describe, expect, it } from "vitest";
2: import { EventEmitter } from "node:events";
3: import type { Worker } from "node:worker_threads";
4: import {
5:   embed,
6:   isAvailable,
7:   LocalProviderUnavailableError,
8:   _persistEmbedCap,
9:   _readPersistedEmbedCap,
10:   _resetLocalProviderProbe,
11:   _restoreProvider,
12:   _saveAndClearProvider,
13:   _setConstrainedMemoryForTest,
14:   _setContainerFreeForTest,
15:   _setTestWorkerFactory,
16: } from "../src/embedding";
17: import {
18:   backoffEmbedCap,
19:   MIN_EMBED_TOKENS,
20:   EMBED_TOKEN_CEILING,
21: } from "../src/embedding-cap";
22: import { EMBED_OOM_EXIT_CODE } from "../src/embedding-worker-types";
23: import { isStderrSilenced, silenceStderr } from "../src/log";
24: 
25: // Exercises the stateful OOM-recovery lifecycle in LocalProvider that the ...

Found 3 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/pool.ts:
  Line 84:   healthy: boolean;

  Line 308:       healthy: false,

  Line 551:     slot.healthy = true;

Found 5 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/local.ts:
  Line 139: function persistEmbedCap(

  Line 177: export function _persistEmbedCap(

  Line 182:   persistEmbedCap(cap, freeMemBytes, knownBadCap);

  Line 791:     persistEmbedCap(next, free, this.lastOomCap);

  Line 857:     persistEmbedCap(capAfter, free, this.lastOomCap);

Found 26 matches
/home/byk/Code/opencode-lore-embedding-runtime/.lore.md:
  Line 29: * **Embedding token batching and temporal chunk cap**: Use embedInTokenBatches for all embedding paths, including temporal messages, to prevent ONNX padding all inputs to the longest sequence and causing OOM. Batch by token area (MAX\_BATCH\_TOKEN\_AREA 4096), but always admit the first item so the loop progresses. Preserve input order and call storeTemporalChunks once. Cap temporal chunks at 64: retain the first 63 and join the remainder into one tail; an oversized tail may occupy its own batch and is truncated downstream.

  Line 38: * **embedding worker stdio drain**: Chose silently calling \`resume()\` on owned embedding-worker stdout/stderr over logging sanitized or rate-limited lines because native dependencies can emit model paths, provider diagnostics, IDs, and process state, while every core log reaches persistent storage and \`LogSink\`. ...

 RUN  v4.1.8 /home/byk/Code/opencode-lore-embedding-runtime


 Test Files  2 passed (2)
      Tests  13 passed (13)
   Start at  09:37:10
   Duration  2.89s (transform 1.34s, setup 1.00s, import 854ms, tests 3.33s, environment 0ms)

Working copy changes:
A packages/core/src/cgroup-memory.ts
M packages/core/src/embedding/local.ts
M packages/core/src/embedding/pool.ts
M packages/core/src/embedding-cap.ts
M packages/core/src/embedding-worker-types.ts
M packages/core/src/embedding-worker.ts
M packages/core/src/embedding.ts
M packages/core/src/ort-native.ts
A packages/core/test/cgroup-memory.test.ts
M packages/core/test/embedding-cap.test.ts
M packages/core/test/embedding-pool-memory.test.ts
M packages/core/test/embedding-pool.test.ts
M packages/core/test/embedding-wasm-fallback.test.ts
M packages/core/test/embedding-worker-stdio.test.ts
M packages/core/test/embedding-worker-types.test.ts
M packages/core/test/ort-native.test.ts
M packages/gateway/script/bundle.ts
M packages/gateway/script/ort-platform-package.ts
M packages/gateway/test/bundle-exports.test.ts
M packages/gateway/test/ort-platform-package.test.ts
Working copy  (@) : tmzmtlss 6a5b70c9 fix/embedding-runtime-admission | fix(core): correct embedding runtime ...

tmzmtlsspstn 6a5b70c9ee77ac9387a28be6865a1bb3d21cd577 parents=2cbf40060c67df229731cf1b9e34d5bf22ec2145 conflict=false empty=false
pxrvwsvvkmpo 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 conflict=false empty=false

ab8a298011cb88a89aa2ac41f70ad718afc296605e867007d1c298f679f43b5f  -

(no output)

packages/core/src/cgroup-memory.ts

a781cff720fd7624addc687a1830db1cbebde9153c10bd961dc08ecbe374b9f7  -

 RUN  v4.1.8 /home/byk/Code/opencode-lore-embedding-runtime

 ❯ packages/core/test/embedding-cap.test.ts (62 tests | 1 failed) 66ms
     × always accepts finite Node headroom without a hard limit 16ms
 ❯ packages/core/test/embedding-pool-memory.test.ts (5 tests | 1 failed) 1001ms
     × uses the token floor when cgroup accounting fails without a hard limit 11ms

 Test Files  2 failed | 1 passed (3)
      Tests  2 failed | 122 passed (124)
   Start at  09:39:48
   Duration  2.91s (transform 1.52s, setup 1.32s, import 1.45s, tests 2.54s, environment 0ms)


⎯⎯⎯⎯⎯⎯⎯ Failed Tests 2 ⎯⎯⎯⎯⎯⎯⎯

 FAIL  packages/core/test/embedding-cap.test.ts > resolveMemoryHeadroom > always accepts finite Node headroom without a hard limit
AssertionError: expected undefined to be 7516192768 // Object.is equality

- Expected:
7516192768

+ Received:
undefined

 ❯ packages/core/test/embedding-cap.test.ts:102:57
    100|
    101|   it("always accepts finite Node headroom without a hard limit", () =>…
    102|    ...

false false false

{"reprobe":3000,"infiniteFree":null}

freeFinite=false backoffFinite=false backoffNaN=true

256

6a5b70c9ee77ac9387a28be6865a1bb3d21cd577 parent=2cbf40060c67df229731cf1b9e34d5bf22ec2145 conflict=false
a781cff720fd7624addc687a1830db1cbebde9153c10bd961dc08ecbe374b9f7  -
packages/core/src/cgroup-memory.ts
packages/core/src/embedding/local.ts
packages/core/src/embedding/pool.ts
packages/core/src/embedding-cap.ts
packages/core/src/embedding-worker-types.ts
packages/core/src/embedding-worker.ts
packages/core/src/embedding.ts
packages/core/src/ort-native.ts
packages/core/test/cgroup-memory.test.ts
packages/core/test/embedding-cap.test.ts
packages/core/test/embedding-pool-memory.test.ts
packages/core/test/embedding-pool.test.ts
packages/core/test/embedding-wasm-fallback.test.ts
packages/core/test/embedding-worker-stdio.test.ts
packages/core/test/embedding-worker-types.test.ts
packages/core/test/ort-native.test.ts
packages/gateway/script/bundle.ts
packages/gateway/script/ort-platform-package.ts
packages/gateway/test/bundle-exports.test.ts
packages/gateway/test/ort-platform-package.test.ts

6a5b70c9ee77ac9387a28be6865a1bb3d21cd577 parent=2cbf40060c67df229731cf1b9e34d5bf22ec2145 conflict=false
a781cff720fd7624addc687a1830db1cbebde9153c10bd961dc08ecbe374b9f7  -