@herbertgao/pi-extensions 2026.10.0 → 2026.10.2

package/node_modules/pi-lens/scripts/download-grammars.js

@@ -38,6 +38,11 @@ export const SOURCE_OVERRIDES = {
         version: "0.7.1",
         url: "https://unpkg.com/@tree-sitter-grammars/tree-sitter-yaml@0.7.1/tree-sitter-yaml.wasm",
     },
+    "tree-sitter-bash.wasm": {
+        package: "tree-sitter-bash",
+        version: "0.25.1",
+        url: "https://unpkg.com/tree-sitter-bash@0.25.1/tree-sitter-bash.wasm",
+    },
 };
 /**
  * Grammars committed under `vendor/grammars/` rather than fetched.

package/node_modules/pi-lens/scripts/grammars.lock.json

@@ -2,7 +2,7 @@
   "package": "tree-sitter-wasms",
   "version": "0.1.13",
   "grammars": {
-    "tree-sitter-bash.wasm": "sha256:807dcdb1380a59befb112ed8fbd3d3872c7fadaf5903a769282b50973b30696d",
+    "tree-sitter-bash.wasm": "sha256:8292919c88a0f7d3fb31d0cd0253ca5a9531bc1ede82b0537f2c63dd8abe6a7a",
     "tree-sitter-c.wasm": "sha256:056b25072382f72deee2c64ec238ffc4bb8cf42844ef21502c0e70f03a8a0d66",
     "tree-sitter-c_sharp.wasm": "sha256:6266a7e32d68a3459104d994dc848df15d5672b0ea8e86d327274b694f8e6991",
     "tree-sitter-cpp.wasm": "sha256:f6afdf53bfd6de76557bb7edb624a3a3869e14d9a83b78433f93617ecee42527",
@@ -39,6 +39,11 @@
       "package": "@tree-sitter-grammars/tree-sitter-yaml",
       "version": "0.7.1",
       "url": "https://unpkg.com/@tree-sitter-grammars/tree-sitter-yaml@0.7.1/tree-sitter-yaml.wasm"
+    },
+    "tree-sitter-bash.wasm": {
+      "package": "tree-sitter-bash",
+      "version": "0.25.1",
+      "url": "https://unpkg.com/tree-sitter-bash@0.25.1/tree-sitter-bash.wasm"
     }
   },
   "vendored": {

package/node_modules/pi-lens/scripts/install-selftest.mjs

@@ -50,7 +50,10 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { HOST_PROVIDED_PACKAGES } from "./lib/host-provided-deps.mjs";
 import { collectSkillEntryPaths } from "./lib/skills-predicate.mjs";
-import { resolveWebTreeSitterPackageDir } from "./lib/web-tree-sitter-dir.mjs";
+import {
+	findCoreGrammarDir,
+	resolveWebTreeSitterPackageDir,
+} from "./lib/web-tree-sitter-dir.mjs";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const pkgRoot = path.resolve(here, "..");
@@ -127,18 +130,14 @@ function probeResolve(spec) {
 }
 
 // --- 1. The documented failure-point modules (eager bare imports) ----------
+// #3219: the package ships only bundled entries. file-utils (→ minimatch),
+// complexity-client (→ tree-sitter) and bootstrap (→ all analyzers) are inlined
+// in dist/index.js, so its import probes them; the installer registry is the
+// bundled dist/probes/installer.js the bins share chunks with.
 await probeImport("dist/index.js (entry)", "dist/index.js");
 await probeImport(
-	"clients/file-utils.js (→ minimatch)",
-	"dist/clients/file-utils.js",
-);
-await probeImport(
-	"clients/complexity-client.js (→ tree-sitter)",
-	"dist/clients/complexity-client.js",
-);
-await probeImport(
-	"clients/bootstrap.js (→ all analyzers)",
-	"dist/clients/bootstrap.js",
+	"probes/installer.js (bundled installer registry)",
+	"dist/probes/installer.js",
 );
 
 // --- 2. Direct bare-specifier resolution -----------------------------------
@@ -174,7 +173,7 @@ record(
 // symlink store) — the binary exists but the launcher can't reach it.
 try {
 	const installerUrl = `file://${path
-		.resolve(pkgRoot, "dist/clients/installer/index.js")
+		.resolve(pkgRoot, "dist/probes/installer.js")
 		.replace(/\\/g, "/")}`;
 	const { TOOLS, resolvePlatformPackageBinary } = await import(installerUrl);
 	for (const tool of TOOLS.filter((t) => t.platformPackage)) {
@@ -220,33 +219,33 @@ try {
 	);
 }
 
-// tree-sitter grammars — download-grammars.js postinstall writes them into
-// node_modules/web-tree-sitter/grammars/. Locate that dir through the SAME
-// shared ladder the extension runtime uses (#3409 round 1, R3418-2): this probe
-// used to resolve the BARE `web-tree-sitter` specifier and walk up, which throws
-// MODULE_NOT_FOUND inside a `bun build --compile` host — so on the very hosts pi
-// ships as, it reported the grammar asset missing while the exported wasm
-// subpath resolved fine. One ladder, one answer, for the client, the pasted
-// install fingerprint and this script.
-let grammarDetail = "tree-sitter-*.wasm missing (postinstall skipped?)";
-let hasCoreGrammar = false;
+// tree-sitter grammars — the core set ships INSIDE the tarball, in
+// `<pkgRoot>/grammars`, and the runtime reads that dir first
+// (`bundledGrammarsDir` in clients/tree-sitter-client.ts). `web-tree-sitter/
+// grammars` is only the lazy-fetch write target, nothing at install time fills
+// it, so probing it alone warned in every layout and the strict npm gate (#1185)
+// could never drop `--allow-soft`. Check the bundled dir, then fall back to the
+// web-tree-sitter dir, which the extension runtime locates through the SAME
+// shared ladder (#3409 round 1, R3418-2): a bare `web-tree-sitter` resolve
+// throws MODULE_NOT_FOUND inside a `bun build --compile` host.
+const bundledGrammarDir = path.join(pkgRoot, "grammars");
 const webTreeSitterDir = resolveWebTreeSitterPackageDir({
 	resolve: (specifier) => require.resolve(specifier),
 	packageRoot: () => pkgRoot,
 	cwd: () => process.cwd(),
 });
-if (!webTreeSitterDir) {
-	grammarDetail =
-		"web-tree-sitter package dir unresolvable (module resolver, package root and cwd)";
-} else {
-	const grammarDir = path.join(webTreeSitterDir, "grammars");
-	hasCoreGrammar = fs.existsSync(
-		path.join(grammarDir, "tree-sitter-typescript.wasm"),
-	);
-	grammarDetail = hasCoreGrammar
-		? grammarDir
-		: `tree-sitter-*.wasm missing in ${grammarDir} (postinstall skipped?)`;
-}
+const grammarDir = findCoreGrammarDir({
+	packageRoot: pkgRoot,
+	webTreeSitterDir,
+});
+const hasCoreGrammar = grammarDir !== undefined;
+const grammarDetail = hasCoreGrammar
+	? grammarDir
+	: `tree-sitter-typescript.wasm missing in ${bundledGrammarDir}${
+			webTreeSitterDir
+				? ` and ${path.join(webTreeSitterDir, "grammars")}`
+				: " (web-tree-sitter dir unresolvable)"
+		}`;
 record("tree-sitter grammars", "asset", hasCoreGrammar, grammarDetail);
 
 // --- 4. pi.skills manifest resolution, AS INSTALLED (#2587) ----------------

package/node_modules/pi-lens/scripts/lib/host-provided-deps.mjs

@@ -18,11 +18,20 @@
  *   VALUE imports of those work with no copy on disk — verified by hiding both
  *   from the dogfood install and re-running under PI_TIMING (#1926), and by
  *   `@tintinweb/pi-subagents`, which declares pi-tui as a peer and ships no
- *   copy. `@earendil-works/pi-coding-agent` is different: it is not resolvable
- *   from an extension at all, so pi-lens imports it TYPE-ONLY and inlines the
- *   runtime helpers it needs. `tests/host-sdk-type-only.test.ts` enforces that
+ *   copy. That resolution is jiti's: pi's loader hands `dist/index.js` to
+ *   jiti, whose native import fails on those unresolvable static imports, and
+ *   the transpiled fallback serves them from pi's running instance
+ *   (`virtualModules` in the bundled CLI). `@earendil-works/pi-coding-agent` is
+ *   served the same way, but a static import of it would fail the extension
+ *   LOAD on any host that does not serve it, and where pi-lens' static imports
+ *   resolve natively a runtime import of it goes through Node and can load a
+ *   second copy. So pi-lens imports it TYPE-ONLY and inlines the runtime
+ *   helpers it needs. `tests/host-sdk-type-only.test.ts` enforces that
  *   separate rule (#1334 S6); do not read this list as permission to
- *   value-import the host SDK.
+ *   value-import the host SDK. Its one admitted exception is lazy and caught:
+ *   `index.ts` looks up pi's `withFileMutationQueue` on the first write, and
+ *   `clients/file-mutation-queue.ts` records whether it reached the host's
+ *   own copy (#3506).
  *
  * LAZY_NATIVE_PACKAGES
  *   Native addon / wasm, dynamic-imported by absolute file:// URL at call time.

package/node_modules/pi-lens/scripts/lib/web-tree-sitter-dir.mjs

@@ -121,3 +121,21 @@ export function resolveWebTreeSitterPackageDir(deps) {
 	}
 	return undefined;
 }
+
+/**
+ * The directory holding the core grammars an INSTALLED pi-lens can load, or
+ * undefined (#1185). The tarball ships them in `<packageRoot>/grammars` and the
+ * runtime reads that dir first (`bundledGrammarsDir` in
+ * clients/tree-sitter-client.ts); `<web-tree-sitter>/grammars` is only the
+ * lazy-fetch write target and nothing at install time fills it. The selftest
+ * used to probe only the latter, so it warned in every layout.
+ */
+export function findCoreGrammarDir({ packageRoot, webTreeSitterDir }) {
+	return [
+		path.join(packageRoot, "grammars"),
+		webTreeSitterDir && path.join(webTreeSitterDir, "grammars"),
+	].find(
+		(dir) =>
+			dir && fs.existsSync(path.join(dir, "tree-sitter-typescript.wasm")),
+	);
+}

