pi-tuck 0.0.0-stage → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,67 @@
+# Changelog
+
+All notable changes to pi-tuck. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
+[Semantic Versioning](https://semver.org/).
+
+## [1.0.1] - 2026-10-30
+
+First release on npm. 1.0.0 was tagged but never published; its notes below describe what 1.0.1 ships besides these changes.
+
+### Added
+
+- Linux support. Compaction and keyword recall work as on macOS; semantic search stays macOS on Apple silicon only.
+
+### Changed
+
+- The `tuck_recall` and `tuck_search` tool descriptions are shorter: about 1,050 tokens per request instead of 1,670. The parameters
+  accept the same input.
+
+### Fixed
+
+- A long session whose dialogue no longer fit the summary stalled for tens of seconds at every cut (88 s at 3,900 entries), because
+  the ranked view re-rendered the whole candidate summary for each block it considered. It now keeps the summary's size up to date
+  as blocks join, so a cut takes well under a second and grows linearly with the session. Summaries are byte for byte the same.
+
+## [1.0.0] - 2026-10-30
+
+Tagged, not published.
+
+### Added
+
+- Semantic search is on by default. Its local runtime (EmbeddingGemma-2, llama.cpp, a standalone CPython) is downloaded once, in the
+  background, from pinned public sources, each file checked against its SHA-256. Turn it off with `{"semanticRecall": false}` in
+  `~/.pi/agent/pi-tuck.json`.
+- Summaries list the agent's other tool calls (shell commands and the like) before the cut, newest first and capped at 30, without
+  their output but with a pointer to it, so an agent that writes little prose still sees what it already ran.
+- Runs started by a custom message (Pi 1.4) are budgeted by that message.
+- Sessions written by pi-vcc-based compactors (`VCC-TRANSCRIPT/1` summaries, `vcc_recall` and `vcc_search` calls) are read as this
+  format, with tool names updated for the model.
+
+### Changed
+
+- Summaries keep the whole dialogue, a list of the files read, written or edited, and the session's first prompt word for word, and end
+  with an instruction to re-read files before editing them. They stay small as a session grows, where 0.2.1's re-rendered the whole tool
+  history at every compaction. The ranked view remains as the fallback when the dialogue does not fit.
+- Tools are renamed `tuck_recall` and `tuck_search` (from `pi_tuck_recall` and `pi_tuck_search`), and commands `/tuck-semantic` and
+  `/tuck-incident`. Summaries are headed `TUCK-TRANSCRIPT/1`.
+- Tested against Pi 1.1.0's and 1.4.0's libraries.
+
+### Fixed
+
+- On Pi 1.4, a prompt that needed a cut hung the session: Pi now counts a run as started before `before_agent_start`, and a
+  compaction asked for there waited on that run. The cut is made when the prompt arrives, while Pi is still idle.
+- A revoked source that stops semantic recall records why, instead of reading as recall that was never switched on.
+
+### Removed
+
+- The bounded, masked and full summary views; the dialogue view replaces them.
+- The external `~/.config/pi/semantic-recall.json` configuration and `PI_SEMANTIC_RECALL_CONFIG`.
+
+## [0.2.1] - 2026-10-24
+
+Source preview on GitHub, not published to npm. Deterministic compaction with `pi_tuck_recall` and `pi_tuck_search`; semantic search
+opt-in, with a runtime the user had to supply.
+
+[1.0.1]: https://github.com/galyavin/pi-tuck/releases/tag/v1.0.1
+[1.0.0]: https://github.com/galyavin/pi-tuck/tree/v1.0.0
+[0.2.1]: https://github.com/galyavin/pi-tuck/tree/e00fa99

package/LICENSE

@@ -0,0 +1,81 @@
+MIT License
+
+Copyright (c) 2026 sting8k
+Copyright (c) 2026 Rustem Galyavin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Portions derived from pi-blackhole (https://github.com/k0valik/pi-blackhole).
+The following notice is retained for those portions:
+
+MIT License
+
+Copyright (c) 2026 k0valik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Pi-derived inlined message constructors
+
+The following notice applies to the adapted createCustomMessage and
+createBranchSummaryMessage construction branches in src/tuck/cut.ts
+and their distributed generated equivalents. Notice source: Pi v1.1.0,
+https://github.com/earendil-works/pi/blob/abe508e1b89912adde45528136c3221eb69acdd7/LICENSE
+This notice-source pin does not identify the original copy revision.
+
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,126 @@
-# Temporary Holding Version
+# pi-tuck
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Deterministic compaction for [Pi](https://pi.dev). When a session's context fills up, pi-tuck replaces older turns with a summary built
+from the session itself, not written by a model: no extra model call, no cost, no invented history, and the same input always gives the
+same summary. Nothing is lost: the full history stays in the session file, and the agent gets two tools to read it back, by keyword and
+by meaning.
+
+## Install
+
+```sh
+pi install npm:pi-tuck@1.0.1
+```
+
+or straight from GitHub:
+
+```sh
+pi install git:github.com/galyavin/pi-tuck@v1.0.1
+```
+
+Requires Pi 1.1 or later (tested on 1.1.0 and 1.4.0) on macOS or Linux. Semantic search (`tuck_search` by meaning) runs only on macOS
+on Apple silicon; elsewhere `tuck_search` uses keywords and everything else works.
+Start a new Pi session after installing.
+
+## What it does
+
+**Compaction.** pi-tuck takes over Pi's compaction, both automatic and `/compact`. A summary keeps:
+
+- the dialogue: what you asked and what the agent answered, in order;
+- the files the agent read, wrote or edited, newest first (up to 60), with pointers to read them back;
+- the agent's other tool calls, such as shell commands, newest first (up to 30), without their output but with pointers to it;
+- your first prompt in the session, word for word (up to 12,000 characters).
+
+Tool output is left out of the summary; it stays in the session file. If the dialogue itself is too long for the room left, the summary
+keeps a ranked selection of records instead. Each summary ends with a short instruction to the agent: re-read a file before editing it,
+and look things up rather than guess.
+
+**`tuck_recall`** finds earlier text by keyword and reads any original message or tool result exactly, by the index shown in a summary.
+It can also write an original back out to a file.
+
+**`tuck_search`** finds earlier history related to a question even when the wording differs. It combines keyword hits with local
+semantic search (see below) and returns the original text with pointers for `tuck_recall`.
+
+**Commands**
+
+| Command | Does |
+|---|---|
+| `/tuck-semantic on\|off\|status` | Turns semantic search on or off for this session, or shows its state. |
+| `/tuck-incident on\|next\|off\|status` | Records this session's compaction decisions to a file you can attach to a bug report. |
+
+`/compact` works as usual; pi-tuck does not take custom summary instructions. Pi's own setting `"compaction": { "enabled": false }`
+turns compaction off.
+
+**Small context windows.** pi-tuck keeps room for the model's reply: the larger of the model's output limit and Pi's
+`compaction.reserveTokens` (default 16,384). It refuses a request that cannot fit rather than let the provider cut it off. For a model
+with a window of 32k tokens or less, lower the reserve for that model in Pi's `settings.json`:
+
+```json
+{ "compaction": { "modelOverrides": { "my-provider/my-model": { "reserveTokens": 4096 } } } }
+```
+
+## Semantic search
+
+Semantic search is on by default and runs entirely on your Mac: an embedding model,
+[EmbeddingGemma-2](https://huggingface.co/google/embeddinggemma-2), served by [llama.cpp](https://github.com/ggml-org/llama.cpp) on the
+CPU. No text leaves your machine.
+
+The first time a session starts, pi-tuck downloads what it needs, once, about 390 MB in the background, and keeps working with keyword
+search meanwhile:
+
+| File | From |
+|---|---|
+| EmbeddingGemma-2, 8-bit GGUF (310 MB) and its tokenizer (32 MB) | huggingface.co |
+| llama.cpp release b11476 for macOS arm64 (12 MB) | github.com/ggml-org/llama.cpp |
+| CPython 3.13 (25 MB) and 16 Python packages for the tokenizer (9 MB) | github.com/astral-sh/python-build-standalone, pypi.org |
+
+Every file is pinned to a SHA-256 in [src/assets.ts](src/assets.ts) and checked before use. Everything goes to `~/.pi/agent/pi-tuck`;
+to remove it, delete that folder. Setup needs about 6.5 GB of free disk space while it runs and uses 460 MB after. If it fails, for
+example offline, pi-tuck says so and tries again at the next session start. One-shot runs (`pi -p`) don't start the setup.
+
+Indexing starts in the background the first time a session uses `tuck_search`, and catches up after each compaction. Semantic search is off when Pi
+runs in a folder that contains Pi's agent folder, such as your home folder, because its own files live there; open Pi in a project folder.
+
+**Turn it off** by creating `~/.pi/agent/pi-tuck.json`:
+
+```json
+{ "semanticRecall": false }
+```
+
+Nothing is then downloaded, and `tuck_search` uses keywords only. If you set `PI_CODING_AGENT_DIR`, the file and the download folder are
+in that folder instead.
+
+## Use from code
+
+The package also exports its parts for hosts that embed Pi through its SDK:
+
+```ts
+import { installCompaction, createSemanticRecall, ensureSemanticRuntime } from "pi-tuck";
+
+const config = JSON.parse(readFileSync(await ensureSemanticRuntime("/abs/path/outside/projects"), "utf8"));
+const semanticRecall = createSemanticRecall(config);
+const handle = await installCompaction(pi, { semanticRecall });
+await handle.setSemanticEnabled(true, ctx); // e.g. in a session_start handler
+```
+
+`installCompaction` options (reply reserve, host-injected messages, recall policy and others) are documented in
+[src/compaction.ts](src/compaction.ts). `handle.close()` stops the semantic worker; call it before disposing a session.
+
+## Development
+
+```sh
+npm install
+npm run check   # types
+npm test        # unit tests (Vitest) and the Python runtime tests
+npm run build   # dist/ for the library export
+```
+
+## Credits
+
+pi-tuck grew out of [pi-vcc](https://github.com/sting8k/pi-vcc) by sting8k and includes code from
+[pi-blackhole](https://github.com/k0valik/pi-blackhole) by k0valik and from [Pi](https://github.com/earendil-works/pi) by Mario
+Zechner, all MIT; their notices are in [LICENSE](LICENSE). The downloaded model is Apache-2.0, llama.cpp is MIT, and CPython is under the
+PSF license.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export type { CompactionOptions } from "./src/compaction.js";
+export { installCompaction } from "./src/compaction.js";
+export { inspectIncident, readableIncident } from "./src/diagnostic-replay.js";
+export { createSemanticRecall, SemanticRecallController } from "./src/semantic-recall.js";
+export type { SemanticRecallConfig, PriorResult, SemanticState } from "./src/semantic-recall.js";
+export { ensureSemanticRuntime } from "./src/setup.js";
+/** pi-tuck as a Pi extension: compaction and history recall always; semantic recall too, unless `pi-tuck.json` in Pi's agent folder
+ * says `{"semanticRecall": false}`. Its runtime is set up in the background the first time a session starts. */
+export default function (pi: ExtensionAPI): Promise<void>;

package/dist/index.js

@@ -0,0 +1,90 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { readFileSync, realpathSync } from "node:fs";
+import { join, sep } from "node:path";
+import { installCompaction } from "./src/compaction.js";
+import { createSemanticRecall } from "./src/semantic-recall.js";
+import { defaultRoot } from "./src/assets.js";
+import { ensureSemanticRuntime } from "./src/setup.js";
+export { installCompaction } from "./src/compaction.js";
+export { inspectIncident, readableIncident } from "./src/diagnostic-replay.js";
+export { createSemanticRecall, SemanticRecallController } from "./src/semantic-recall.js";
+export { ensureSemanticRuntime } from "./src/setup.js";
+/** pi-tuck as a Pi extension: compaction and history recall always; semantic recall too, unless `pi-tuck.json` in Pi's agent folder
+ * says `{"semanticRecall": false}`. Its runtime is set up in the background the first time a session starts. */
+export default async function (pi) {
+    const semanticRecall = createSemanticRecall();
+    // `/tuck-semantic off` holds for the rest of the session, including over a setup that finishes later.
+    let off = false;
+    const handle = await installCompaction(pi, { semanticRecall, onSemanticSetting: async (enabled) => { off = !enabled; } });
+    const settings = readSettings(join(getAgentDir(), "pi-tuck.json"));
+    if (settings.semanticRecall === false)
+        return;
+    let session = 0, said = "", setup;
+    // A context outlives its session (a setup can finish after /new); a notice to an ended session is dropped.
+    const say = (ctx, message, level) => { try {
+        ctx.ui.notify(message, level);
+    }
+    catch { /* ended */ } };
+    const once = (ctx, message, level) => { if (said !== message) {
+        said = message;
+        say(ctx, message, level);
+    } };
+    pi.on("session_shutdown", () => { session++; });
+    pi.on("session_start", (_event, ctx) => {
+        const current = ++session;
+        off = false;
+        if (settings.error)
+            once(ctx, `pi-tuck: ${settings.error}; using the defaults.`, "warning");
+        if (process.platform !== "darwin" || process.arch !== "arm64")
+            return once(ctx, "pi-tuck: semantic recall needs macOS on Apple silicon for now; compaction and word recall work.", "info");
+        // Semantic recall keeps its runtime and indexes outside the project it serves, so not when Pi runs in a folder that holds its
+        // agent folder, such as the home folder.
+        if (within(real(getAgentDir()), real(ctx.cwd)))
+            return once(ctx, "pi-tuck: semantic recall is off here because Pi's agent folder is inside this folder; open Pi in a project folder to use it.", "info");
+        if (!ctx.hasUI)
+            return; // a one-shot run (pi -p) would end before a first-time setup could
+        if (!semanticRecall.status().configured)
+            semanticRecall.refuse("Semantic recall is being set up; word recall works meanwhile");
+        setup ??= ensureSemanticRuntime(defaultRoot(), message => say(ctx, message, "info"));
+        setup.then(async () => {
+            if (current !== session || off)
+                return;
+            try {
+                await handle.setSemanticEnabled(true, ctx); // reads the runtime's configuration through the outside-project check
+            }
+            catch (error) {
+                if (current === session)
+                    say(ctx, `pi-tuck: semantic recall could not start (${reason(error)}); it tries again when a session starts.`, "warning");
+            }
+        }, error => {
+            setup = undefined; // the next session start tries again
+            semanticRecall.refuse(`Semantic recall setup failed: ${reason(error)}`);
+            if (current === session)
+                say(ctx, `pi-tuck: semantic recall setup failed (${reason(error)}). Word recall works; setup retries when a session starts.`, "warning");
+        });
+    });
+}
+function readSettings(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return {};
+    }
+    try {
+        const value = JSON.parse(text);
+        if (value && typeof value === "object" && (value.semanticRecall === undefined || typeof value.semanticRecall === "boolean"))
+            return value;
+    }
+    catch { /* reported below */ }
+    return { error: `${path} should be a JSON object like {"semanticRecall": false}` };
+}
+const reason = (error) => error instanceof Error ? error.message : String(error);
+const within = (path, folder) => path === folder || path.startsWith(folder.endsWith(sep) ? folder : folder + sep);
+const real = (path) => { try {
+    return realpathSync(path);
+}
+catch {
+    return path;
+} };

package/dist/src/assets.d.ts

@@ -0,0 +1,58 @@
+export interface Download {
+    url: string;
+    sha256: string;
+    size: number;
+}
+/** Where pi-tuck keeps the runtime, its downloads and the indexes: one folder, so deleting it removes all of them. */
+export declare const defaultRoot: () => string;
+/** A relocatable CPython for macOS arm64; the runtime's virtual environment is made from it and keeps pointing at it. */
+export declare const PYTHON: Download & {
+    version: string;
+    name: string;
+};
+/** EmbeddingGemma-2, 8-bit GGUF. */
+export declare const MODEL: Download;
+/** The model's own tokenizer: passages are split on its token offsets. */
+export declare const TOKENIZER: Download;
+/** llama.cpp release b11476 (commit 988190680d5a). `files` are the server and the libraries it loads from its own folder; the archive
+ * names most libraries through symlinks, which the runtime refuses, so each is copied as a plain file under the name the server loads. */
+export declare const LLAMA: Download & {
+    folder: string;
+    files: Record<string, string>;
+    license: string;
+};
+/** The tokenizer library and its declared dependencies, installed offline with hash checking. */
+export declare const WHEELS: Record<string, Download>;
+/** What scripts/eg2-runtime.py checks the runtime against: the model, its encoding contract and the native build. */
+export declare const PINS: {
+    embedding: {
+        model: string;
+        revision: string;
+        dimensions: number;
+        maxTokens: number;
+        queryInstruction: string;
+        documentInstruction: string;
+        pooling: string;
+        dtype: string;
+        textOnly: boolean;
+    };
+    runtime: {
+        tokenizers: string;
+        python: string;
+    };
+    backend: {
+        name: string;
+        commit: string;
+        artifact: string;
+        computePrecision: string;
+        gpuLayers: number;
+        compute: string;
+        modelRepository: string;
+        modelRevision: string;
+        modelSHA256: string;
+    };
+};
+/** A digest of every pinned input: a changed pin provisions a new runtime beside the old one instead of mutating it. */
+export declare const RUNTIME_ID: string;
+/** The provisioned runtime's configuration, written last by provisioning: its presence means the runtime is complete. */
+export declare const runtimeConfigPath: (root: string) => string;

package/dist/src/assets.js

@@ -0,0 +1,80 @@
+// Everything semantic recall's local runtime is built from: a public source and its SHA-256 for each file. setup.ts downloads and
+// verifies these, and a change to any of them gives the runtime a new id, so an update provisions beside the old runtime, never over it.
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+/** Where pi-tuck keeps the runtime, its downloads and the indexes: one folder, so deleting it removes all of them. */
+export const defaultRoot = () => join(getAgentDir(), "pi-tuck");
+const MODEL_REVISION = "031f0d4b35536f69ab3509d4893c923264fcf253", TOKENIZER_REVISION = "914f7f89142e33e77833254d9c9b90c3cef7303b";
+const LLAMA_COMMIT = "988190680d5a89fce97de3c20df2c2813731fd61";
+/** A relocatable CPython for macOS arm64; the runtime's virtual environment is made from it and keeps pointing at it. */
+export const PYTHON = {
+    name: "cpython-3.13.18+20261026", version: "3.13", size: 25394044,
+    url: "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.13.18%2B20261026-aarch64-apple-darwin-install_only.tar.gz",
+    sha256: "e5af2fde6a937a0e0c795a0c595c4efb70578d57463a2657c819992b9b9acbac",
+};
+/** EmbeddingGemma-2, 8-bit GGUF. */
+export const MODEL = {
+    url: `https://huggingface.co/unsloth/embeddinggemma-2-GGUF/resolve/${MODEL_REVISION}/embeddinggemma-2-Q8_0.gguf`,
+    sha256: "6f1bd4ac6c5df7444f9cca7ca36cafe6cfa34cd6f49fefb1e0b4be8143aed8bc", size: 309855520,
+};
+/** The model's own tokenizer: passages are split on its token offsets. */
+export const TOKENIZER = {
+    url: `https://huggingface.co/google/embeddinggemma-2/resolve/${TOKENIZER_REVISION}/tokenizer.json`,
+    sha256: "4d777ef5bdc1aa36227abdfb77c3e49e7b9c892d16e1b6bda41c393504828be4", size: 32170510,
+};
+/** llama.cpp release b11476 (commit 988190680d5a). `files` are the server and the libraries it loads from its own folder; the archive
+ * names most libraries through symlinks, which the runtime refuses, so each is copied as a plain file under the name the server loads. */
+export const LLAMA = {
+    url: "https://github.com/ggml-org/llama.cpp/releases/download/b11476/llama-b11476-bin-macos-arm64.tar.gz",
+    sha256: "577634a1b8a59e8dabe02ba10de1e610be0574dfaf1cf3020e6dd42853ed877e", size: 12012019,
+    folder: "llama-b11476",
+    files: {
+        "llama-server": "1bf5602a2be50097c44282a6ecc63234d94ee8f96d39fd45fed6eff4e74b6b41",
+        "libllama-server-impl.dylib": "d699e1d7f0b3d5c63c9e7cd88c50e37c96cbf64802dbcefdc784983565a29608",
+        "libllama-common.0.dylib": "e90e6f5bba4ff114f7fb9ed1328171b1c4eceac71ee8923178f5d417310b0d4e",
+        "libmtmd.0.dylib": "c87488222bc71275f75da743e8cc628b014b59d051bc0e303c444e96f54762a7",
+        "libllama.0.dylib": "423bd595e045f0bb8225ad721571d5ab9842815f1b975f2462d2c7c8e0594bd7",
+        "libggml.0.dylib": "85ac40d540a5cc86f28a70270ddcdde677e92eb585c3bacd1b7e82270fe8934b",
+        "libggml-cpu.0.dylib": "937073375f79a187d8fda2e3900a9095e979593b691d6bbb146956743ceddd82",
+        "libggml-blas.0.dylib": "6526259e8f70a5b3a394df3ba082050c290d7653846efbdc84b3710b22fb4eac",
+        "libggml-metal.0.dylib": "a40058fab152c973339e40e80df900c1b311e06bcfb4c1c473cb169c7ee88a5c",
+        "libggml-rpc.0.dylib": "48c13b7c2c56e2b569b636e6a28d1c0853ad2d1db1980c0afd374651c6e897d0",
+        "libggml-base.0.dylib": "6fba8bb7fb529801d1b73782ac1707b653b1ea4caf53f667b85bc801e2883326",
+    },
+    license: "94f29bbed6a22c35b992c5c6ebf0e7c92f13b836b90f36f461c9cf2f0f1d010d",
+};
+const pypi = (path, sha256, size) => ({ url: "https://files.pythonhosted.org/packages/" + path, sha256, size });
+/** The tokenizer library and its declared dependencies, installed offline with hash checking. */
+export const WHEELS = {
+    "anyio-4.15.1-py3-none-any.whl": pypi("12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", "6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", 132079),
+    "certifi-2026.7.22-py3-none-any.whl": pypi("0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", "62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", 136983),
+    "click-8.5.0-py3-none-any.whl": pypi("58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", "255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", 125251),
+    "filelock-4.0.12-py3-none-any.whl": pypi("da/a1/b047e1c486a2c66283633b7dbb73872ca16ca1ce6a426f70d4d037fc8e1c/filelock-4.0.12-py3-none-any.whl", "5f17ee83ecee8a6f3e389c75822fb70a1c2f0506b99438a6dffa1d56793588c8", 111732),
+    "fsspec-2026.9.0-py3-none-any.whl": pypi("6c/c0/a98505f18594f1bce828bb159cec0fcf9860562f1a2c85913409fc8f3d9e/fsspec-2026.9.0-py3-none-any.whl", "8dd6e646e99ea382bd85f97a45e6b526a442d79423a7dc673f1e2756d05fcb5f", 221738),
+    "h11-0.16.0-py3-none-any.whl": pypi("04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", 37515),
+    "hf_xet-1.7.0-cp38-abi3-macosx_11_0_arm64.whl": pypi("c3/47/a26ebdce7056a61e931f228439bc0ab08cbec239d1690f965e5e637cba79/hf_xet-1.7.0-cp38-abi3-macosx_11_0_arm64.whl", "59fba37039233c7fcbe196817d6cdcf1b40dfb17b410f229d85b0cf0a1848da4", 3560352),
+    "httpcore-1.0.9-py3-none-any.whl": pypi("7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", 78784),
+    "httpx-0.28.1-py3-none-any.whl": pypi("2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", 73517),
+    "huggingface_hub-1.33.0-py3-none-any.whl": pypi("fc/16/963096d224b80909432dc16561a615fd33d2d13beef3ce4c63fa25e40867/huggingface_hub-1.33.0-py3-none-any.whl", "04e434b06e100eddbce9a6e817d72693a7884b10a79bd67ab48080d5c07eb899", 846435),
+    "idna-3.20-py3-none-any.whl": pypi("58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", "ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", 69583),
+    "packaging-26.3-py3-none-any.whl": pypi("63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", "d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", 129956),
+    "pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl": pypi("b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", "2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", 173252),
+    "tokenizers-0.23.2-cp310-abi3-macosx_11_0_arm64.whl": pypi("67/49/22da045a91732384d3a3771816bf188dc5a1f702c32e635afa7c679c0bef/tokenizers-0.23.2-cp310-abi3-macosx_11_0_arm64.whl", "986670e43691469dcee610ea0f846f91a8f84e91fc6f7a48d4c064414c0ec2bf", 3101593),
+    "tqdm-4.70.1-py3-none-any.whl": pypi("a7/03/921a3d3c75785aca9ebfbfcabfbc3a1be12e2ab5265deb026d55a5a3f83e/tqdm-4.70.1-py3-none-any.whl", "c293e525e6fef9c20e8728fd4612df02a0aa31bb5fe91ecd93e123b1b7bffa73", 80199),
+    "typing_extensions-4.16.0-py3-none-any.whl": pypi("49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", "481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", 45571),
+};
+/** What scripts/eg2-runtime.py checks the runtime against: the model, its encoding contract and the native build. */
+export const PINS = {
+    embedding: { model: "google/embeddinggemma-2", revision: TOKENIZER_REVISION, dimensions: 768, maxTokens: 8192,
+        queryInstruction: "task: search result | query: ", documentInstruction: "title: none | text: ",
+        pooling: "mask-aware mean including prompt, projected token states, then float32 L2", dtype: "Q8_0", textOnly: true },
+    runtime: { tokenizers: "0.23.2", python: PYTHON.version },
+    backend: { name: "llama.cpp", commit: LLAMA_COMMIT, artifact: "Q8_0", computePrecision: "float32", gpuLayers: 0,
+        compute: "CPU float32 with f32 KV; quantized weights where selected", modelRepository: "unsloth/embeddinggemma-2-GGUF",
+        modelRevision: MODEL_REVISION, modelSHA256: MODEL.sha256 },
+};
+/** A digest of every pinned input: a changed pin provisions a new runtime beside the old one instead of mutating it. */
+export const RUNTIME_ID = createHash("sha256").update(JSON.stringify({ PYTHON, MODEL, TOKENIZER, LLAMA, WHEELS, PINS })).digest("hex").slice(0, 16);
+/** The provisioned runtime's configuration, written last by provisioning: its presence means the runtime is complete. */
+export const runtimeConfigPath = (root) => join(root, "runtime", RUNTIME_ID, "semantic-recall.json");