Session 06yaMbbbr72K

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

<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 8888d203 fix/embedding-runtime-admission | fix(core): correct embedding runtime ...

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

packages/core/src/cgroup-memory.ts                 | 205 +++++++++
packages/core/src/embedding/local.ts               | 146 +++----
packages/core/src/embedding/pool.ts                |  18 +-
packages/core/src/embedding-cap.ts                 |  77 ++-
packages/core/src/embedding-worker-types.ts        |  18 +-
packages/core/src/embedding-worker.ts              |  27 +-
packages/core/src/embedding.ts                     |   1 +
packages/core/src/ort-native.ts                    | 256 +++++++++++-
packages/core/test/cgroup-memory.test.ts           | 297 ++++++++++++++
packages/core/test/embedding-cap.test.ts           |  75 ++-
packages/core/test/embedding-pool-memory.test.ts   |  23 +-
packages/core/test/embedding-pool.test.ts          |  69 +++
packages/core/test/embedding-wasm-fallback.test.ts |  60 +-
packages/core/test/embedding-worker-stdio.test.ts  |  46 +-
packages/core/test/embedding-worker-types.test.ts  |  41 +
packages/core/test/ort-native.test.ts              | 478 ...

tmzmtlsspstn 8888d203b173
fix(core): correct embedding runtime selection and admission
134d3de918ab

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

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

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/local.ts</path>
<type>file</type>
<content>
760:     return this.initPromise;
761:   }
762: 
763:   private updateWorkerRef(): void {
764:     if (!this.worker) return;
765:     if (this.pendingRequests.size > 0) {
766:       this.worker.ref();
767:     } else {
768:       this.worker.unref();
769:     }
770:   }
771: 
772:   private maybeReprobeCap(): void {
773:     const now = Date.now();
774:     if (now - this.lastReprobeAt < EMBED_REPROBE_INTERVAL_MS) return;
775:     this.lastReprobeAt = now;
776:     const free = containerFreeBytes();
777:     if (!shouldReprobeEmbedCap(free, this.capFreememAtLearn)) return;
778:     // The re-probe ceiling is the memory model over this worker's pool SHARE of
779:     // free memory, so climbing back up never lets N workers sum past the host's
780:     // RAM. The ratio check above stays on undivided free (it only compares
781:     // now-vs-learn, both ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/pool.ts</path>
<type>file</type>
<content>
577:   private async runOperation(
578:     operation: PoolOperation,
579:     slot: EmbedSlot,
580:   ): Promise<void> {
581:     let watchdogTimer: ReturnType<typeof setTimeout> | undefined;
582:     let rejectWatchdog!: (error: Error) => void;
583:     const watchdog = new Promise<never>((_resolve, reject) => {
584:       rejectWatchdog = reject;
585:     });
586:     const armWatchdog = (
587:       stage: "init" | "execution",
588:       timeoutMs: number,
589:     ): void => {
590:       if (watchdogTimer) clearTimeout(watchdogTimer);
591:       watchdogTimer = setTimeout(
592:         () => {
593:           log.error(
594:             `embedding worker watchdog expired: stage=${stage} timeout_ms=${timeoutMs}`,
595:           );
596:           rejectWatchdog(new EmbeddingWorkerWatchdogError(stage));
597:         },
598:         Math.max(1, timeoutMs),
599:  ...

diff --git a/packages/core/src/cgroup-memory.ts b/packages/core/src/cgroup-memory.ts
new file mode 100644
index 0000000000..57d6fa9940
--- /dev/null
+++ b/packages/core/src/cgroup-memory.ts
@@ -0,0 +1,205 @@
+import { readFileSync } from "node:fs";
+import { posix } from "node:path";
+
+interface CgroupMembership {
+  version: 1 | 2;
+  path: string;
+}
+
+interface CgroupMemoryFiles {
+  version: 1 | 2;
+  directory: string;
+  mountPoint: string;
+  root: string;
+}
+
+type ReadTextFile = (path: string) => string;
+
+function readTextFile(path: string): string {
+  return readFileSync(path, "utf8");
+}
+
+function decodeProcPath(value: string): string | null {
+  const decoded = value.replace(/\\([0-7]{3})/g, (_match, octal: string) =>
+    String.fromCharCode(Number.parseInt(octal, 8)),
+  );
+  if (!decoded.startsWith("/") || decoded.includes("\0")) return null;
+  if (decoded.split("/").includes("..")) return null;
+  return posix.normalize(decoded);
+}
+
+function ...

Found 53 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts:
  Line 23:   _setAvailableMemoryForTest,

  Line 194:     _setAvailableMemoryForTest(null);

  Line 796:     _setAvailableMemoryForTest(23 * 1024 * 1024);

  Line 819:     _setAvailableMemoryForTest(1600 * 1024 * 1024);


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool-memory.test.ts:
  Line 12:   _setAvailableMemoryForTest,

  Line 114:     _setAvailableMemoryForTest(null);

  Line 154:     _setAvailableMemoryForTest(Number.NaN);


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/cgroup-memory.test.ts:
  Line 3:   readLinuxCgroupMemoryHeadroomBytes,

  Line 4:   resolveLinuxCgroupMemoryFiles,

  Line 10:       resolveLinuxCgroupMemoryFiles(

  Line 24:       resolveLinuxCgroupMemoryFiles(

  Line 47:     expect(resolveLinuxCgroupMemoryFiles(cgroup, mountInfo)).toEqual({

  Line 65:     expect(resolveLinuxCgroupMemoryFiles(cgroup, ...

Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/temporal-embedding-queue.test.ts:
  Line 35:   reject: (error: unknown) => void;

  Line 40:   let reject!: (error: unknown) => void;

  Line 48: let savedProvider: unknown;

  Line 836:       .all(shortId, emptyId) as unknown as Array<{

  Line 895:       .all(vecId) as unknown as Array<{ chunk_id: string }>;

  Line 982:       let error: unknown;

  Line 1071:       .all(id) as unknown as Array<{ chunk_id: string }>;


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-init-retry.test.ts:
  Line 29:   postMessage(msg: unknown): void {

  Line 52:     return f as unknown as Worker;

  Line 64: ): Promise<{ ok: true; value: T } | { ok: false; err: unknown }> {

  Line 78:   let savedProvider: unknown;


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts:
  Line 34: // lazy + memory-gated growth, the broken-provider ...

diff --git a/packages/core/test/cgroup-memory.test.ts b/packages/core/test/cgroup-memory.test.ts
new file mode 100644
index 0000000000..d252879139
--- /dev/null
+++ b/packages/core/test/cgroup-memory.test.ts
@@ -0,0 +1,297 @@
+import { describe, expect, it } from "vitest";
+import {
+  readLinuxCgroupMemoryHeadroomBytes,
+  resolveLinuxCgroupMemoryFiles,
+} from "../src/cgroup-memory";
+
+describe("Linux cgroup memory usage", () => {
+  it("resolves cgroup v2 from the process mount rather than a fixed path", () => {
+    expect(
+      resolveLinuxCgroupMemoryFiles(
+        "0::/system.slice/opencode.service\n",
+        "25 20 0:22 / /run/my-cgroup rw - cgroup2 cgroup2 rw\n",
+      ),
+    ).toEqual({
+      version: 2,
+      directory: "/run/my-cgroup/system.slice/opencode.service",
+      mountPoint: "/run/my-cgroup",
+      root: "/",
+    });
+  });
+
+  it("resolves namespaced cgroup v2 and escaped mount paths", () => {
+    expect(
+      resolveLinuxCgroupMemoryFiles(
+     ...

<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:     // ...

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

<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-pool.test.ts</path>
<type>file</type>
<content>
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 }).cause).toMatchObject({
739:         name: "EmbeddingWorkerWatchdogError",
740:         stage: "init",
741:       });
742:     }
743:   });
744: 
745:   it("stays at a single worker under concurrency when memory is tight", async () => {
746:     _setEmbedPoolSizeForTest(2); // ceiling allows 2...
747:     _setPoolFreememForTest(0); // ...but no memory for a second ~680MB model
748:     const fakes ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
1500:     let resetDone = false;
1501:     const reset = resetProvider().then(() => {
1502:       resetDone = true;
1503:     });
1504:     await flush();
1505:     expect(resetDone).toBe(false);
1506:     fakes[1].exit();
1507:     await reset;
1508:     expect(resetDone).toBe(true);
1509:     expect(fakes[0].gotShutdown).toBe(true);
1510:   });
1511: 
1512:   it("LORE_EMBED_POOL_SIZE sets the ceiling (env-driven, no test override)", async () => {
1513:     process.env.LORE_EMBED_POOL_SIZE = "2";
1514:     _setPoolFreememForTest(64 * GB);
1515:     const fakes = installFakeWorkers();
1516:     await warmPool(fakes);
1517: 
1518:     const p1 = embed(["alpha"], "query");
1519:     const p2 = embed(["beta"], "query");
1520:     await flush();
1521: 
1522:     expect(fakes).toHaveLength(2);
1523:     fakes[0].completeAll();
1524:     ...

diff --git a/packages/core/src/embedding.ts b/packages/core/src/embedding.ts
index ef16a40b44..5f416c9f82 100644
--- a/packages/core/src/embedding.ts
+++ b/packages/core/src/embedding.ts
@@ -29,6 +29,7 @@
   _persistEmbedCap,
   _readPersistedEmbedCap,
   _resetLocalProviderProbe,
+  _setAvailableMemoryForTest,
   _setConstrainedMemoryForTest,
   _setContainerFreeForTest,
   _setLocalInitCooldownMsForTest,

Found 17 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts:
  Line 32:     expect(clampFreeToContainerLimit(7 * GB, 0)).toBe(7 * GB);

  Line 36:     expect(clampFreeToContainerLimit(7 * GB, Number.NaN)).toBe(7 * GB);

  Line 37:     expect(clampFreeToContainerLimit(7 * GB, -1)).toBe(7 * GB);

  Line 44:     expect(clampFreeToContainerLimit(hostFree, 12 * GB, hostFree)).toBe(

  Line 51:     expect(clampFreeToContainerLimit(7 * GB, 512 * MB, 512 * MB)).toBe(

  Line 57:     expect(clampFreeToContainerLimit(7 * GB, 12 * GB, 23 * MB)).toBe(23 * MB);

  Line 58:     expect(clampFreeToContainerLimit(7 * GB, 12 * GB, 0)).toBe(0);

  Line 62:     expect(clampFreeToContainerLimit(7 * GB, 0, 23 * MB)).toBe(23 * MB);

  Line 66:     expect(clampFreeToContainerLimit(7 * GB, 512 * MB, undefined)).toBe(0);

  Line 67:     expect(clampFreeToContainerLimit(7 * GB, 512 * MB, Number.NaN)).toBe(0);

  Line 74:           clampFreeToContainerLimit(6 * GB, ...

Found 21 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts:
  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 395:     expect(desiredEmbedPoolSize(0)).toBe(1);

  Line 396:     expect(desiredEmbedPoolSize(PER_WORKER_MEM_BUDGET_BYTES)).toBe(1);

  Line 398:     expect(desiredEmbedPoolSize(2 * PER_WORKER_MEM_BUDGET_BYTES - 1)).toBe(1);

  Line 402:     expect(desiredEmbedPoolSize(2 * PER_WORKER_MEM_BUDGET_BYTES)).toBe(

  Line 405:     expect(desiredEmbedPoolSize(64 * GB)).toBe(DEFAULT_MAX_EMBED_POOL);

  Line 409:     expect(desiredEmbedPoolSize(64 * GB, 4)).toBe(4);

  Line 411:     ...

Found 5 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts:
  Line 30:     // process.constrainedMemory() returns 0 on bare metal / VM without a cgroup

  Line 139:     // constrainedMemory() = 12 GiB, freemem in the range this box actually sees.


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-cap.ts:
  Line 145:  * `constrained` is `process.constrainedMemory()` — the cgroup memory limit in

  Line 177:  * host-wide `availableMemory()` value on Linux. When Node and cgroup accounting


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/local.ts:
  Line 88:  * / unsupported by the runtime. `process.constrainedMemory()` is libuv-backed (cgroup v1 + v2, no

/home/byk/Code/opencode-lore-embedding-runtime/node_modules/@types/node/process.d.ts
/home/byk/Code/opencode-lore-embedding-runtime/node_modules/@types/node/child_process.d.ts

Found 2 matches
/home/byk/Code/opencode-lore-embedding-runtime/node_modules/@types/node/process.d.ts:
  Line 1585:                 constrainedMemory(): number;

  Line 1591:                 availableMemory(): number;

<path>/home/byk/Code/opencode-lore-embedding-runtime/node_modules/@types/node/process.d.ts</path>
<type>file</type>
<content>
1568:                  *
1569:                  * As with `require.main`, `process.mainModule` will be `undefined` if there
1570:                  * is no entry script.
1571:                  * @since v0.1.17
1572:                  * @deprecated Since v14.0.0 - Use `main` instead.
1573:                  */
1574:                 mainModule?: Module;
1575:                 memoryUsage: MemoryUsageFn;
1576:                 /**
1577:                  * Gets the amount of memory available to the process (in bytes) based on
1578:                  * limits imposed by the OS. If there is no such constraint, or the constraint
1579:                  * is unknown, `0` is returned.
1580:                  *
1581:                  * See [`uv_get_constrained_memory`](https://docs.libuv.org/en/v1.x/misc.html#c.uv_get_constrained_memory) for more
1582:                  * ...

No files found

/usr/src/linux-headers-6.8.0-117/arch/x86/include/asm/uv/uv.h
/usr/src/linux-headers-6.8.0-117/arch/s390/include/asm/uv.h
/usr/src/linux-headers-6.8.0-139/arch/x86/include/asm/uv/uv.h
/usr/src/linux-headers-6.8.0-139/arch/s390/include/asm/uv.h

/home/byk/.volta/bin/node
{"node":"v24.16.0","uv":"1.52.1","constrained":12884901888,"available":181379072}

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
842:   it("degrades the whole provider to unavailable when a worker init-errors", async () => {
843:     _setEmbedPoolSizeForTest(1);
844:     const fakes = installFakeWorkers();
845: 
846:     const r = settle(embed(["alpha"], "query"));
847:     await flush();
848:     expect(fakes).toHaveLength(1);
849: 
850:     fakes[0].initError("model load failed");
851:     await flush();
852: 
853:     const outcome = await r;
854:     expect(outcome.ok).toBe(false);
855:     // The module-global broken latch is shared across the pool → FTS-only.
856:     expect(isAvailable()).toBe(false);
857:   });
858: 
859:   it("retires a transiently failed slot after a sibling recovers", async () => {
860:     _setEmbedPoolSizeForTest(2);
861:     _setPoolFreememForTest(64 * GB);
862:     const fakes = installFakeWorkers();
863:     await warmPool(fakes);
864: 
865:     const ...

No files found

tmzmtlsspstn 8888d203b173 fix(core): correct embedding runtime selection and admission
pxrvwsvvkmpo 2cbf40060c67 feat(cch): add seeds for Claude Code up to 2.1.272 (#1780)
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 ...