package/node_modules/pi-typesafe/README.md

@@ -142,7 +142,7 @@ if (!answer.ok) return { skipped: answer.errorCode === "budget" };  // never thr
 
 Your extension owns its own user consent and budget; `/typesafe enable` applies only to this package's tool. Check `authState()` rather than your own consent flag before you report that judgments are on.
 
-Judgments can also go through OpenRouter: `createTypeSafe({ backend: "openrouter" })` sends them to `openrouter.ai` with the key from `OPENROUTER_API_KEY`. Command Code serves the same protocol: `createTypeSafe({ backend: "commandcode" })` sends them to `api.commandcode.ai` with the key from `COMMANDCODE_API_KEY` and the model `typesafe/jev`. Or pass a `BackendEndpoint` object as `backend` to name any host that serves the protocol: it brings its own key variable, never reads `TYPESAFE_API_KEY`, and `backendHost()` reports its destination host for your consent text. These backends have no login store, so `/typesafe login` does not apply to them. Pass the same `backend` to `authState`, `keySituation`, and `ensureApiKey`, or the status you report describes the TypeSafe key while the requests use another one. The `/typesafe` commands and the `typesafe_evaluate` tool always use the TypeSafe backend. Every export — the client, `ask`, batching, the usage ledger, auth state, and the `pi-typesafe/calibrate` and `pi-typesafe/ui` entry points — is in [docs/api.md](docs/api.md).
+Judgments can also go through OpenRouter: `createTypeSafe({ backend: "openrouter" })` sends them to `openrouter.ai` with the key from `OPENROUTER_API_KEY`. Command Code serves the same protocol: `createTypeSafe({ backend: "commandcode" })` sends them to `api.commandcode.ai` with the key from `COMMANDCODE_API_KEY` and the model `typesafe/jev`. So does Liquid AI: `createTypeSafe({ backend: "liquid" })` sends them to `api.liquid.ai` with the key from `LIQUID_API_KEY` and the model `d1:free`, which is free; pass `model: "d1"` for the paid model, priced at $0.040 per million input tokens. Liquid counts the state once per question, where TypeSafe counts it once per request, so a request with N questions costs about N times the state on Liquid. Speed, measured on 2026-10-03 with one request at a time: `d1:free` took a median of about 14 seconds and sometimes failed with HTTP 504 after about 46 seconds, while `d1` took about 0.5 seconds. With `d1:free`, raise `timeoutMs` above its 15-second default, or pass `model: "d1"`. Or pass a `BackendEndpoint` object as `backend` to name any host that serves the protocol: it brings its own key variable, never reads `TYPESAFE_API_KEY`, and `backendHost()` reports its destination host for your consent text. These backends have no login store, so `/typesafe login` does not apply to them. Pass the same `backend` to `authState`, `keySituation`, and `ensureApiKey`, or the status you report describes the TypeSafe key while the requests use another one. The `/typesafe` commands and the `typesafe_evaluate` tool always use the TypeSafe backend. Every export — the client, `ask`, batching, the usage ledger, auth state, and the `pi-typesafe/calibrate` and `pi-typesafe/ui` entry points — is in [docs/api.md](docs/api.md).
 
 ## Development
 

