@mmnto/cli 1.68.0 → 1.69.0

package/dist/commands/spine-llm-replay.js

@@ -0,0 +1,492 @@
+/**
+ * ADR-111 miner slice 5b-i — the deterministic LLM record/replay SCAFFOLD.
+ *
+ * The certifying run (slice 5) introduces the miner's first NON-deterministic,
+ * LLM-backed components (the live `DraftExtractor` / `DraftClassifier` adapters,
+ * slice 5b-ii). The cohort panel's central answer (consolidated fold A, 4/4) is
+ * that those live outputs must be FROZEN into a recorded replay artifact so the
+ * scorer + falsification harness can re-run the certifying experiment ZERO-LLM,
+ * byte-deterministically, and auditably — "arguably contract-MANDATED" by §6
+ * (fail-loud, no degrade) + §8 (every decision ledgered) + Tenet-15.
+ *
+ * THIS file is the deterministic record/replay scaffold proven in isolation with
+ * a STUB orchestrator: NO live LLM, NO network, NO prompts (those are slice
+ * 5b-ii, which populates the provenance block from the real adapter). It defines:
+ *
+ *   - the `llm-replay.v1` Zod artifact (two typed record sections + a provenance
+ *     block), CLI-side — the replay artifact is a CLI-layer concern; core stays
+ *     unaware of it;
+ *   - the deterministic `inputKey` digests for the extractor + classifier ports
+ *     (mirroring core's `deriveClaimId` — `sha256("<prefix>" + canonicalJson(...))`
+ *     over IDENTITY fields only);
+ *   - record/replay decorators (generic over the port) that wrap the core ports;
+ *   - the EXTERNAL-expected-hash integrity gate (fold B — a self-hash the artifact
+ *     validates against itself is circular; a content+hash co-rewrite would pass).
+ *
+ * Determinism discipline: this module is `new Date()` / `Math.random()` -free. A
+ * recorded `[]` (extractor) or `{behavioral, error-default}` (classifier) is a
+ * REAL row — present in the map, distinguishable from a missing key (a replay
+ * MISS is a corpus-integrity failure, never a safe-default).
+ *
+ * Reuse (Tenet-21): the canonical key-sorted serializer (`canonicalStringify`),
+ * the full-digest hash (`calculateDeterministicHash` shape), the `deriveClaimId`
+ * identity-fields-only pattern, and the wind-tunnel's external-expected-hash
+ * integrity discipline (`verifyControlIntegrity`) are all reused, not reinvented.
+ */
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+// ─── Named constants ─────────────────────────────────
+/**
+ * inputKey version prefixes (mirrors core's `CLAIM_ID_VERSION` discipline). The
+ * version is folded INTO the canonical identity payload (`keyVersion` field) AND
+ * prepended to the digest input, so the key space is partitioned by both port
+ * kind and schema version — a future identity-shape change re-keys cleanly
+ * instead of silently colliding with v1 keys.
+ */
+const EXTRACTOR_KEY_VERSION = 'extractor:v1';
+const CLASSIFIER_KEY_VERSION = 'classifier:v1';
+// ─── Errors (CLI-layer; loud-by-construction) ────────
+/**
+ * A replay query hit an `inputKey` absent from the frozen records. This is a
+ * CORPUS-INTEGRITY failure, never a recoverable per-PR condition: the frozen
+ * experiment's premise is that every input the certifying run will ask for was
+ * recorded. A miss means the corpus drifted out from under the replay (a new
+ * input appeared, or a recorded one was dropped). Falling back to `[]` /
+ * `{behavioral, error-default}` would absorb that drift silently and let the
+ * certifying verdict diverge from the frozen one undetected — so we throw.
+ */
+export class ReplayMissError extends Error {
+    adapterKind;
+    inputKey;
+    constructor(adapterKind, inputKey) {
+        super(`${adapterKind} replay MISS: inputKey ${inputKey} is absent from the frozen records. ` +
+            `A miss is a corpus-integrity failure (the frozen-experiment premise is broken), never a safe-default — ` +
+            `re-record the replay fixture from the live adapter so it covers this input.`);
+        this.name = 'ReplayMissError';
+        this.adapterKind = adapterKind;
+        this.inputKey = inputKey;
+    }
+}
+/**
+ * The loaded replay fixture's content-hash does not match the EXTERNAL expected
+ * hash injected at construction (fold B). The expected hash is supplied by the
+ * caller (5c sources it from a committed lock), NOT embedded in the artifact —
+ * an embedded self-hash would be circular (a content+hash co-rewrite passes its
+ * own check). A mismatch means the fixture was tampered with or drifted; the
+ * replay must NOT proceed, so we throw AT CONSTRUCTION (before any query).
+ */
+export class FixtureIntegrityError extends Error {
+    expectedHash;
+    actualHash;
+    constructor(expectedHash, actualHash) {
+        super(`replay fixture integrity check failed — expected ${expectedHash} got ${actualHash}. ` +
+            `The frozen LLM record/replay artifact was altered (tampered or drifted). Revert the change or ` +
+            `re-freeze the lock with the updated content-hash.`);
+        this.name = 'FixtureIntegrityError';
+        this.expectedHash = expectedHash;
+        this.actualHash = actualHash;
+    }
+}
+/**
+ * Recording the same `(adapterKind, inputKey)` twice with (potentially)
+ * different outputs. The record sink is APPEND-ONCE: a duplicate is never
+ * last-write-wins (that would silently launder a non-deterministic adapter's
+ * second answer over its first). The recording run must be deterministic, so a
+ * duplicate key is a producer bug → throw.
+ */
+export class DuplicateRecordError extends Error {
+    adapterKind;
+    inputKey;
+    constructor(adapterKind, inputKey) {
+        super(`duplicate record for ${adapterKind} inputKey ${inputKey} — the record sink is append-once ` +
+            `(never last-write-wins). A second output for the same input is a non-determinism leak in the recording run.`);
+        this.name = 'DuplicateRecordError';
+        this.adapterKind = adapterKind;
+        this.inputKey = inputKey;
+    }
+}
+// ─── Canonical serialization (reused, not reinvented) ─
+/**
+ * Recursively rebuild a value with object keys in SORTED order so the subsequent
+ * stringify is canonical (mirrors core's `canonicalize` in `artifacts/hash.ts`).
+ * Arrays keep element order (a reordered array is a different payload). Used for
+ * BOTH the inputKey digest payloads and the records-block content-hash, so the
+ * pure replay path has no git / IO dependency.
+ */
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (typeof value === 'object' && value !== null) {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = canonicalize(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+/** Canonical (recursively key-sorted) minified JSON serialization of `payload`. */
+function canonicalJson(payload) {
+    return JSON.stringify(canonicalize(payload));
+}
+/** Full sha256 hex (64 chars) — the digest IS an identity, never a truncation. */
+function sha256Hex(input) {
+    return createHash('sha256').update(input, 'utf-8').digest('hex');
+}
+// ─── inputKey derivation (fold D — the `deriveClaimId` pattern) ───────────────
+/**
+ * Normalize a single review thread to its STABLE identity: sort comments by
+ * (body, author) and carry only the resolution flags + path. Provider/array
+ * order must not change the key, so comments are sorted by a stable tuple before
+ * hashing. Resolved/outdated flags ARE part of the identity (the eligible-thread
+ * set the extractor was actually handed depends on them).
+ */
+function normalizeThread(thread) {
+    const comments = [...thread.comments].sort((a, b) => a.body !== b.body
+        ? a.body < b.body
+            ? -1
+            : 1
+        : a.author < b.author
+            ? -1
+            : a.author > b.author
+                ? 1
+                : 0);
+    return {
+        path: thread.path,
+        isResolved: thread.isResolved,
+        isOutdated: thread.isOutdated,
+        comments,
+    };
+}
+/**
+ * Normalize the eligible thread set: per-thread comment-normalize, then sort by the
+ * FULL canonical JSON of each normalized thread. Sorting by `(path, first-comment)`
+ * was NOT a total order — two threads on the SAME path sharing a first comment but
+ * differing in LATER comments compared equal, so their provider array order leaked
+ * into the canonical payload and the same logical input keyed differently (greptile
+ * P1 + CR, #2209; a PR commonly has multiple threads on one file). Sorting by the
+ * whole canonical thread IS a total order: two threads compare equal only when
+ * byte-identical, so neither thread nor comment order from the provider can shift
+ * the key. Stripped of any non-deterministic field — `ReviewThread` carries only
+ * `path`, resolution flags, and `{author, body}` comments, all stable.
+ */
+function normalizeThreads(threads) {
+    return threads.map(normalizeThread).sort((a, b) => {
+        const ka = canonicalJson(a);
+        const kb = canonicalJson(b);
+        return ka < kb ? -1 : ka > kb ? 1 : 0;
+    });
+}
+/**
+ * Filter to the EXACT eligible set the extractor is handed: non-resolved,
+ * non-outdated threads (mirrors core's `eligibleThreads`). The inputKey is a
+ * function of what the port ACTUALLY saw, so eligibility must be applied before
+ * normalizing — two contents that differ only in resolved/outdated threads
+ * (which the extractor never sees) still key identically.
+ */
+function eligibleThreads(threads) {
+    return threads.filter((t) => !t.isResolved && !t.isOutdated);
+}
+/**
+ * Deterministic extractor inputKey (fold D). `sha256(canonicalJson({ keyVersion,
+ * pr, mergeCommitSha, threads: <normalized eligible threads> }))`. MUST include
+ * `mergeCommitSha` (provenance identity). The eligible set is normalized so
+ * provider thread/comment order can't change the key; resolved/outdated threads
+ * are excluded (the port never sees them). Mirrors `deriveClaimId`: the version
+ * is BOTH a payload field and a digest-input prefix.
+ */
+export function extractorInputKey(content) {
+    const payload = {
+        keyVersion: EXTRACTOR_KEY_VERSION,
+        pr: content.pr,
+        mergeCommitSha: content.mergeCommitSha,
+        threads: normalizeThreads(eligibleThreads(content.threads)),
+    };
+    return sha256Hex(`${EXTRACTOR_KEY_VERSION}${canonicalJson(payload)}`);
+}
+/**
+ * Deterministic classifier inputKey (fold D). `sha256(canonicalJson({
+ * keyVersion, provenance, dslSource, draftRef }))`. The classifier does NOT
+ * dedupe drafts — TWO drafts from the SAME provenance must not collide to one
+ * key — so `draftRef` (a stable ordinal/ref the caller supplies, e.g. the slice-3
+ * per-(pr, ordinal) candidate ref) disambiguates them. Without it, N drafts with
+ * an identical body from one PR would map to one record and lose N-1 outputs.
+ */
+export function classifierInputKey(draft, draftRef) {
+    const payload = {
+        keyVersion: CLASSIFIER_KEY_VERSION,
+        provenance: draft.provenance,
+        dslSource: draft.dslSource,
+        draftRef,
+    };
+    return sha256Hex(`${CLASSIFIER_KEY_VERSION}${canonicalJson(payload)}`);
+}
+// ─── The `llm-replay.v1` artifact (Zod, CLI-side) ─────
+/**
+ * Run-level provenance block. In 5b-i these fields are populated by the (stub)
+ * caller — the SCHEMA and the integrity gate covering them are what this slice
+ * builds; 5b-ii populates them from the live adapter. They pin the exact frozen
+ * experiment (prompt + model + adapter + key version + tool version) so a replay
+ * is reproducible and a provenance drift is detectable. Provenance lives OUTSIDE
+ * the records map (the records block is strictly `inputKey → output`).
+ */
+export const ReplayProvenanceSchema = z.object({
+    /** sha256 of the frozen draft/classify prompt TEMPLATE (the decaying-prompt pin). */
+    promptTemplateHash: z.string(),
+    /** sha256 of the frozen system prompt. */
+    systemPromptHash: z.string(),
+    /** LLM provider id (e.g. `anthropic` / `gemini` / `openai`). */
+    provider: z.string(),
+    /** Model id (e.g. a pinned model snapshot). */
+    model: z.string(),
+    /** Decode temperature the frozen outputs were produced at. */
+    temperature: z.number(),
+    /** The orchestrator build the live adapter ran under. */
+    orchestratorVersion: z.string(),
+    /** Which port adapter produced these records (`extractor` / `classifier` / a combined run). */
+    adapterKind: z.string(),
+    /** The inputKey schema version (so a key-shape change is recorded, not silent). */
+    keyVersion: z.string(),
+    /** The totem/CLI version that froze the artifact. */
+    totemVersion: z.string(),
+});
+/**
+ * The records block: STRICTLY `inputKey → the port's raw return value`. A
+ * recorded `[]` (extractor) / `{behavioral, error-default}` (classifier) is a
+ * REAL row, distinct from a missing key. NEVER write `durationMs` / `recordedAt`
+ * / local-user / run-id into a record — those are non-deterministic / identifying
+ * metadata that would corrupt the content-hash and break the frozen-experiment
+ * premise. The maps are plain `Record<inputKey, output>`; record keys are
+ * written SORTED by the canonical serializer (clean git diffs).
+ */
+/**
+ * CLI-side validation of a recorded `ClassifierResult` (GCA #2209 + the cohort
+ * panel's "replay artifact schema is a CLI-layer concern", gemini): a LOCAL Zod
+ * schema rather than a static runtime import of core's `ClassifierResultSchema`
+ * (which would pull the heavy `@mmnto/totem` barrel onto the CLI-startup path).
+ * Mirrors core's shape AND its refinement (`error-default` ⟹ `behavioral`, the
+ * low-privilege safe-default) so a recorded `{structural, error-default}` is
+ * rejected. A test asserts parity with core, so this duplication can't silently
+ * drift if core's `ClassifierResult` changes.
+ */
+export const ClassifierResultLocalSchema = z
+    .object({
+    disposition: z.enum(['structural', 'behavioral']),
+    dispositionSource: z.enum(['classified', 'error-default']),
+})
+    .refine((v) => v.dispositionSource !== 'error-default' || v.disposition === 'behavioral', {
+    message: "dispositionSource 'error-default' requires disposition 'behavioral'",
+});
+export const ReplayRecordsSchema = z.object({
+    /** `inputKey → DraftExtractor.draft()` return (a `string[]`; `[]` is a real row). */
+    extractor: z.record(z.array(z.string())),
+    /** `inputKey → DraftClassifier.classify()` return (a `ClassifierResult`). */
+    classifier: z.record(ClassifierResultLocalSchema),
+});
+/** Stable artifact-format tag — bumped if the envelope shape changes. */
+export const REPLAY_ARTIFACT_KIND = 'llm-replay.v1';
+/** The full `llm-replay.v1` artifact: format tag + provenance + the two record sections. */
+export const ReplayArtifactSchema = z.object({
+    kind: z.literal(REPLAY_ARTIFACT_KIND),
+    provenance: ReplayProvenanceSchema,
+    records: ReplayRecordsSchema,
+});
+/**
+ * Serialize an artifact to canonical, key-SORTED JSON, PRETTY-printed for a
+ * committable artifact + clean diffs. Record keys land sorted because the
+ * canonicalizer recursively sorts object keys — so re-freezing in a different
+ * insertion order is a no-op diff.
+ *
+ * NOTE (greptile/CR #2209): the content-hash (`computeArtifactHash`) is computed
+ * over the MINIFIED canonical form (`canonicalJson`), NOT these pretty-printed
+ * bytes. Both run through the same `canonicalize` (so they never drift on key
+ * order), but they are NOT byte-identical — to verify integrity always call
+ * `computeArtifactHash(loadedArtifact)`; never `sha256` the raw file bytes.
+ */
+export function serializeReplayArtifact(artifact) {
+    return JSON.stringify(canonicalize(ReplayArtifactSchema.parse(artifact)), null, 2);
+}
+/**
+ * The artifact CONTENT-HASH (fold B + fold F): sha256 over the canonically-
+ * serialized WHOLE artifact (kind + provenance + records). Deterministic +
+ * git-independent (the pure replay path has no git dependency — contrast the
+ * wind-tunnel's `git hash-object`, which 5c may switch to for wind-tunnel
+ * consistency, out of scope here). Hashing the WHOLE artifact (not records-only)
+ * means the integrity gate ALSO COVERS the provenance block — so a prompt / model
+ * / key-version edit (e.g. `promptTemplateHash`) WITHOUT a re-record trips the
+ * gate (fold F: a prompt change must force a re-record, never silently serve
+ * stale outputs under a changed prompt). The expected hash is EXTERNAL (caller-
+ * injected; 5c sources it from a committed lock) — never embedded (a self-hash
+ * the artifact validates against itself is circular: a content+hash co-rewrite
+ * would pass its own check).
+ */
+export function computeArtifactHash(artifact) {
+    return hashParsedArtifact(ReplayArtifactSchema.parse(artifact));
+}
+/**
+ * Hash an ALREADY-parsed artifact — no redundant re-parse (CR #2209). The Replay
+ * constructors parse the fixture once, then the integrity gate hashes that parsed
+ * value directly via this helper; `computeArtifactHash` (public) parses first for
+ * untrusted input. Both produce the same digest for a valid artifact.
+ */
+function hashParsedArtifact(parsed) {
+    return sha256Hex(canonicalJson(parsed));
+}
+// ─── Record sink ─────────────────────────────────────
+/**
+ * The append-once record sink the `Recording*` decorators write into. Holds the
+ * in-progress records map; `freeze()` produces the immutable artifact. A
+ * duplicate `(adapterKind, inputKey)` throws `DuplicateRecordError` — never
+ * last-write-wins (a second output for the same input is a non-determinism leak
+ * the recording run must surface, not absorb).
+ */
+export class ReplayRecordSink {
+    extractor = new Map();
+    classifier = new Map();
+    recordExtractor(inputKey, output) {
+        if (this.extractor.has(inputKey))
+            throw new DuplicateRecordError('extractor', inputKey);
+        this.extractor.set(inputKey, output);
+    }
+    recordClassifier(inputKey, output) {
+        if (this.classifier.has(inputKey))
+            throw new DuplicateRecordError('classifier', inputKey);
+        this.classifier.set(inputKey, output);
+    }
+    /** Snapshot the records as a plain (Zod-validated) object — keys land sorted on serialize. */
+    records() {
+        return ReplayRecordsSchema.parse({
+            extractor: Object.fromEntries(this.extractor),
+            classifier: Object.fromEntries(this.classifier),
+        });
+    }
+    /** Assemble the full `llm-replay.v1` artifact from the recorded sink + a provenance block. */
+    freeze(provenance) {
+        return ReplayArtifactSchema.parse({
+            kind: REPLAY_ARTIFACT_KIND,
+            provenance,
+            records: this.records(),
+        });
+    }
+}
+// ─── Recording decorators (generic over the port) ─────
+/**
+ * Records every `DraftExtractor.draft()` call's inputKey → raw `string[]` output
+ * into the sink, then passes the value THROUGH unchanged. The recorded value is
+ * the PORT's return (pre-core-funnel) — a recorded `[]` is a real row. A
+ * duplicate inputKey throws (via the sink).
+ */
+export class RecordingDraftExtractor {
+    wrapped;
+    sink;
+    constructor(wrapped, sink) {
+        this.wrapped = wrapped;
+        this.sink = sink;
+    }
+    async draft(content) {
+        const output = await this.wrapped.draft(content);
+        this.sink.recordExtractor(extractorInputKey(content), output);
+        return output;
+    }
+}
+/**
+ * Records every `DraftClassifier.classify()` call's inputKey → raw
+ * `ClassifierResult` output into the sink, then passes it through unchanged. The
+ * caller supplies a `draftRef` (the disambiguator for multiple drafts from one
+ * provenance — fold D). A duplicate inputKey throws (via the sink).
+ *
+ * `classify` does not take a `draftRef` in the core port signature, so the
+ * decorator binds it via a per-draft ref RESOLVER the caller supplies (e.g. the
+ * slice-3 per-(pr, ordinal) candidate ref). The resolver is pure + deterministic.
+ */
+export class RecordingDraftClassifier {
+    wrapped;
+    sink;
+    draftRef;
+    constructor(wrapped, sink, draftRef) {
+        this.wrapped = wrapped;
+        this.sink = sink;
+        this.draftRef = draftRef;
+    }
+    async classify(draft) {
+        const output = await this.wrapped.classify(draft);
+        this.sink.recordClassifier(classifierInputKey(draft, this.draftRef(draft)), output);
+        return output;
+    }
+}
+// ─── Replay decorators (PURE — zero live calls) ───────
+/**
+ * Validate the loaded fixture's whole-artifact content-hash against the EXTERNAL
+ * expected hash (fold B + fold F — provenance is covered, so a prompt-hash edit
+ * trips the gate). Throws `FixtureIntegrityError` on mismatch. Shared by both
+ * replay decorators so the gate runs exactly once per construction with one
+ * implementation.
+ */
+function assertFixtureIntegrity(artifact, expectedHash) {
+    // `artifact` is already Zod-parsed by the Replay constructor — hash it directly,
+    // no redundant re-parse (CR #2209; matters for high-volume 5c runs).
+    const actualHash = hashParsedArtifact(artifact);
+    if (actualHash !== expectedHash)
+        throw new FixtureIntegrityError(expectedHash, actualHash);
+}
+/**
+ * PURE replay of `DraftExtractor` — zero live LLM / network calls. Computes the
+ * inputKey for the requested content, looks it up in the frozen records:
+ *   - HIT  → return the recorded `string[]` (including a recorded `[]` — a real row);
+ *   - MISS → throw `ReplayMissError` (NEVER fall back to `[]`).
+ *
+ * Integrity (fold B + F): the constructor takes the EXTERNAL expected content-
+ * hash, computes the actual WHOLE-ARTIFACT hash (records + provenance), and throws
+ * `FixtureIntegrityError` AT CONSTRUCTION on mismatch — so a tampered/drifted
+ * fixture (records OR a prompt-provenance edit) can never serve a single replay.
+ */
+export class ReplayDraftExtractor {
+    records;
+    constructor(fixture, expectedHash) {
+        const parsed = ReplayArtifactSchema.parse(fixture);
+        assertFixtureIntegrity(parsed, expectedHash);
+        this.records = parsed.records.extractor;
+    }
+    // `async` so a MISS surfaces as a REJECTED promise (the port contract is
+    // `Promise<string[]>`; a consumer awaits it). A synchronous `throw` would
+    // escape an `await`-less caller's `.catch`, so the rejection path is uniform.
+    async draft(content) {
+        const inputKey = extractorInputKey(content);
+        // `Object.prototype.hasOwnProperty`-style presence check, NOT truthiness: a
+        // recorded `[]` is a real HIT (falsy-but-present), distinct from an absent
+        // key (a MISS).
+        if (!Object.prototype.hasOwnProperty.call(this.records, inputKey)) {
+            throw new ReplayMissError('extractor', inputKey);
+        }
+        return this.records[inputKey];
+    }
+}
+/**
+ * PURE replay of `DraftClassifier` — zero live calls. Computes the inputKey
+ * (using the caller's `draftRef` resolver), looks it up:
+ *   - HIT  → return the recorded `ClassifierResult` (including a recorded
+ *            `{behavioral, error-default}` — a real row);
+ *   - MISS → throw `ReplayMissError` (NEVER fall back to the safe-default).
+ *
+ * Same external-expected-hash integrity gate at construction (fold B).
+ */
+export class ReplayDraftClassifier {
+    records;
+    draftRef;
+    constructor(fixture, expectedHash, draftRef) {
+        const parsed = ReplayArtifactSchema.parse(fixture);
+        assertFixtureIntegrity(parsed, expectedHash);
+        this.records = parsed.records.classifier;
+        this.draftRef = draftRef;
+    }
+    // `async` so a MISS surfaces as a REJECTED promise (uniform with the port
+    // contract `Promise<ClassifierResult>`), as in `ReplayDraftExtractor.draft`.
+    async classify(draft) {
+        const inputKey = classifierInputKey(draft, this.draftRef(draft));
+        if (!Object.prototype.hasOwnProperty.call(this.records, inputKey)) {
+            throw new ReplayMissError('classifier', inputKey);
+        }
+        return this.records[inputKey];
+    }
+}
+//# sourceMappingURL=spine-llm-replay.js.map

package/dist/commands/spine-llm-replay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spine-llm-replay.js","sourceRoot":"","sources":["../../src/commands/spine-llm-replay.ts"],"names":[],"mappings":"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"}

package/dist/commands/spine-llm-replay.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spine-llm-replay.test.d.ts.map

package/dist/commands/spine-llm-replay.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spine-llm-replay.test.d.ts","sourceRoot":"","sources":["../../src/commands/spine-llm-replay.test.ts"],"names":[],"mappings":""}