@vincemakes/kiso-runtime 0.2.0 → 0.2.1

package/dist/run.js

@@ -57,6 +57,29 @@ export class Run {
             this.#session.ensureHealthy();
             this.#session.beginRun(this);
             const log = this.#session.log;
+            // The static prompt parts — computed ONCE, before the tracer, and
+            // reused for both the composed string (below) and the rent ledger
+            // (E3): a single evaluation keeps the model-visible byte stream
+            // byte-identical to the pre-E3 run (I6, trace-bytes.test.ts).
+            // 0.1.40 (R-C item 1): the tool substitution table — the ACTIVE tool
+            // set's vocabulary, snippets, and guidelines — sits BETWEEN the
+            // session's base prompt and the extension appends: generated
+            // machinery never outranks the deliberate extension text (the E2
+            // "append lands at the END" contract holds). "" when empty.
+            const toolTable = composeToolTable(this.#config.registry);
+            const basePrompt = toolTable === "" ? this.#config.systemPrompt
+                : this.#config.systemPrompt === undefined ? toolTable
+                    : `${this.#config.systemPrompt}\n\n${toolTable}`;
+            // E3 — the ledger's parts: the base as CONFIGURED (what the CLI
+            // handed the runtime — the tool table is generated machinery, R3)
+            // and the extension appends in load order (R4 attribution). The
+            // composed string below is their result; the ledger counts the
+            // parts, observation-only. exactOptionalPropertyTypes: an absent
+            // surface is an absent key — never an explicit undefined (R9).
+            const rentParts = {
+                ...(this.#config.systemPrompt !== undefined ? { base: this.#config.systemPrompt } : {}),
+                appends: (this.#config.extensions ?? []).flatMap((e) => e.systemPrompt?.append === undefined ? [] : [{ name: e.name, text: e.systemPrompt.append }]),
+            };
             // E1 (1.2.0): the request tracer — the observation ledger. It
             // sits at the adapter boundary; the model-visible byte stream is
             // untouched (I6, trace-bytes.test.ts). Soft-fail: a degraded
@@ -69,21 +92,13 @@ export class Run {
                 model: this.#config.model,
                 adapterVersion: runtimeVersion(),
                 log: log.all,
+                rentParts,
             });
             tracer.init();
             const signal = this.#externalSignal ? new MergedSignal(this.#abort.signal, this.#externalSignal) : this.#abort.signal;
             // E2: the session's own microcompact wins; otherwise the FIRST
             // extension providing a compaction config supplies it.
             const microcompact = microcompactFor(this.#config);
-            // 0.1.40 (R-C item 1): the tool substitution table — the ACTIVE tool
-            // set's vocabulary, snippets, and guidelines — sits BETWEEN the
-            // session's base prompt and the extension appends: generated
-            // machinery never outranks the deliberate extension text (the E2
-            // "append lands at the END" contract holds). "" when empty.
-            const toolTable = composeToolTable(this.#config.registry);
-            const basePrompt = toolTable === "" ? this.#config.systemPrompt
-                : this.#config.systemPrompt === undefined ? toolTable
-                    : `${this.#config.systemPrompt}\n\n${toolTable}`;
             // E2: the session's own systemPrompt first, then every extension
             // append in LOAD order — deterministic (same extensions → same
             // prompt); no appends → byte-identical to the extension-less run.

package/dist/trace/guard.d.ts

@@ -22,6 +22,7 @@
  * the honest nullable quartet is a schema bump, deferred.
  */
 import type { Adapter, AdapterEvent, Event, StreamOptions } from "@vincemakes/kiso-core";
+import { type RentParts } from "./rent.js";
 export interface RequestTracerDeps {
     root: string;
     sessionId: string;
@@ -33,6 +34,11 @@ export interface RequestTracerDeps {
     adapterVersion?: string | null;
     /** The session log — the manifest's seqRange pointers derive from it. */
     log: readonly Event[];
+    /** E3 — the rent ledger's inputs: the base prompt as configured and
+     *  the per-extension appends in load order (the adapter's composed
+     *  systemPrompt is their RESULT — the parts are what the ledger
+     *  counts; the composed string itself is unchanged, I6). */
+    rentParts?: RentParts;
 }
 export declare class RequestTracer {
     #private;

package/dist/trace/guard.js

@@ -26,6 +26,7 @@ import { buildContextManifest, segmentHashes } from "./manifest.js";
 import { cacheableHashes } from "./analyze.js";
 import { hashContext, hashSystemPrompt, hashToolSpecs, stablePrefixFingerprint } from "./hash.js";
 import { PRICING_TABLE_V1, canonicalizeUsage } from "../usage/canonical.js";
+import { buildRentLedger } from "./rent.js";
 import { TRACE_SCHEMA_VERSION } from "./record.js";
 import { TraceWriter } from "./writer.js";
 export class RequestTracer {
@@ -34,6 +35,7 @@ export class RequestTracer {
     #provider;
     #runId;
     #adapterVersion;
+    #rentParts;
     #requestIndex = 0;
     #contextHashCounts = new Map();
     constructor(deps) {
@@ -42,6 +44,7 @@ export class RequestTracer {
         this.#provider = deps.provider;
         this.#runId = deps.runId;
         this.#adapterVersion = deps.adapterVersion ?? null;
+        this.#rentParts = deps.rentParts;
     }
     init() {
         this.#writer.init();
@@ -119,6 +122,18 @@ export class RequestTracer {
         this.#contextHashCounts.set(contextHash, retryAttempt + 1);
         const manifest = buildContextManifest({ log: this.#log, systemPrompt, tools, messages });
         const hashes = segmentHashes(systemPrompt, tools, messages);
+        // E3 — the static rent ledger, one line per surface; the envelope
+        // derives from the request the guard already has (R5), the base and
+        // the appends from the threaded parts (R3/R4 — observation only).
+        // exactOptionalPropertyTypes: an absent surface is an absent key —
+        // never an explicit undefined (R9).
+        const rentParts = this.#rentParts;
+        const rent = buildRentLedger({
+            model: options.model,
+            ...(rentParts?.base !== undefined ? { base: rentParts.base } : {}),
+            ...(rentParts?.appends !== undefined ? { appends: rentParts.appends } : {}),
+            ...(tools !== undefined ? { tools } : {}),
+        });
         return {
             schemaVersion: TRACE_SCHEMA_VERSION,
             kind: "request",
@@ -156,6 +171,7 @@ export class RequestTracer {
                 pricingTableId: PRICING_TABLE_V1.id,
                 pricingTableVersion: PRICING_TABLE_V1.version,
             },
+            rent,
             latencyMs: 0,
             ttftMs: 0,
             toolCalls: [],

package/dist/trace/record.d.ts

@@ -19,15 +19,24 @@
  * quartet stays as provider observation above it). The validators accept
  * BOTH generations (R1d-1): a v1 sidecar has no canonical block and reads
  * as defaults at every consumer — never a crash.
+ *
+ * E3 (0.2.1) — schemaVersion 3: the record gains the `rent` block — the
+ * static rent ledger, one line per surface (trace/rent.ts). The v3
+ * writers record it; v1/v2 sidecars keep reading as defaults (R1d-1,
+ * R2-1): no rent block = no rent lines = the zero-rent reading, never a
+ * crash.
  */
-/** schemaVersion: 2 for 1.3.0 (the canonical block). Version 1 = the 1.2.0
- *  shape, kept for generation-compat reads (R1d-1). Algorithm and shape
- *  changes bump it (ADR-0051 §6 OUT-side versioning). */
-export declare const TRACE_SCHEMA_VERSION = 2;
-/** The versions a reader may meet in a ledger. v1 records are accepted
- *  (generation-compat, R1d-1) and read as defaults — no canonical block. */
+/** schemaVersion: 3 for 0.2.1 (the rent block). Version 1 = the 1.2.0
+ *  shape, version 2 = the 1.3.0 shape; both kept for generation-compat
+ *  reads (R1d-1, R2-1). Algorithm and shape changes bump it (ADR-0051 §6
+ *  OUT-side versioning). */
+export declare const TRACE_SCHEMA_VERSION = 3;
+/** The versions a reader may meet in a ledger. v1 and v2 records are
+ *  accepted (generation-compat) and read as defaults — no canonical
+ *  block (v1), no rent block (v1, v2). */
 export declare const TRACE_SCHEMA_VERSIONS: Readonly<Set<number>>;
 import type { CanonicalUsage } from "../usage/canonical.js";
+import { type RentLine } from "./rent.js";
 export type Freshness = "fresh" | "cache_read" | "cache_write";
 /** That is the complete set for 1.2.0. */
 export type Outcome = "ok" | "provider_error" | "aborted";
@@ -43,7 +52,7 @@ export interface TraceSegment {
 }
 /** That is the complete set for 1.2.0. */
 export interface TraceRecord {
-    schemaVersion: 2;
+    schemaVersion: 3;
     kind: "request";
     requestId: string;
     runId: string;
@@ -77,6 +86,11 @@ export interface TraceRecord {
      *  the validator pins the equality — and carries the cost from the
      *  versioned pricing table (every cost records its table version). */
     canonical: CanonicalUsage;
+    /** E3 — the static rent ledger: one line per surface (system:base,
+     *  system:ext:<name>, tool:<name>, envelope), counts never payloads —
+     *  see trace/rent.ts. v3 requires the block; a v1/v2 sidecar has none
+     *  and reads as the zero-rent ledger (R2-1). */
+    rent: RentLine[];
     latencyMs: number;
     ttftMs: number;
     toolCalls: string[];
@@ -91,21 +105,21 @@ export interface TraceRecord {
 }
 /** That is the complete set for 1.2.0. */
 export interface HeaderLine {
-    schemaVersion: 2;
+    schemaVersion: 3;
     kind: "header";
     sessionId: string;
     kisoVersion: string;
     createdAt: number;
 }
 export interface RunEndLine {
-    schemaVersion: 2;
+    schemaVersion: 3;
     kind: "run_end";
     runId: string;
     ts: number;
     lastRequestIndex: number;
 }
 export interface CrashLine {
-    schemaVersion: 2;
+    schemaVersion: 3;
     kind: "crash";
     ts: number;
     note: string;
@@ -122,7 +136,9 @@ export declare function hashSpecFor(version: number): HashSpec;
  *  canonical block and reads as defaults at every consumer. */
 export declare const TRACE_RECORD_FIELDS_V1: readonly ["schemaVersion", "kind", "requestId", "runId", "requestIndex", "retryAttempt", "provider", "model", "adapterVersion", "systemPromptHash", "toolSchemaHash", "contextHash", "contextManifest", "segmentHashes", "stablePrefixFingerprint", "freshInput", "cacheRead", "cacheWrite", "output", "latencyMs", "ttftMs", "toolCalls", "outcome", "lineageLink", "ts"];
 /** The 1.3.0 field set (schemaVersion 2) = the v1 set + `canonical`. */
-export declare const TRACE_RECORD_FIELDS: readonly ["schemaVersion", "kind", "requestId", "runId", "requestIndex", "retryAttempt", "provider", "model", "adapterVersion", "systemPromptHash", "toolSchemaHash", "contextHash", "contextManifest", "segmentHashes", "stablePrefixFingerprint", "freshInput", "cacheRead", "cacheWrite", "output", "latencyMs", "ttftMs", "toolCalls", "outcome", "lineageLink", "ts", "canonical"];
+export declare const TRACE_RECORD_FIELDS_V2: readonly ["schemaVersion", "kind", "requestId", "runId", "requestIndex", "retryAttempt", "provider", "model", "adapterVersion", "systemPromptHash", "toolSchemaHash", "contextHash", "contextManifest", "segmentHashes", "stablePrefixFingerprint", "freshInput", "cacheRead", "cacheWrite", "output", "latencyMs", "ttftMs", "toolCalls", "outcome", "lineageLink", "ts", "canonical"];
+/** The 0.2.1 field set (schemaVersion 3) = the v2 set + `rent`. */
+export declare const TRACE_RECORD_FIELDS: readonly ["schemaVersion", "kind", "requestId", "runId", "requestIndex", "retryAttempt", "provider", "model", "adapterVersion", "systemPromptHash", "toolSchemaHash", "contextHash", "contextManifest", "segmentHashes", "stablePrefixFingerprint", "freshInput", "cacheRead", "cacheWrite", "output", "latencyMs", "ttftMs", "toolCalls", "outcome", "lineageLink", "ts", "canonical", "rent"];
 export declare const TRACE_SEGMENT_FIELDS: readonly ["role", "seqRange", "estTokens", "freshness"];
 export declare function validateTraceSegment(v: unknown): v is TraceSegment;
 export declare function validateTraceRecord(v: unknown): v is TraceRecord;

package/dist/trace/record.js

@@ -19,18 +19,28 @@
  * quartet stays as provider observation above it). The validators accept
  * BOTH generations (R1d-1): a v1 sidecar has no canonical block and reads
  * as defaults at every consumer — never a crash.
+ *
+ * E3 (0.2.1) — schemaVersion 3: the record gains the `rent` block — the
+ * static rent ledger, one line per surface (trace/rent.ts). The v3
+ * writers record it; v1/v2 sidecars keep reading as defaults (R1d-1,
+ * R2-1): no rent block = no rent lines = the zero-rent reading, never a
+ * crash.
  */
-/** schemaVersion: 2 for 1.3.0 (the canonical block). Version 1 = the 1.2.0
- *  shape, kept for generation-compat reads (R1d-1). Algorithm and shape
- *  changes bump it (ADR-0051 §6 OUT-side versioning). */
-export const TRACE_SCHEMA_VERSION = 2;
-/** The versions a reader may meet in a ledger. v1 records are accepted
- *  (generation-compat, R1d-1) and read as defaults — no canonical block. */
-export const TRACE_SCHEMA_VERSIONS = new Set([1, TRACE_SCHEMA_VERSION]);
+/** schemaVersion: 3 for 0.2.1 (the rent block). Version 1 = the 1.2.0
+ *  shape, version 2 = the 1.3.0 shape; both kept for generation-compat
+ *  reads (R1d-1, R2-1). Algorithm and shape changes bump it (ADR-0051 §6
+ *  OUT-side versioning). */
+export const TRACE_SCHEMA_VERSION = 3;
+/** The versions a reader may meet in a ledger. v1 and v2 records are
+ *  accepted (generation-compat) and read as defaults — no canonical
+ *  block (v1), no rent block (v1, v2). */
+export const TRACE_SCHEMA_VERSIONS = new Set([1, 2, TRACE_SCHEMA_VERSION]);
 import { PRICING_TABLE_V1, priceFor, pricingTableFor, validateCanonicalUsage } from "../usage/canonical.js";
+import { validateRentLine } from "./rent.js";
 export const HASH_SPEC_BY_VERSION = {
     1: { algorithm: "sha-256", output: "full-hex" },
     2: { algorithm: "sha-256", output: "full-hex" }, // E2 — the algorithms do not change
+    3: { algorithm: "sha-256", output: "full-hex" }, // E3 — same algorithms, re-pinned (the E2 ritual)
 };
 export function hashSpecFor(version) {
     const spec = HASH_SPEC_BY_VERSION[version];
@@ -72,7 +82,9 @@ export const TRACE_RECORD_FIELDS_V1 = [
     "ts",
 ];
 /** The 1.3.0 field set (schemaVersion 2) = the v1 set + `canonical`. */
-export const TRACE_RECORD_FIELDS = [...TRACE_RECORD_FIELDS_V1, "canonical"];
+export const TRACE_RECORD_FIELDS_V2 = [...TRACE_RECORD_FIELDS_V1, "canonical"];
+/** The 0.2.1 field set (schemaVersion 3) = the v2 set + `rent`. */
+export const TRACE_RECORD_FIELDS = [...TRACE_RECORD_FIELDS_V2, "rent"];
 export const TRACE_SEGMENT_FIELDS = ["role", "seqRange", "estTokens", "freshness"];
 // ── Validators ────────────────────────────────────────────────────────────
 // Strict by design: extra keys are rejected (the closed set), so a
@@ -119,12 +131,13 @@ export function validateTraceRecord(v) {
     if (!isRecord(v))
         return false;
     const version = v.schemaVersion;
-    // generation-compat (R1d-1): a v1 sidecar has no canonical block and
-    // reads as defaults — accepted, never a crash; the current version is
-    // fully checked (shape + the canonical block + its consistency).
-    if (version !== 1 && version !== TRACE_SCHEMA_VERSION)
+    // generation-compat (R1d-1, R2-1): a v1 sidecar has no canonical
+    // block, a v2 sidecar has no rent block — both read as defaults,
+    // accepted, never a crash; the current version is fully checked
+    // (shape + the canonical block + the rent ledger).
+    if (version !== 1 && version !== 2 && version !== TRACE_SCHEMA_VERSION)
         return false;
-    const fields = version === 1 ? TRACE_RECORD_FIELDS_V1 : TRACE_RECORD_FIELDS;
+    const fields = version === 1 ? TRACE_RECORD_FIELDS_V1 : version === 2 ? TRACE_RECORD_FIELDS_V2 : TRACE_RECORD_FIELDS;
     if (!hasClosedKeys(v, fields, ["lineageLink"]))
         return false;
     if (v.kind !== "request")
@@ -197,6 +210,13 @@ export function validateTraceRecord(v) {
                 return false;
         }
     }
+    if (version === TRACE_SCHEMA_VERSION) {
+        // the rent block: every line validates (closed fields, non-empty
+        // surface, non-negative integer chars, the estTokens == ceil(chars/4)
+        // cross-check — R6). v1/v2 sidecars have no block (R2-1).
+        if (!Array.isArray(v.rent) || !v.rent.every(validateRentLine))
+            return false;
+    }
     if (!isNumber(v.ts))
         return false;
     return true;

package/dist/trace/rent.d.ts

@@ -0,0 +1,81 @@
+/**
+ * E3 (0.2.1) — the rent ledger: every request's static model-side rent,
+ * one line per surface.
+ *
+ * The static rent is the surface the model pays REGARDLESS of the turn's
+ * content: the base system prompt, each extension's append, every tool's
+ * serialized spec, and the per-request envelope. One line per surface,
+ * four classes, measured in chars + the rounds' est-token convention
+ * (chars/4, ceil — the E1 script's formula, the work order's own words,
+ * R6):
+ *
+ *   - system:base       the session's own prompt as the CLI handed it
+ *                       (built-in constant + project instructions — the
+ *                       runtime cannot split those, R3). The runtime's
+ *                       generated tool table is machinery BETWEEN base and
+ *                       appends; it stays out of the ledger (counts live
+ *                       in tool:<name> lines and the base's own line).
+ *   - system:ext:<name> one line per extension with a non-empty
+ *                       systemPrompt.append, measured on the append
+ *                       string, in load order.
+ *   - tool:<name>       one line per tool, measured on the exact
+ *                       serialized ToolSpec projection the adapters
+ *                       receive ({name, description, inputSchema} — the
+ *                       registry.toSpecs() shape, protocol/messages.ts).
+ *   - envelope          the per-request fixed overhead OUTSIDE the
+ *                       conversation payloads: the R5 skeleton
+ *                       JSON.stringify({model, messages: [], tools: []})
+ *                       — a function of the model string only, never of
+ *                       the payloads (the skeleton is the definition).
+ *
+ * R9: an absent surface is an absent line — an unconfigured mcp, a
+ * session with no project instructions: no line. The absence IS the
+ * ledger statement (the 0.1.45 diet-A precedent: not paid = no rent).
+ *
+ * Determinism (the reviewer-facing property): every line is derivable
+ * from components the reviewer can recompute — the exported prompt
+ * constant, the appends, the ToolSpec array, the request skeleton. The
+ * ledger stores COUNTS, never payloads (the seqRange thin-pointer
+ * discipline applied to rent).
+ *
+ * buildRentLedger is the SINGLE source: the R7 star gate drives a real
+ * session with the script's predicted composition and asserts the
+ * recorded ledger equals the prediction line for line.
+ */
+import type { ToolSpec } from "@vincemakes/kiso-core";
+export interface RentLine {
+    /** "system:base" | "system:ext:<name>" | "tool:<name>" | "envelope" */
+    surface: string;
+    /** length of the serialized surface, measured, never a copy */
+    chars: number;
+    /** Math.ceil(chars / 4) — the E1 script convention, pinned (R6) */
+    estTokens: number;
+}
+/** The closed line set (the same gate discipline as the record fields). */
+export declare const RENT_LINE_FIELDS: readonly ["surface", "chars", "estTokens"];
+/** What the runtime knows about the static surface beyond what the
+ *  adapter call itself carries: the base prompt as configured, and the
+ *  per-extension appends in load order (the adapter's composed
+ *  systemPrompt is the result — the parts are the ledger's inputs). */
+export interface RentParts {
+    base?: string;
+    appends?: readonly {
+        name: string;
+        text: string;
+    }[];
+}
+export interface RentInput extends RentParts {
+    model: string;
+    tools?: readonly ToolSpec[];
+}
+/** The one ledger: system:base, then system:ext:* (load order), then
+ *  tool:* (the array's order — the registry's toSpecs() order), then the
+ *  envelope. Absent surfaces contribute no lines (R9). */
+export declare function buildRentLedger(input: RentInput): RentLine[];
+/** The line validator — the same strict discipline as the record's other
+ *  closed sets: no key outside the spec, every spec'd key present,
+ *  non-empty surface (R9: a line exists only for a surface that exists),
+ *  non-negative integer chars, and the estTokens cross-check (R6). The
+ *  schema pins the LINE, not the multiset — duplicate surfaces are the
+ *  writer's business, never a schema crash. */
+export declare function validateRentLine(v: unknown): v is RentLine;

package/dist/trace/rent.js

@@ -0,0 +1,96 @@
+/**
+ * E3 (0.2.1) — the rent ledger: every request's static model-side rent,
+ * one line per surface.
+ *
+ * The static rent is the surface the model pays REGARDLESS of the turn's
+ * content: the base system prompt, each extension's append, every tool's
+ * serialized spec, and the per-request envelope. One line per surface,
+ * four classes, measured in chars + the rounds' est-token convention
+ * (chars/4, ceil — the E1 script's formula, the work order's own words,
+ * R6):
+ *
+ *   - system:base       the session's own prompt as the CLI handed it
+ *                       (built-in constant + project instructions — the
+ *                       runtime cannot split those, R3). The runtime's
+ *                       generated tool table is machinery BETWEEN base and
+ *                       appends; it stays out of the ledger (counts live
+ *                       in tool:<name> lines and the base's own line).
+ *   - system:ext:<name> one line per extension with a non-empty
+ *                       systemPrompt.append, measured on the append
+ *                       string, in load order.
+ *   - tool:<name>       one line per tool, measured on the exact
+ *                       serialized ToolSpec projection the adapters
+ *                       receive ({name, description, inputSchema} — the
+ *                       registry.toSpecs() shape, protocol/messages.ts).
+ *   - envelope          the per-request fixed overhead OUTSIDE the
+ *                       conversation payloads: the R5 skeleton
+ *                       JSON.stringify({model, messages: [], tools: []})
+ *                       — a function of the model string only, never of
+ *                       the payloads (the skeleton is the definition).
+ *
+ * R9: an absent surface is an absent line — an unconfigured mcp, a
+ * session with no project instructions: no line. The absence IS the
+ * ledger statement (the 0.1.45 diet-A precedent: not paid = no rent).
+ *
+ * Determinism (the reviewer-facing property): every line is derivable
+ * from components the reviewer can recompute — the exported prompt
+ * constant, the appends, the ToolSpec array, the request skeleton. The
+ * ledger stores COUNTS, never payloads (the seqRange thin-pointer
+ * discipline applied to rent).
+ *
+ * buildRentLedger is the SINGLE source: the R7 star gate drives a real
+ * session with the script's predicted composition and asserts the
+ * recorded ledger equals the prediction line for line.
+ */
+/** The closed line set (the same gate discipline as the record fields). */
+export const RENT_LINE_FIELDS = ["surface", "chars", "estTokens"];
+const line = (surface, text) => ({
+    surface,
+    chars: text.length,
+    estTokens: Math.ceil(text.length / 4),
+});
+/** The one ledger: system:base, then system:ext:* (load order), then
+ *  tool:* (the array's order — the registry's toSpecs() order), then the
+ *  envelope. Absent surfaces contribute no lines (R9). */
+export function buildRentLedger(input) {
+    const lines = [];
+    if (input.base !== undefined)
+        lines.push(line("system:base", input.base));
+    for (const append of input.appends ?? [])
+        lines.push(line(`system:ext:${append.name}`, append.text));
+    for (const tool of input.tools ?? []) {
+        lines.push(line(`tool:${tool.name}`, JSON.stringify({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema })));
+    }
+    // R5: the envelope is the request skeleton — a model-string function,
+    // never the payloads; the empty arrays are literal (the definition).
+    lines.push(line("envelope", JSON.stringify({ model: input.model, messages: [], tools: [] })));
+    return lines;
+}
+/** The line validator — the same strict discipline as the record's other
+ *  closed sets: no key outside the spec, every spec'd key present,
+ *  non-empty surface (R9: a line exists only for a surface that exists),
+ *  non-negative integer chars, and the estTokens cross-check (R6). The
+ *  schema pins the LINE, not the multiset — duplicate surfaces are the
+ *  writer's business, never a schema crash. */
+export function validateRentLine(v) {
+    if (typeof v !== "object" || v === null || Array.isArray(v))
+        return false;
+    const o = v;
+    const keys = Object.keys(o);
+    const fields = RENT_LINE_FIELDS;
+    if (keys.some((k) => !fields.includes(k)))
+        return false;
+    if (!fields.every((k) => k in o))
+        return false;
+    if (typeof o.surface !== "string" || o.surface.length === 0)
+        return false;
+    const chars = o.chars;
+    const estTokens = o.estTokens;
+    if (typeof chars !== "number" || !Number.isInteger(chars) || chars < 0)
+        return false;
+    if (typeof estTokens !== "number" || !Number.isInteger(estTokens) || estTokens < 0)
+        return false;
+    if (estTokens !== Math.ceil(chars / 4))
+        return false;
+    return true;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vincemakes/kiso-runtime",
-  "version": "0.2.0",
-  "description": "kiso runtime — durable multi-turn agent sessions: AgentDefinition, AgentRuntime, AgentSession, Run, append-only JSONL store.",
+  "version": "0.2.1",
+  "description": "kiso runtime \u2014 durable multi-turn agent sessions: AgentDefinition, AgentRuntime, AgentSession, Run, append-only JSONL store.",
   "type": "module",
   "license": "MIT",
   "exports": {