Session 0UTwdk1MrRYC

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

/home/byk/Code/opencode-lore-embedding-runtime/quality/REVIEW.md
/home/byk/Code/opencode-lore-embedding-runtime/package.json
/home/byk/Code/opencode-lore-embedding-runtime/AGENTS.md
/home/byk/Code/opencode-lore-embedding-runtime/.lore.md
/home/byk/Code/opencode-lore-embedding-runtime/.git

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

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

Found 17 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-cap.ts:
  Line 120:  * workers fit in `freeBytes` — but never below 1: the primary worker always runs

  Line 126:   freeBytes: number,

  Line 134:   const free = Number.isFinite(freeBytes) && freeBytes > 0 ? freeBytes : 0;

  Line 266: export function memoryModelEmbedCap(freeBytes: number): number {

  Line 268:     freeBytes * EMBED_MEM_FRACTION - EMBED_MODEL_BASELINE_BYTES,

  Line 291:   freeBytes: number,

  Line 298:     const ratio = stored.freeMemBytes > 0 ? freeBytes / stored.freeMemBytes : 1;

  Line 305:     return freeBytes > stored.freeMemBytes

  Line 328:   freeBytes: number,

  Line 332:     freememAtLearn > 0 && freeBytes >= freememAtLearn * EMBED_REPROBE_RATIO

  Line 356:   freeBytes: number,

  Line 360:   let ceiling = memoryModelEmbedCap(freeBytes);


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/pool.ts:
  Line 301:       // Pass the pool ...

Found 42 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/shutdown-vector-pool.test.ts:
  Line 204:     const workerCount = FakeWorker.instances.length;

  Line 205:     expect(workerCount).toBeGreaterThan(0);

  Line 210:     expect(FakeWorker.instances).toHaveLength(workerCount);

  Line 421:     const workerCount = FakeWorker.instances.length;

  Line 429:     expect(FakeWorker.instances).toHaveLength(workerCount);


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts:
  Line 1395:     const workerCount = fakes.length;

  Line 1401:     expect(fakes).toHaveLength(workerCount);


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool-memory.test.ts:
  Line 123:     // Pin the learned cap high (freeMemBytes=0 → trust band ignores host free),


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-oom-recovery.test.ts:
  Line 119:     // freeMemBytes=0 → reconcileEmbedCap ...

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

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

<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/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/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>
419: /** Local embedding provider using @huggingface/transformers with nomic-embed-text-v1.5 by default. */
420: export class LocalProvider implements EmbeddingProvider {
421:   // With inference off the main thread, large batches no longer block
422:   // the event loop. 256 maximises throughput per round-trip to the
423:   // worker. Backfill callers use token-budget-based batching (see
424:   // nextBatch) to give the worker's priority queue breathing room
425:   // for recall queries and prevent OOM on long texts.
426:   readonly maxBatchSize = 256;
427: 
428:   private worker: import("node:worker_threads").Worker | null = null;
429:   private workerReady = false;
430:   private workerInitError: string | null = null;
431:   private pendingRequests = new Map<
432:     number,
433:     {
434:       resolve: (vectors: Float32Array[]) => void;
435:       reject: ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/local.ts</path>
<type>file</type>
<content>
1000:       this.trackRetiredWorkerTermination(dead);
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 ...

Modified regular file packages/core/src/embedding/local.ts:
   1    1: /** Local ONNX embedding worker lifecycle. */
   2    2: 
   3    3: import { freemem } from "node:os";
        4: import { readLinuxCgroupMemoryHeadroomBytes } from "../cgroup-memory";
   4    5: import { db } from "../db";
   5    6: import * as log from "../log";
   6    7: import { vendorModelInfo } from "../embedding-vendor";
    ...
  13   14:   memoryModelEmbedCap,
  14   15:   reconcileEmbedCap,
  15   16:   reprobeEmbedCap,
       17:   resolveMemoryHeadroom,
  16   18:   shouldReprobeEmbedCap,
  17   19:   type PersistedEmbedCap,
  18   20: } from "../embedding-cap";
    ... ...

<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-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 58 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/vec0-cutover.test.ts:
  Line 2049:   test("reports cumulative scheduling progress across restarts", async () => {


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/tenant-isolation.test.ts:
  Line 59:   test("isolates project/global memory, entities, recall, point reads, and background sweeps after restart", async () => {

  Line 155:     // A real restart drops connection-keyed project caches before the adversary


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/temporal-identity.test.ts:
  Line 141:     "keeps the same source message isolated in tenant order %# and after restart",

  Line 474:     // A post-restart result for the second session must not rewrite main, the


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/db.test.ts:
  Line 2614:     // v43: persisted for accurate calibrated-delta estimation after restart. ...

<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 7 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding.ts:
  Line 29:   _persistEmbedCap,

  Line 40: } from "./embedding/local";

  Line 41: export type { EmbeddingFailureInfo } from "./embedding/local";

  Line 46:   _setEmbedPoolSizeForTest,

  Line 49: } from "./embedding/pool";

  Line 53:   _restoreProvider,

  Line 54:   _saveAndClearProvider,

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding.ts</path>
<type>file</type>
<content>
1: /**
2:  * Public embedding facade.
3:  *
4:  * Implementation is split by responsibility so lifecycle ownership, search,
5:  * document writes, and migrations/backfills can evolve independently without
6:  * changing the long-standing public API imported by core and gateway callers.
7:  */
8: 
9: export {
10:   EmbeddingAbortError,
11:   EmbeddingQueueCapacityError,
12:   EmbeddingRequestAbortedError,
13:   EmbeddingWorkerWatchdogError,
14:   LocalProviderUnavailableError,
15:   awaitWorkerShutdown,
16:   l2Normalize,
17: } from "./embedding/contract";
18: export type {
19:   EmbeddingAbortCode,
20:   EmbeddingAbortPhase,
21:   EmbeddingOperationOptions,
22:   EmbeddingProvider,
23:   ShutdownableWorker,
24: } from "./embedding/contract";
25: 
26: export {
27:   _getLocalInitRetryAtForTest,
28:   _markLocalProviderUnavailable,
29:   _persistEmbedCap,
30:   ...

Found 74 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/runtime.ts:
  Line 30: /** Re-open provider admission after the local self-heal cadence allows a probe. */

  Line 41: let providerAdmissionClosed = false;

  Line 42: /** Every local-provider generation remains owned until worker exit is known. */

  Line 43: const providerGenerations = new OwnedRetirements<object>();

  Line 48:   return providerGenerations.track(shutdown);

  Line 52:   await providerGenerations.settle({

  Line 57: export function getProvider(): EmbeddingProvider | null {

  Line 58:   if (providerAdmissionClosed) return null;

  Line 67:   const providerName = cfg.provider;

  Line 70:   if (providerName === "local") {

  Line 71:     cachedProvider = new EmbeddingPool(model, cfg.dimensions);

  Line 72:   } else if (providerName === "voyage" || providerName === "openai") {

  Line 73:     cachedProvider = createRemoteProvider(providerName, model, cfg.dimensions);

  Line ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/runtime.ts</path>
<type>file</type>
<content>
35:   });
36:   return true;
37: }
38: 
39: let cachedProvider: EmbeddingProvider | null | undefined;
40: /** One-way process-shutdown latch. Config resets must never reopen admission. */
41: let providerAdmissionClosed = false;
42: /** Every local-provider generation remains owned until worker exit is known. */
43: const providerGenerations = new OwnedRetirements<object>();
44: 
45: function trackProviderGenerationShutdown(
46:   shutdown: Promise<void>,
47: ): Promise<void> {
48:   return providerGenerations.track(shutdown);
49: }
50: 
51: async function settleProviderGenerations(): Promise<void> {
52:   await providerGenerations.settle({
53:     failureMessage: "embedding worker termination was not confirmed",
54:   });
55: }
56: 
57: export function getProvider(): EmbeddingProvider | null {
58:   if (providerAdmissionClosed) return null;
59:   if ...

Found 5 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/website/src/content/docs/docs/configuration.md:
  Line 197: | `embedPoolSize` | number | — | min 1, max 8 | Number of local embedding worker threads (each loads its own ~137MB model). Default: memory-gated (1–2). Override with LORE_EMBED_POOL_SIZE. |


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-cap.ts:
  Line 111:  *  schema max for `search.embeddings.embedPoolSize`). */

  Line 117:  * `configured` (from `search.embeddings.embedPoolSize` or `LORE_EMBED_POOL_SIZE`)


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/pool.ts:
  Line 38:   const cfg = config().search.embeddings.embedPoolSize;


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/config.ts:
  Line 682:           embedPoolSize: z

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/config.ts</path>
<type>file</type>
<content>
650:             .max(2048)
651:             .default(768)
652:             .describe(
653:               "Embedding dimensions. Default: 768 (local) / 1024 (voyage) / 1536 (openai). Local Nomic v1.5 supports Matryoshka: 64, 128, 256, 512, 768.",
654:             ),
655:           /** Run vector searches on a read-worker pool (off the main event
656:            *  loop) instead of synchronously on the main thread. Default: true.
657:            *  This is a kill switch, not opt-in — set to false to force the
658:            *  in-process path if the pool ever misbehaves. */
659:           workerOffload: z
660:             .boolean()
661:             .default(true)
662:             .describe(
663:               "Run vector searches on a read-worker pool off the main event loop. Kill switch (default true); set false to force the in-process path.",
664:             ),
665:  ...

Found 14 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-cap.ts:
  Line 290: export function reconcileEmbedCap(


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

  Line 160: function computeInitialEmbedCap(

  Line 165:   return reconcileEmbedCap(

  Line 177: export function _persistEmbedCap(

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

  Line 449:   private capFreememAtLearn: number;

  Line 474:     this.maxTokens = computeInitialEmbedCap(persisted, this.memDivisor);

  Line 475:     this.capFreememAtLearn = containerFreeBytes();

  Line 777:     if (!shouldReprobeEmbedCap(free, this.capFreememAtLearn)) return;

  Line 790:     this.capFreememAtLearn = free;

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

  Line 854:     this.capFreememAtLearn = free;

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

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-cap.test.ts</path>
<type>file</type>
<content>
240:       expect(cap).toBeGreaterThanOrEqual(MIN_EMBED_TOKENS);
241:       expect(cap).toBeLessThanOrEqual(MODEL_MAX_TOKENS);
242:     }
243:   });
244: });
245: 
246: describe("EMBED_TOKEN_CEILING", () => {
247:   it("is a fixed ceiling below the model max, in the measured ~4900 range", () => {
248:     // Derived from the 4 GiB WASM MAXIMUM_MEMORY (measured on the built worker)
249:     // × 0.85 headroom, minus baseline, over K. Must sit below MODEL_MAX_TOKENS
250:     // (that's the whole point) and near the observed safe convergence (≤4962).
251:     expect(EMBED_TOKEN_CEILING).toBeLessThan(MODEL_MAX_TOKENS);
252:     expect(EMBED_TOKEN_CEILING).toBeGreaterThan(4000);
253:     expect(EMBED_TOKEN_CEILING).toBeLessThanOrEqual(5200);
254:   });
255: 
256:   it("is the binding ceiling once free RAM is large enough to hit it", () => {
257:     // Below the ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/contract.ts</path>
<type>file</type>
<content>
1: /** Shared embedding contracts and cancellation helpers. */
2: 
3: import type { WorkerInbound } from "../embedding-worker-types";
4: 
5: export const WORKER_SHUTDOWN_TIMEOUT_MS = 1_500;
6: 
7: /**
8:  * Cooperative cancellation controls for bounded embedding phases. `deadlineMs` is a duration from
9:  * invocation, matching the existing shutdown deadline convention in this module.
10:  */
11: export interface EmbeddingOperationOptions {
12:   signal?: AbortSignal;
13:   deadlineMs?: number;
14: }
15: 
16: /** Stable phase names for orchestration callers (notably semantic lint). */
17: export type EmbeddingAbortPhase =
18:   | "provider-readiness"
19:   | "settle-document-embeds"
20:   | "knowledge-backfill";
21: 
22: export type EmbeddingAbortCode = "aborted" | "deadline-exceeded";
23: 
24: /** Typed cooperative-stop signal for embedding work. ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/contract.ts</path>
<type>file</type>
<content>
200:   }
201: }
202: 
203: /** A caller stopped waiting for an embedding request. */
204: export class EmbeddingRequestAbortedError extends Error {
205:   constructor() {
206:     super("Embedding request aborted");
207:     this.name = "EmbeddingRequestAbortedError";
208:   }
209: }
210: 
211: /** The host-owned local queue hit its bounded count or byte budget. */
212: export class EmbeddingQueueCapacityError extends Error {
213:   constructor() {
214:     super("Embedding queue capacity exceeded");
215:     this.name = "EmbeddingQueueCapacityError";
216:   }
217: }
218: 
219: /** The worker exceeded its own initialization or execution lifetime. ...

Found 46 matches
/home/byk/Code/opencode-lore-embedding-runtime/.lore.md:
  Line 11: * **captureRequestUpstream requestOrder precedence**: Chose capturing session routing/policy with the synchronous \`requestOrder\` assigned in \`handleRequest\` over allowing asynchronous turn processing to overwrite session state on completion. Concurrent requests can finish out of order; completion-order writes look natural but let an older turn replace a newer route/policy decision. \`captureRequestUpstream()\` must preserve newest-request-wins semantics.

  Line 23: * **db() raw initialization order**: Chose raw SQLite setup followed by delayed tracing/singleton publication over wrapping or assigning immediately because migrations and TEMP-trigger setup must never be traced/re-entrant, and failed migration must retry. Register \`lore\_current\_tenant\`, preflight FTS5, migrate, install sync capture, load sqlite-vec, recover authoritative vec0, then trace and publish. ...

Found 3 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts:
  Line 1028:     await resetProvider();

  Line 1396:     await resetProvider();

  Line 1646:     await resetProvider();

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
1000:     const queued1 = settle(embed(["queued-1"], "document"));
1001:     const queued2 = settle(embed(["queued-2"], "document"));
1002:     await flush();
1003: 
1004:     fakes[0].initError("Cannot find module 'onnxruntime-node'");
1005:     await flush();
1006:     for (const outcome of await Promise.all([running, queued1, queued2])) {
1007:       expect(outcome.ok).toBe(false);
1008:       if (!outcome.ok) {
1009:         expect(outcome.err).toBeInstanceOf(LocalProviderUnavailableError);
1010:       }
1011:     }
1012:   });
1013: 
1014:   it("cancels a pending cooldown wake-up when the pool shuts down", async () => {
1015:     vi.useFakeTimers();
1016:     _setEmbedPoolSizeForTest(1);
1017:     _setLocalInitCooldownMsForTest(1_000);
1018:     const fakes = installFakeWorkers();
1019: 
1020:     const running = settle(embed(["running"], ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
1370:     await flush();
1371:     fakes[0].completeAll();
1372:     await warm;
1373:     fakes[0].exitOnShutdown = false;
1374:     fakes[0].terminate = () => Promise.reject(new Error("terminate boom"));
1375: 
1376:     const reset = resetProvider(10);
1377:     const shutdown = shutdownProvider(1000);
1378:     await expect(reset).rejects.toThrow(
1379:       "embedding worker termination was not confirmed",
1380:     );
1381:     await expect(shutdown).rejects.toThrow(
1382:       "embedding worker termination was not confirmed",
1383:     );
1384:   });
1385: 
1386:   it("keeps provider admission closed across a late config reset", async () => {
1387:     _setEmbedPoolSizeForTest(1);
1388:     const fakes = installFakeWorkers();
1389:     const warm = embed(["warm"], "document");
1390:     await flush();
1391:     fakes[0].completeAll();
1392:     ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
1625: 
1626:     expect(fakes).toHaveLength(2);
1627:     fakes[0].completeAll();
1628:     fakes[1].completeAll();
1629:     await Promise.all([p1, p2]);
1630:   });
1631: 
1632:   it("shuts down every worker in the pool", async () => {
1633:     _setEmbedPoolSizeForTest(2);
1634:     _setPoolFreememForTest(64 * GB);
1635:     const fakes = installFakeWorkers();
1636:     await warmPool(fakes);
1637: 
1638:     const p1 = embed(["alpha"], "query");
1639:     const p2 = embed(["beta"], "query");
1640:     await flush();
1641:     expect(fakes).toHaveLength(2);
1642:     fakes[0].completeAll();
1643:     fakes[1].completeAll();
1644:     await Promise.all([p1, p2]);
1645: 
1646:     await resetProvider();
1647:     expect(fakes[0].gotShutdown).toBe(true);
1648:     expect(fakes[1].gotShutdown).toBe(true);
1649:   });
1650: });

(End of file - total 1650 ...

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

1 256
1.5 877
2 1734
2.6 2385
3 2735
4 3457
6 4572
8 4948
ceiling 4948

Found 25 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 16:   desiredEmbedPoolSize,

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

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

  Line 398:     expect(desiredEmbedPoolSize(2 * PER_WORKER_MEM_BUDGET_BYTES - ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/test/embedding-pool.test.ts</path>
<type>file</type>
<content>
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:     fakes[1].completeAll();
1525:     await Promise.all([p1, p2]);
1526:   });
1527: 
1528:   it("ignores an invalid LORE_EMBED_POOL_SIZE and falls back to a single worker", async () => {
1529:     process.env.LORE_EMBED_POOL_SIZE = "not-a-number";
1530:     _setPoolFreememForTest(64 * GB);
1531:     const fakes = installFakeWorkers();
1532: 
1533:     const p1 = embed(["alpha"], "query");
1534:     const p2 = embed(["beta"], "query");
1535:     await flush();
1536: 
1537:     // Invalid env → undefined → default ceiling of 1 in test mode.
1538:     ...

Found 29 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding.ts:
  Line 30:   _readPersistedEmbedCap,


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding-cap.ts:
  Line 66: export interface PersistedEmbedCap {

  Line 292:   stored: PersistedEmbedCap | null,


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/pool.ts:
  Line 12: } from "../embedding-cap";


/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/embedding/local.ts:
  Line 19:   type PersistedEmbedCap,

  Line 20: } from "../embedding-cap";

  Line 46: function readPersistedEmbedCap(): PersistedEmbedCap | null {

  Line 52:     const parsed = JSON.parse(row.value) as Partial<PersistedEmbedCap>;

  Line 149:     } satisfies PersistedEmbedCap);

  Line 161:   persisted: PersistedEmbedCap | null = readPersistedEmbedCap(),

  Line 186: export function _readPersistedEmbedCap(): PersistedEmbedCap | null {

  Line 187:   return ...

<path>/home/byk/Code/opencode-lore-embedding-runtime/packages/core/package.json</path>
<type>file</type>
<content>
1: {
2:   "name": "@loreai/core",
3:   "version": "0.40.0",
4:   "type": "module",
5:   "license": "FSL-1.1-Apache-2.0",
6:   "description": "Shared memory engine for Lore — three-tier storage, distillation, gradient context management",
7:   "main": "./dist/node/index.js",
8:   "types": "./dist/node/index.d.ts",
9:   "exports": {
10:     ".": {
11:       "types": "./dist/types/index.d.ts",
12:       "development": "./src/index.ts",
13:       "bun": "./dist/bun/index.js",
14:       "default": "./dist/node/index.js"
15:     }
16:   },
17:   "imports": {
18:     "#db/driver": {
19:       "bun": "./src/db/driver.bun.ts",
20:       "default": "./src/db/driver.node.ts"
21:     }
22:   },
23:   "scripts": {
24:     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.eval.json",
25:     "build": "tsx script/build.ts"
26:   },
27:   "dependencies": {
28:     "@hpke/core": ...

Found 1 matches
/home/byk/Code/opencode-lore-embedding-runtime/packages/core/src/index.ts:
  Line 50: export * as embedding from "./embedding";

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

5935754a015c253946e8bd46a7ce0907cd324cba863236770b2685fa2e36b20b  packages/core/src/embedding-cap.ts
ff99f80d82b48d0e915c4be9ea84f8c60365436825ffb4bf3aa80b6d42afb458  packages/core/src/embedding/local.ts
c032d9990b6b7cc62d4fb41a5ce907d8988d846fc14393e2b287fcd16fb3c9bf  packages/core/src/embedding/pool.ts
32fa8972d267a576d23dc4f64fcca616c15d2f20160eff9d8941663b307fa698  packages/core/test/embedding-cap.test.ts
dd922bec9215c345d879a44885078044567deafa9574538aaa6ac414c6cc95df  packages/core/test/embedding-cap-persistence.test.ts
fd2a206b9f8248448fabf0ba72d5040114d8495c27835606961b5c0e4933f436  packages/core/test/embedding-pool-memory.test.ts
5913c6bd181657e8276cd1e83a499e2e870c2e0f02900bc32c3ceb97d363deab  packages/core/test/embedding-oom-recovery.test.ts
00fd39baf0c0a8545f3e42cb8edb8a80842556b0b8d4b5c209e991a748f88dd6  packages/core/test/embedding-pool.test.ts