Session 0CNxVkKH1COG

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

/home/byk/Code/opencode-lore-embedding-runtime/AGENTS.md

No files found

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

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

Found 100 matches (more matches available)
/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, mountInfo)).toEqual({

  Line 80:       resolveLinuxCgroupMemoryFiles("0::/tenant/job\n", mountInfo),

  Line 90:     expect(resolveLinuxCgroupMemoryFiles("bad", "bad")).toBeNull();

  Line 92:       resolveLinuxCgroupMemoryFiles(

  Line 98:       resolveLinuxCgroupMemoryFiles(

  Line 128:     expect(readLinuxCgroupMemoryHeadroomBytes(readText)).toBe(100);

  Line 154:     expect(readLinuxCgroupMemoryHeadroomBytes(readText)).toBe(50);

  Line 180:     expect(readLinuxCgroupMemoryHeadroomBytes(readText)).toBeUndefined();

  ...

Found 11 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-cap.ts:
  Line 125: export function desiredEmbedPoolSize(


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/pool.ts:
  Line 285:     const headroom = availableMemoryHeadroom();


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/local.ts:
  Line 99: export function availableMemoryHeadroom(): number | undefined {

  Line 130: function containerFreeBytes(): number {

  Line 135:     availableMemoryHeadroom(),

  Line 141:   freeMemBytes: number = containerFreeBytes(),

  Line 164:   const free = containerFreeBytes() / Math.max(1, memDivisor);

  Line 567:     this.capFreememAtLearn = containerFreeBytes();

  Line 571:     const liveCap = memoryModelEmbedCap(containerFreeBytes() / this.memDivisor);

  Line 868:     const free = containerFreeBytes();

  Line 937:     const free = containerFreeBytes();

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/cgroup-memory.test.ts</path>
<type>file</type>
<content>
1: import { describe, expect, it } from "vitest";
2: import {
3:   readLinuxCgroupMemoryHeadroomBytes,
4:   resolveLinuxCgroupMemoryFiles,
5: } from "../src/cgroup-memory";
6: 
7: describe("Linux cgroup memory usage", () => {
8:   it("resolves cgroup v2 from the process mount rather than a fixed path", () => {
9:     expect(
10:       resolveLinuxCgroupMemoryFiles(
11:         "0::/system.slice/opencode.service\n",
12:         "25 20 0:22 / /run/my-cgroup rw - cgroup2 cgroup2 rw\n",
13:       ),
14:     ).toEqual({
15:       version: 2,
16:       directory: "/run/my-cgroup/system.slice/opencode.service",
17:       mountPoint: "/run/my-cgroup",
18:       root: "/",
19:     });
20:   });
21: 
22:   it("resolves namespaced cgroup v2 and escaped mount paths", () => {
23:     expect(
24:       resolveLinuxCgroupMemoryFiles(
25:         "0::/worker.slice\n",
26:   ...

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

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-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 e6d0f1ed fix/embedding-runtime-admission | fix(core): correct embedding runtime selection and admission
Parent commit (@-): pxrvwsvv 2cbf4006 main | feat(cch): add seeds for Claude Code ...

@  tmzmtlsspstn e6d0f1edc850
│  pxrvwsvvkmpo 2cbf40060c67
~

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

Found 25 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/cgroup-memory.test.ts:
  Line 275:   it("reads v1 headroom and treats its oversized unlimited sentinel as max", () => {


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts:
  Line 792:   it("stays at a single worker when current cgroup headroom can't fit a second", async () => {

  Line 815:   it("reserves headroom while an admitted worker is still starting", async () => {

  Line 829:     // completed initialization, the same headroom must not be spent again.

  Line 1601:     _setPoolFreememForTest(0); // no headroom → ceiling 1


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool-memory.test.ts:
  Line 149:   it("uses the token floor when constrained primary-worker headroom is unknown", async () => {


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts:
  Line 56:   it("clamps to current cgroup ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
150:   return p.then(
151:     (value) => ({ ok: true as const, value }),
152:     (err) => ({ ok: false as const, err }),
153:   );
154: }
155: 
156: async function warmPool(fakes: FakeWorker[]): Promise<void> {
157:   const warm = embed(["bootstrap"], "document");
158:   await flush();
159:   expect(fakes).toHaveLength(1);
160:   fakes[0].completeAll();
161:   await warm;
162: }
163: 
164: describe("EmbeddingPool dispatch (#999)", () => {
165:   let savedProvider: unknown;
166:   let savedVoyage: string | undefined;
167:   let savedOpenAI: string | undefined;
168:   let savedPoolEnv: string | undefined;
169:   let savedNodeEnv: string | undefined;
170: 
171:   beforeEach(() => {
172:     // Force the local provider (no remote fallback) and a fresh instance.
173:     savedVoyage = process.env.VOYAGE_API_KEY;
174:     savedOpenAI = ...

<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/src/embedding/local.ts</path>
<type>file</type>
<content>
1120:           error instanceof Error
1121:             ? error.message
1122:             : "embedding worker died during WASM resubmit";
1123:         this.handleInitError(errorMsg);
1124:         return;
1125:       }
1126:     }
1127:     this.updateWorkerRef();
1128:   }
1129: 
1130:   private trackRetiredWorkerTermination(worker: ShutdownableWorker): void {
1131:     void this.retiredWorkers.retireOnce(worker, async () => {
1132:       await worker.terminate();
1133:     });
1134:   }
1135: 
1136:   private async settleRetiredWorkers(timeoutMs: number): Promise<void> {
1137:     await this.retiredWorkers.settle({
1138:       timeoutMs,
1139:       timeoutMessage:
1140:         "retired embedding worker did not settle before shutdown deadline",
1141:       failureMessage: "embedding worker termination was not confirmed",
1142:     });
1143:   }
1144: 
1145: ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts</path>
<type>file</type>
<content>
380:   });
381: 
382:   it("never re-probes up to or past a known-bad cap", () => {
383:     // Huge free pool would step 2000 → 2857, but 2400 OOMed before → ceiling 2399.
384:     expect(reprobeEmbedCap(2000, 64 * GB, 2400)).toBe(2399);
385:     // The gentle step lands below the known-bad ceiling → unaffected.
386:     expect(reprobeEmbedCap(1000, 64 * GB, 5000)).toBe(Math.round(1000 / 0.7));
387:     // Already at ceiling−1 → no upward movement (never re-OOMs the same cap).
388:     expect(reprobeEmbedCap(2399, 64 * GB, 2400)).toBe(2399);
389:   });
390: });
391: 
392: describe("desiredEmbedPoolSize", () => {
393:   it("returns 1 when free memory can't fit a second worker budget", () => {
394:     // A single per-worker budget (~1.13GB) or less → only the primary worker.
395:     expect(desiredEmbedPoolSize(0)).toBe(1);
396:     ...

{"hybrid":{"version":2,"directory":"/run/unified/unified","mountPoint":"/run/unified","root":"/"},"multipleDirectHeadroom":1400}

dd2f98daaa44045bd67adf4d8f28ebb5bd28f488109795b4ffc48bd3b3dababf  packages/core/src/cgroup-memory.ts
3b14b32d6ca6c9b76a0ac4a7586cea674fc6e6b841aa7d7fcc1870e2be497593  packages/core/src/embedding/local.ts
c032d9990b6b7cc62d4fb41a5ce907d8988d846fc14393e2b287fcd16fb3c9bf  packages/core/src/embedding/pool.ts
5935754a015c253946e8bd46a7ce0907cd324cba863236770b2685fa2e36b20b  packages/core/src/embedding-cap.ts
f2f2efe2bf18841247174c7107594d1e73c55cd16f90b06ac3efd3621f54933e  packages/core/test/cgroup-memory.test.ts
dd3ceed23b7967634d047a60dd47bcab0c3f0ea759c12d703422a40e3e2af3d5  packages/core/test/embedding-cap.test.ts
c511e60ed46f4fd248b229b36a39099508dfe4129fadeb05beefa72e0c7e891d  packages/core/test/embedding-pool-memory.test.ts
00fd39baf0c0a8545f3e42cb8edb8a80842556b0b8d4b5c209e991a748f88dd6  packages/core/test/embedding-pool.test.ts

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-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 e6d0f1ed fix/embedding-runtime-admission | fix(core): correct embedding runtime selection and admission
Parent commit (@-): pxrvwsvv 2cbf4006 main | feat(cch): add seeds for Claude Code ...