package/node_modules/pi-typesafe/dist/backends.d.ts

@@ -1,6 +1,6 @@
-export type TypeSafeBackend = "typesafe" | "openrouter" | "commandcode";
+export type TypeSafeBackend = "typesafe" | "openrouter" | "commandcode" | "liquid";
 export interface BackendConfig {
-    /** Human name for status lines: "TypeSafe", "OpenRouter", "Command Code". */
+    /** Human name for status lines: "TypeSafe", "OpenRouter", "Command Code", "Liquid AI". */
     label: string;
     host: string;
     /** The environment variable that carries this backend's key. Absent means the TypeSafe key resolution applies. */
@@ -16,6 +16,11 @@ export interface BackendConfig {
     /** Whether the model list checks the key. A public list accepts any key, so it proves nothing. Absent means it does. */
     modelsVerifyKey?: boolean;
 }
+/** A registry entry: a backend config that can also name a price per model. Caller-supplied endpoints carry none. */
+export interface RegistryBackendConfig extends BackendConfig {
+    /** USD per million input tokens, by the model id as it is sent. A model with no entry is priced at DEFAULT_USD_PER_MTOK. */
+    prices?: Readonly<Record<string, number>>;
+}
 /** A caller-supplied endpoint that serves the Jev decisions protocol. Passed per call; never added to the registry. */
 export interface BackendEndpoint extends BackendConfig {
     /** Required. The environment variable with this endpoint's key. Must not be TYPESAFE_API_KEY. */
@@ -26,7 +31,7 @@ export interface BackendEndpoint extends BackendConfig {
 /** A registry name or a caller-supplied endpoint. */
 export type BackendSpec = TypeSafeBackend | BackendEndpoint;
 /** A backend resolved and validated: what the client will actually use. */
-export interface ResolvedBackend extends BackendConfig {
+export interface ResolvedBackend extends RegistryBackendConfig {
     /** Registry name, absent for a caller-supplied endpoint. */
     readonly name?: TypeSafeBackend;
     /** Origin only: scheme, host, and port. */
@@ -42,9 +47,9 @@ export declare const DEFAULT_BACKEND: TypeSafeBackend;
 /** The environment variable and login store that the default backend reads. */
 export declare const TYPESAFE_KEY_ENV = "TYPESAFE_API_KEY";
 /** Registry of known judgment backends. Callers pass a `BackendEndpoint` for a host this registry does not name. */
-export declare const DECISIONS_BACKENDS: Record<TypeSafeBackend, BackendConfig>;
+export declare const DECISIONS_BACKENDS: Record<TypeSafeBackend, RegistryBackendConfig>;
 /** The registry entry for a backend name; a `configuration` error for a name the registry does not know. */
-export declare function backendConfig(name: TypeSafeBackend): BackendConfig;
+export declare function backendConfig(name: TypeSafeBackend): RegistryBackendConfig;
 /**
  * The model id to send for a caller's `model` on this backend. OpenRouter routes a bare Jev id under the `typesafe`
  * author: `jev-latest` becomes its alias form `~typesafe/jev-latest`, and a bare `jev-<major>.<minor>` — with or
@@ -55,6 +60,11 @@ export declare function backendConfig(name: TypeSafeBackend): BackendConfig;
 export declare function backendModelId(backend: TypeSafeBackend, model: string): string;
 /** The model a client sends when the caller names none: the backend's own default, in the form that backend accepts. */
 export declare function defaultModelId(backend: TypeSafeBackend): string;
+/**
+ * The registry's price for a model, in USD per million input tokens, or undefined when the backend names none.
+ * `model` is the id as sent. A caller-supplied endpoint has no prices.
+ */
+export declare function backendPrice(backend: ResolvedBackend, model: string): number | undefined;
 /**
  * Whether a backend's key comes from the TypeSafe resolution (`TYPESAFE_API_KEY`, then the login store) or only from
  * its own environment variable. Only the TypeSafe backend has a login store; every other backend is environment-only.

package/node_modules/pi-typesafe/dist/backends.js

@@ -26,6 +26,15 @@ export const DECISIONS_BACKENDS = {
         modelsIdField: "id",
         modelsVerifyKey: false,
     },
+    liquid: {
+        label: "Liquid AI",
+        host: "https://api.liquid.ai",
+        keyEnv: "LIQUID_API_KEY",
+        path: "/decisions/v1/systemone",
+        modelsPath: "/decisions/v1/models",
+        modelsVerifyKey: true,
+        prices: { d1: 0.04, "d1:free": 0 },
+    },
 };
 /** The registry entry for a backend name; a `configuration` error for a name the registry does not know. */
 export function backendConfig(name) {
@@ -39,6 +48,7 @@ const DEFAULT_MODEL = {
     typesafe: "jev-latest",
     openrouter: "typesafe/jev-1.13",
     commandcode: "typesafe/jev",
+    liquid: "d1:free",
 };
 /**
  * The model id to send for a caller's `model` on this backend. OpenRouter routes a bare Jev id under the `typesafe`
@@ -61,6 +71,14 @@ export function backendModelId(backend, model) {
 export function defaultModelId(backend) {
     return backendModelId(backend, DEFAULT_MODEL[backend]);
 }
+/**
+ * The registry's price for a model, in USD per million input tokens, or undefined when the backend names none.
+ * `model` is the id as sent. A caller-supplied endpoint has no prices.
+ */
+export function backendPrice(backend, model) {
+    const prices = backend.prices;
+    return prices !== undefined && Object.hasOwn(prices, model) ? prices[model] : undefined;
+}
 /**
  * Whether a backend's key comes from the TypeSafe resolution (`TYPESAFE_API_KEY`, then the login store) or only from
  * its own environment variable. Only the TypeSafe backend has a login store; every other backend is environment-only.

package/node_modules/pi-typesafe/dist/client.d.ts

@@ -2,8 +2,8 @@ import type { Fetch, Questions, SystemOneRequest, SystemOneResult } from "@types
 import type { BackendSpec } from "./backends.js";
 import type { BatchEvaluation, BatchOptions } from "./batch.js";
 import type { BlockedCap, SpendCaps, UsageLedger, UsageReport } from "./usage.js";
-export { backendHost, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
-export type { BackendConfig, BackendEndpoint, BackendSpec, ResolvedBackend, TypeSafeBackend } from "./backends.js";
+export { backendHost, backendPrice, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
+export type { BackendConfig, BackendEndpoint, BackendSpec, RegistryBackendConfig, ResolvedBackend, TypeSafeBackend } from "./backends.js";
 export interface TypeSafeOptions {
     /** Defaults to TYPESAFE_API_KEY, then the key saved by `/typesafe login`; never returned. */
     apiKey?: string;
@@ -23,7 +23,7 @@ export interface TypeSafeOptions {
     maxInputTokensPerDay?: number;
     /** Estimated spend per local day, in US dollars. Unlimited by default. */
     maxUsdPerDay?: number;
-    /** Price used for the cost estimate and the USD cap. Default: DEFAULT_USD_PER_MTOK. */
+    /** Price in USD per million input tokens, used for every request's cost and the USD cap; 0 means free. Default: the backend's price for the model sent, else DEFAULT_USD_PER_MTOK. */
     usdPerMTok?: number;
     /** The usage ledger; defaults to the store next to the key. Injected by tests. */
     ledger?: UsageLedger;
@@ -50,6 +50,7 @@ export interface SpendReport {
     readonly session: UsageSnapshot;
     readonly today: UsageReport;
     readonly caps: SpendCaps;
+    /** The price of this client's default model. A request that names another model may be priced differently. */
     readonly usdPerMTok: number;
     readonly blocked?: BlockedCap;
 }

package/node_modules/pi-typesafe/dist/client.js

@@ -1,12 +1,12 @@
 import { TypeSafeClient } from "@typesafe-ai/sdk";
 import { recordAuthFailure, recordAuthVerified } from "./auth.js";
-import { TYPESAFE_KEY_ENV, backendModelId, resolveBackend, usesTypesafeKey } from "./backends.js";
+import { TYPESAFE_KEY_ENV, backendModelId, backendPrice, resolveBackend, usesTypesafeKey } from "./backends.js";
 import { evaluateAll, evaluateMany } from "./batch.js";
 import { keySituation } from "./credentials.js";
 import { TypeSafeIntegrationError, safeError } from "./errors.js";
 import { DEFAULT_MAX_INPUT_BYTES, assertWithinByteLimit, prepareEvaluationRequest } from "./schema.js";
 import { DEFAULT_USD_PER_MTOK, capsFromEnvironment, estimateUsd, mergeCaps, openUsageLedger } from "./usage.js";
-export { backendHost, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
+export { backendHost, backendPrice, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
 /** The paths the SDK appends to whatever base URL it is given. */
 const SDK_PATH = "/v1/systemone";
 const SDK_MODELS_PATH = "/v1/models";
@@ -63,6 +63,12 @@ function positiveInteger(value, label) {
     }
     return value;
 }
+function nonNegativeNumber(value, label) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeSafeIntegrationError("configuration", `${label} must be a non-negative number.`);
+    }
+    return value;
+}
 function positiveNumber(value, label) {
     if (!Number.isFinite(value) || value <= 0) {
         throw new TypeSafeIntegrationError("configuration", `${label} must be a positive number.`);
@@ -138,7 +144,7 @@ export function createTypeSafe(options = {}) {
     const timeout = positiveInteger(options.timeoutMs ?? 15_000, "timeoutMs");
     const maxInputBytes = positiveInteger(options.maxInputBytes ?? DEFAULT_MAX_INPUT_BYTES, "maxInputBytes");
     const maxRequests = positiveInteger(options.maxRequests ?? DEFAULT_MAX_REQUESTS, "maxRequests");
-    const usdPerMTok = positiveNumber(options.usdPerMTok ?? DEFAULT_USD_PER_MTOK, "usdPerMTok");
+    const callerRate = options.usdPerMTok === undefined ? undefined : nonNegativeNumber(options.usdPerMTok, "usdPerMTok");
     const caps = mergeCaps({
         maxRequests,
         ...(options.maxRequestsPerDay === undefined ? {} : { maxRequestsPerDay: positiveInteger(options.maxRequestsPerDay, "maxRequestsPerDay") }),
@@ -165,12 +171,17 @@ export function createTypeSafe(options = {}) {
         logLevel: "off",
         ...(transport ? { fetch: transport } : {}),
     });
-    const ledger = options.ledger ?? openUsageLedger({ usdPerMTok });
+    // The caller's price wins; else the backend's price for the model sent; else the default. Each request is priced alone.
+    const rateFor = (sent) => callerRate ?? backendPrice(backend, sent) ?? DEFAULT_USD_PER_MTOK;
+    const usdPerMTok = rateFor(model);
+    // The ledger's own rate only estimates input tokens that carry no recorded cost, so it follows the caller's price alone.
+    const ledger = options.ledger ?? openUsageLedger(callerRate === undefined ? {} : { usdPerMTok: callerRate });
+    let sessionUsd = 0;
     const usage = { requestsStarted: 0, requestsSucceeded: 0, requestsFailed: 0, inputTokens: 0, outputTokens: 0 };
     // Auth state writes are deduplicated: one verification record per process, one record per distinct failure.
     let verificationRecorded = false;
     let lastFailureRecorded;
-    const snapshot = () => ({ ...usage, estimatedUsd: estimateUsd(usage.inputTokens, usdPerMTok) });
+    const snapshot = () => ({ ...usage, estimatedUsd: Math.round(sessionUsd * 1e6) / 1e6 });
     const blocked = () => (usage.requestsStarted >= maxRequests ? undefined : ledger.blocked(caps));
     const typesafe = {
         getUsage: snapshot,
@@ -203,7 +214,8 @@ export function createTypeSafe(options = {}) {
         async evaluate(input, callOptions = {}) {
             const validated = prepareEvaluationRequest(input, { maxInputBytes });
             // A per-request model meets the same mapping as the client default; the schema already limited the caller's own id.
-            const body = JSON.stringify({ ...validated, model: validated.model === undefined ? model : mapModel(validated.model) });
+            const sentModel = validated.model === undefined ? model : mapModel(validated.model);
+            const body = JSON.stringify({ ...validated, model: sentModel });
             assertWithinByteLimit(body, maxInputBytes);
             if (callOptions.signal?.aborted)
                 throw new TypeSafeIntegrationError("aborted", "TypeSafe request cancelled before submission.");
@@ -227,7 +239,10 @@ export function createTypeSafe(options = {}) {
                 usage.requestsSucceeded += 1;
                 usage.inputTokens += result.usage.input_tokens;
                 usage.outputTokens += result.usage.output_tokens;
-                ledger.recordSuccess(result.usage.input_tokens, result.usage.output_tokens);
+                // Unrounded: a small request must still count toward the cap.
+                const cost = (result.usage.input_tokens * rateFor(sentModel)) / 1e6;
+                sessionUsd += cost;
+                ledger.recordSuccess(result.usage.input_tokens, result.usage.output_tokens, cost);
                 if (!verificationRecorded) {
                     verificationRecorded = true;
                     recordAuthVerified();

package/node_modules/pi-typesafe/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { createTypeSafe, backendHost, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
-export type { TypeSafe, TypeSafeOptions, EvaluationOptions, Evaluation, UsageSnapshot, SpendReport, TypeSafeBackend, BackendConfig, BackendEndpoint, BackendSpec, ResolvedBackend, } from "./client.js";
+export { createTypeSafe, backendHost, backendPrice, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
+export type { TypeSafe, TypeSafeOptions, EvaluationOptions, Evaluation, UsageSnapshot, SpendReport, TypeSafeBackend, BackendConfig, BackendEndpoint, BackendSpec, RegistryBackendConfig, ResolvedBackend, } from "./client.js";
 export { ask, DEFAULT_ASK_TIMEOUT_MS } from "./ask.js";
 export type { AskAnswer, AskOptions, Judge } from "./ask.js";
 export { fanOut, DEFAULT_CONCURRENCY, evaluateMany, evaluateAll, chunkEvaluationRequest } from "./batch.js";

package/node_modules/pi-typesafe/dist/index.js

@@ -1,4 +1,4 @@
-export { createTypeSafe, backendHost, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
+export { createTypeSafe, backendHost, backendPrice, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
 export { ask, DEFAULT_ASK_TIMEOUT_MS } from "./ask.js";
 export { fanOut, DEFAULT_CONCURRENCY, evaluateMany, evaluateAll, chunkEvaluationRequest } from "./batch.js";
 export { authState, authStatePath, clearAuthState, describeAuth, recordAuthFailure, recordAuthVerified } from "./auth.js";

package/node_modules/pi-typesafe/dist/usage.d.ts

@@ -40,6 +40,10 @@ export declare function usagePath(): string;
 /** Input-token cost, rounded to a micro-dollar so the number stays readable. */
 export declare function estimateUsd(inputTokens: number, usdPerMTok: number): number;
 export declare function emptyTotals(): UsageTotals;
+/** Longest an update waits for the ledger lock. A request that cannot get it keeps its delta and adds it with the next update. */
+export declare const LOCK_WAIT_MS = 200;
+/** A lock this old belongs to a process that died while holding it; the next update takes it over. */
+export declare const LOCK_STALE_MS = 5000;
 /** The caps a headless run may set without code: `PI_TYPESAFE_MAX_USD_PER_DAY` and its siblings. */
 export declare function capsFromEnvironment(env?: NodeJS.ProcessEnv): SpendCaps;
 /** Environment first for day caps, then the explicit option; a cap is never raised by the environment. */
@@ -49,12 +53,15 @@ export interface UsageLedgerOptions {
     path?: string;
     /** Clock for the local day and for rollover; injectable for tests. */
     now?: () => Date;
+    /** Rate for input tokens that have no recorded cost: requests recorded without one, and days from an older ledger file. Default: DEFAULT_USD_PER_MTOK. */
     usdPerMTok?: number;
 }
 /**
- * One day of persisted request, token, and cost totals, plus the caps that stop the next request. The in-memory copy is
- * authoritative for this process; the file is the cross-process, across-restart record. Reads are defensive, writes are
- * atomic and best-effort, and a day rolls over on the local date, so a long eval cannot accumulate forever unnoticed.
+ * One day of persisted request, token, and cost totals, plus the caps that stop the next request. The file is the
+ * record for every process: each update adds its delta to the file's current content under a lock, and `today()`,
+ * `blocked()`, and `describe()` read the file, so a cap counts every process that writes it. A delta that cannot be
+ * written in time (the lock is held, or the file is unwritable) stays in this process and is added with its next
+ * update. Reads are defensive, writes are atomic and best-effort, and a day rolls over on the local date.
  */
 export interface UsageLedger {
     readonly path: string;
@@ -63,11 +70,14 @@ export interface UsageLedger {
     today(): UsageReport;
     /** Count the attempt before it is submitted; a request that never returns still counts. */
     recordStart(): void;
-    recordSuccess(inputTokens: number, outputTokens: number): void;
+    /** `usd` is this request's cost at its own price; without it the request is estimated at the ledger's rate. */
+    recordSuccess(inputTokens: number, outputTokens: number, usd?: number): void;
     recordFailure(): void;
     /** The reached day cap that blocks the next request, or undefined. The caller owns the caps. */
     blocked(caps: SpendCaps): BlockedCap | undefined;
     /** One line for status output: today's requests, tokens, and cost, with the caps that apply. */
     describe(caps?: SpendCaps): string;
+    /** Add to the file any delta this process still holds. Updates do this themselves; call it before the process exits. */
+    flush?(): void;
 }
 export declare function openUsageLedger(options?: UsageLedgerOptions): UsageLedger;