@dzhechkov/harness-core 0.3.146 → 0.3.148

package/.dz-manifest.json

@@ -9,7 +9,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "3ce64136feb92682d69ed9b8275ff1f894a4007826d8a2b115b260021bc0f42d"
+        "sha256": "4710903a3f0f81d2163062977f6471f29073d2c516209f875c09cc54e75ea099"
       },
       {
         "path": "coverage/coverage-final.json",
@@ -259,21 +259,37 @@
         "path": "dist/compounding.js.map",
         "sha256": "f353339d08c311fb69d44960e97bcc9ddfc01d7bdb8c3ae26e9884a494c0338f"
       },
+      {
+        "path": "dist/cost-ledger.d.ts",
+        "sha256": "872006c1a6dac23672b6879fa5b7506d2ce7e57f9682d518ffd986e9522e623f"
+      },
+      {
+        "path": "dist/cost-ledger.d.ts.map",
+        "sha256": "8df65b2795b029e0c8a1e3de73593d487ab4b730be134646215935d0a6c73709"
+      },
+      {
+        "path": "dist/cost-ledger.js",
+        "sha256": "da9c70db0807f05b19825a5344d3f73ff11e3759ad5be8b2db75c259be2e0580"
+      },
+      {
+        "path": "dist/cost-ledger.js.map",
+        "sha256": "48aa21f898920731f12e1454793f6d4bb9bcc4d0b1bef519bf1f7df87b7723f6"
+      },
       {
         "path": "dist/cost-scoring.d.ts",
-        "sha256": "e55d1d68facc208c4abc0258377cf0fab66ca43fe0db0a4c05e813d792d32bed"
+        "sha256": "be1b6a913c8ed391e12a3e0d703733fdbca0d7975d2f40a895f85921583220da"
       },
       {
         "path": "dist/cost-scoring.d.ts.map",
-        "sha256": "707ef5acce8a3fe4214ce4e67340ffe814d640ec02327838a23953716d27b18e"
+        "sha256": "04a3e07b206bf9f88750bdf061b7370558f6a6af95e109347cf18d92dbc22437"
       },
       {
         "path": "dist/cost-scoring.js",
-        "sha256": "6d2edea454f379708508559b145d75866c305727cf8a9ef7deb7405435f2c8de"
+        "sha256": "27a8789698060e69be20fe2beccf792603ad3b414aa95563e1cccddb7ab4a8cc"
       },
       {
         "path": "dist/cost-scoring.js.map",
-        "sha256": "3a9d8bbfcdbf481b8bb9f111865293aac8615386cae87e0ffb7f1310c2d77cf4"
+        "sha256": "fe5762b4ac2c5249116c5a18223cf41e87510feb498a8d0663a2bd6a2cadf074"
       },
       {
         "path": "dist/create-skill.d.ts",
@@ -387,6 +403,22 @@
         "path": "dist/event-chain.js.map",
         "sha256": "a874ba52b35ed445f2310a04bb0fbdb0ba34db18601d0086e7e666b7bafc8a16"
       },
+      {
+        "path": "dist/feature-adr-checkpoints.d.ts",
+        "sha256": "e93790da411c0385feb2153a6cd424b2305773a9709582eafe7f2adc8ab45c36"
+      },
+      {
+        "path": "dist/feature-adr-checkpoints.d.ts.map",
+        "sha256": "28f030188a9061ebab709bd2ce90d06ebff69f8baef39551df7dd25520b801a2"
+      },
+      {
+        "path": "dist/feature-adr-checkpoints.js",
+        "sha256": "88120bc4dc1a3fbab9b051434103936ea769978e66d7aada30589cf96602d46c"
+      },
+      {
+        "path": "dist/feature-adr-checkpoints.js.map",
+        "sha256": "361699e01e18cf80f46602673dc1ee8e13ec63bee1d37fe120e4275b052b265d"
+      },
       {
         "path": "dist/feature-adr-claim-gate.d.ts",
         "sha256": "abce2849ac6aa7b31292fb4d5e80b500b3a33a77533d3a3a8b3da6fe3ebaa7af"
@@ -485,19 +517,19 @@
       },
       {
         "path": "dist/index.d.ts",
-        "sha256": "c012cd5c1e1139755edd4a27daeef19e765d70f3764c0f074a0397b5f8252dac"
+        "sha256": "ecf62c0372ef24516aa12797719b0cedfbfea1cf0f92d573baea8e9d9dea45b8"
       },
       {
         "path": "dist/index.d.ts.map",
-        "sha256": "a0505d3d55931149733d95c1e294160395e221c567e92682acd4194c0c3d17fc"
+        "sha256": "ef7b4183ebdd16a162e00960b8070207901d6d3b4415c2ff78da0a762e713a78"
       },
       {
         "path": "dist/index.js",
-        "sha256": "07cf71990a2f7e7e126b02082ba82df93b99239e4ca4179c995cdfc00dcfb88c"
+        "sha256": "25595cd5c6d53c4376571a9bf52444778a749fc22f50c64d15c38b248c12ed1f"
       },
       {
         "path": "dist/index.js.map",
-        "sha256": "bc82e97c1ccded5006c1459bbcd3a84eb18651761d9b74d68d3aabe3be1101dc"
+        "sha256": "c07373c4a1ad8ec473dcd01852cbffc6b5641e78bbf629dd8b5060dda94eea5e"
       },
       {
         "path": "dist/learning-backend.d.ts",
@@ -1029,19 +1061,19 @@
       },
       {
         "path": "dist/usage.d.ts",
-        "sha256": "9dc875d545dbe3fb6fcd35fd0bbe85a0b44e605361c0f6ae8b883e91f3ea97e0"
+        "sha256": "a03311bd06b17ee842215a65755d08d0c1e07188af344c495f73d7c5196c163f"
       },
       {
         "path": "dist/usage.d.ts.map",
-        "sha256": "c4587f4494a98d98aebf81919a3626742302ef8a56fb698541c860496edd326f"
+        "sha256": "33eb02f603e5b668dbfa4af6ed5747d039e2562c5e018c149c21c3c4eed9549c"
       },
       {
         "path": "dist/usage.js",
-        "sha256": "f21b532a45cb8902ee73614c321ab843f69d0c7f9bfb1d027f78344c21b93d67"
+        "sha256": "065a9b2209111adcc448d53191ed37a08db09029cf89188446186bc284ff45bf"
       },
       {
         "path": "dist/usage.js.map",
-        "sha256": "49010990ed212f5660d3ef506416b128ead1ae83797117ec577b0f263c679961"
+        "sha256": "e1562daf935c8e1f0dd0f3372cd5ff9c999d137d80fd900d06cd62e8b511ebb1"
       },
       {
         "path": "dist/vector-tier.d.ts",
@@ -1077,7 +1109,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "de8265cfe636d0042855988d585b3e3165e4a61da0259c0a498fccdac79e1ec4"
+        "sha256": "1a64e1ded35c482214c3426808b24bcf7048041d716e375f101e228931c28248"
       },
       {
         "path": "src/__tests__/golden-baseline.test.ts",
@@ -1139,9 +1171,13 @@
         "path": "src/compounding.ts",
         "sha256": "1b20b2b6ababea386d195ab3481a0af6582fda2757720732b5098e162964da32"
       },
+      {
+        "path": "src/cost-ledger.ts",
+        "sha256": "0658e1caedea358d50e69c5b52ac704b29f614349b7527b2ddd0f82911428abd"
+      },
       {
         "path": "src/cost-scoring.ts",
-        "sha256": "9778add0fb249f4c9b650bde1c3747285568d3b8a462556059d4db7289625735"
+        "sha256": "8ca46e3e1396242f91fbd517b76ebbdf775d3540a033208ba0f0ca33d779d07a"
       },
       {
         "path": "src/create-skill.ts",
@@ -1171,6 +1207,10 @@
         "path": "src/event-chain.ts",
         "sha256": "f8306131a5021167169b525733da711ff378382f0a7368376f35834c350a9e23"
       },
+      {
+        "path": "src/feature-adr-checkpoints.ts",
+        "sha256": "17278275695f9bbec9f48628853659c9d8b5dfcdc6bb2b03e0c88648f95a446d"
+      },
       {
         "path": "src/feature-adr-claim-gate.ts",
         "sha256": "0fd1c44e7f6aea1abfac1e6d3fac3e4bbe4dfd501d068803f310c1ec36716eb6"
@@ -1197,7 +1237,7 @@
       },
       {
         "path": "src/index.ts",
-        "sha256": "570656aaa56d8da53c83f2e93af93e6b9af4398b3e75a7077bf5a7206eee42b5"
+        "sha256": "537dc4dc55cb43f11f2f0cee45ea53ec6fe362df470948408c49bb11fe972d9f"
       },
       {
         "path": "src/learning-backend.ts",
@@ -1329,7 +1369,7 @@
       },
       {
         "path": "src/usage.ts",
-        "sha256": "a74ad3ca87279e0cb808a40dd8f18f52efed5c6f37f45f8186ea573c4a610fdd"
+        "sha256": "317fc95287308a8d7ea92222d234bf62f8415ab97e40c8ceaf2f6a3f1ac5d80c"
       },
       {
         "path": "src/vector-tier.ts",
@@ -1407,6 +1447,10 @@
         "path": "test/compounding.test.ts",
         "sha256": "89265131de29a2841e73068e4be256e1cbe7bd8dbd0c8eacc79039626b41e6f0"
       },
+      {
+        "path": "test/cost-ledger.test.ts",
+        "sha256": "75a5d06f5221fed7f98997a544c880836ead6fe74cc03ebe8c1a0875fb48ad9c"
+      },
       {
         "path": "test/cost-scoring.test.ts",
         "sha256": "7cafddfb69103fc401d17781ade8654a0f7cec92f131bb383be715e6f273d8aa"
@@ -1463,6 +1507,10 @@
         "path": "test/feature-adr-brain.test.ts",
         "sha256": "f131290294c1da977c621842e65c0dc560643720c6b5d49fd6aead2d9270bf74"
       },
+      {
+        "path": "test/feature-adr-checkpoints.test.ts",
+        "sha256": "8564e1953e6da1f5a2b0990b1e5d8c78b24cc268a2c4eea15609d90b8fbda6f6"
+      },
       {
         "path": "test/feature-adr-claim-gate.test.ts",
         "sha256": "0b72b9bc26722022dee860dff0811426c7038a15631bcd084a2fb8295211b741"
@@ -1681,5 +1729,5 @@
       }
     ]
   },
-  "signature": "+Zq5ezfLk8TTPIVlSjlPsS0QO7+g7A33eYSduSLm8R6gZ2U6ap8INEvm2gL8Fbq2KB6IYOt/OL+YuG0TAH4ECg=="
+  "signature": "hxJqU0VjfVbOQps7TTMTwogoeBt7+hX81mj6AF3qiYzso74iAmy0yyf2CQzfZO++8Lk3uw1Cxw50kz92gZyACQ=="
 }

package/README.md

@@ -15,8 +15,10 @@ and any other consumer.
 | `backlog` | `dedupIdea`, `classifyDedup`, `alignIdea`, `spinRoulette`, `readGoalMapDetailed`, `parseEffort`, `ensureBacklogGitignored`, `harmonizeBacklog` | The Smart Backlog engine behind `dz backlog`: content-addressed idea records in `.dz/backlog/ideas.jsonl`, semantic dedup over the REUSED agentdb vector namespace (`dz-backlog` — no second store), weighted-max GoalMap alignment, and a seeded weighted roulette. Every band/weight decision is a PURE function. `classifyDedup` also reports the top-1 match id alongside the cosine (the calibration surface for the 0.92 duplicate band — observational, it never moves the verdict); `readGoalMapDetailed` returns the entries the defensive reader DROPPED with a reason AND the fields it REPAIRED with their raw values (a weight clamped before validation made the validator's out-of-range branch dead code), so `goals --validate` can never report a vacuous "valid (0 goals)" nor hide a `weight: 7`; `parseEffort` returns a printable note for every clamp; `ensureBacklogGitignored` gitignores the store on first write (raw ideas are private prompt-class content) — atomically, preserving the file's dominant EOL, recognising every plain spelling of an existing rule (`/.dz/`, `.dz/**`, …) via `backlogIgnoreStatus`, and obeying a `!` negation as an explicit user opt-out instead of overriding it |
 | `feature-adr-setup` (P3) | `renderGuardsConfig`, `renderGuardsRunner` | Scaffolds deterministic guard tests into a TARGET project: `guards.config.json` + a zero-dependency `check.mjs` runner (loc-cap, secret-scan, frozen-file sha256 pins, waivers-with-reasons) — `dz feature-adr-setup --guards` |
 | `usage` | `computeUsage`, `TOKEN_WEIGHTS`, `readUsageLimits`, `deriveUsageCalibration` | Read-only Claude usage ESTIMATE behind `dz usage`. Tokens are COST-WEIGHTED input-equivalents (input 1x, cache-write 1.25x / 1h 2x, cache-read 0.1x, output 5x) — a flat sum is 89-99.7% cache-read (MEASURED) and tracks conversation length, not work. Scans subagent transcripts too (`<session>/subagents/*.jsonl`), follows no symlinks, reads only regular files (symlinked FILES and DIRECTORY components alike are skipped), and caps the walk BY RECENCY so a huge history cannot discard current usage. `pct` stays `null` while limits are unconfigured — an unconfigured estimate is never dressed up as a number |
+| `cost-ledger` | `deriveCostLedger`, `buildCostLedger`, `verifyCostLedgerReport`, `stageCostAggregates`, `renderCostLedger`, `writeCostLedgerJsonl`, `COST_LEDGER_SCOPE` | Per-stage cost ledger behind `dz usage --by-stage`. A feature-adr run reports ONE number; this joins the workflow's own `stageLabel()` strings to the per-agent transcripts the harness already writes, so a run becomes an itemized receipt. POST-HOC DERIVER, not a writer — no workflow edit, and a KILLED run is still derivable. The invariant: `accounted + unaccounted === runTotal` and `accounted + doubleAttributed === Σ stages`, RAW integer equality (rounding happens exactly once, per sample, at extraction), re-derived from the emitted report by `verifyCostLedgerReport` — the writer clamps, the verifier enforces. A mismatch is a NAMED defect (`Unaccounted`, `DoubleAttributed`, `ForeignSample`, `MissingStageTranscript`, `MalformedRecord`), never a rounding remainder, so `epsilon` defaults to 0. The run total comes from the run's transcript DIRECTORY LISTING, NOT the record's own `totalTokens` — that field is exactly `Σ workflowProgress[].tokens` in 29 of 29 recorded runs (MEASURED), so an invariant against it can never fail. Both sides share ONE estimator with `dz usage` (`weightedTokensOf`). `stageCostAggregates` is a pure feed-forward reader for auto-cost routing that EXCLUDES non-reconciling runs; wiring it into routing is deliberately out of scope. HONEST SCOPE, printed by every surface: local transcript ESTIMATES, not billed amounts — it catches ATTRIBUTION errors, NOT pricing errors; `hasKnownPricing` marks rows priced by the sonnet-class fallback. `INSUFFICIENT_DATA` is a distinct verdict, never collapsed into `BALANCED` |
 | `compounding` | `mulberry32`, `bootstrapDelta`, `decidePromotion`, `assembleCompoundingReport` | Pure learning-loop payoff engine behind `dz compounding`: seeded deterministic bootstrap (conservative nearest-rank lower-95), promotion that refuses non-finite/malformed input and anything under 5 samples per arm, and dz-native measurements (pool write-only ratio, guard trajectory by RATE, replay readiness over unique untruncated prompt events). A gate without data says INSUFFICIENT_DATA — never a verdict. Compaction keeps the newest query-bearing rows verbatim and aggregates ONLY the rest (read totals are invariant across compactions). Also reports EVENT-CHAIN health of the evidence logs it computed from (`evidenceLogs` in, `instrumentation.chains` out) — verified / defect kinds / uncovered pre-chain prefix, with no logs handed in producing no line at all rather than a vacuous "clean" |
 | `event-chain` | `fnv1a32`, `nextChainFields`, `appendChainedLines`, `chainRewrite`, `guardedRewrite`, `verifyEventChain`, `EVENT_CHAIN_SCOPE` | Pure hash-chain over the two learning-evidence logs (`.dz/recall-usage.jsonl`, `.dz/guard-audit.jsonl`): each appended record carries `seq` + `prevHash` (FNV-1a over the previous line AS WRITTEN, so key order cannot make writer and verifier disagree), derived from the LAST LINE ONLY so a per-prompt hook stays O(1). `verifyEventChain` names eight classes — `BrokenLink`, `DuplicateSeq`, `NonMonotonicSeq`, `TornTail`, `DoubleCounted`, `LedgerImbalance`, `MalformedLedger`, `ClaimInterrupted`. The last four exist because a rewriter must not be able to certify itself: the compaction ledger's arithmetic (`Σ weight + dropped === source`, `dropped ∈ [0, source]`) is enforced with NO clamps in the verifier (the clamp belongs to the writer), a damaged ledger line is a defect rather than a silently-disabled check, and a claim that never reached its `throughSeq` — because the segment restarted or the file ended — is reported instead of escaping through the discontinuity. `guardedRewrite` is the concurrency guard for any whole-file rewrite: exclusive lock, plus a re-read of the live file after computing the new text and BEFORE the rename, so a concurrent append aborts the attempt and is folded into a bounded retry rather than overwritten (it narrows the read→rename window; it cannot close it, and says so). Records written before chaining existed stay LEGAL and are counted as an uncovered `preChainPrefix`; an unreadable tail never blocks a write (fresh MARKED segment — an unreadable tail WINDOW is distinguished from an empty file — and the appender starts on a new line so one torn write cannot eat the next record); an unmarked restart is reported once and then re-anchored, so one incident is one defect instead of a cascade. HONEST SCOPE, carried in every result and printed by every surface: corruption detection for our own bugs — FNV-1a is not cryptography, its collisions are constructible, the threat model has no adversary, and a regression test fails if the module regrows tamper-proofing vocabulary |
+| `feature-adr-checkpoints` | `checkpointInputHash`, `decideCheckpointResume`, `parseCheckpointRead`, `serializeCheckpoint`, `fnv1a64`, `CKPT_SCHEMA_VERSION`, `STAGE_ARTIFACTS` | The PURE half of feature-adr's durable per-stage checkpoints (`features/<slug>/.fa-state/checkpoints.jsonl`): a dead L/XL run — or the standard stop-after-plan re-invoke — resumes completed stages instead of re-spending them. Resume = INPUT-identity (64-bit salted FNV over a schema-versioned JSON tuple incl. upstream stage results) + presence of EVERY tier-required artifact; a stale-input hash never resumes in ANY mode (`force` relaxes only the artifact probe — the tested load-bearing property). HONEST SCOPE: it does NOT fingerprint the working tree (a crash-resume legitimately sees the dead run's uncommitted writes) — after manual edits use `resume:'never'` and re-QE. Null results are never persisted or resumable; a stage-identifiable corrupt record ERASES its older entry (last-wins holds for corruption too); a codex code stage whose landing barrier said `genuinely-not-landed` is never checkpointed. The workflow mirrors this inline (wiring-guarded); RU: чекпоинт после каждой дорогой стадии — упавший ран возобновляется, а не пере-тратит завершённое |
 | `operations` | `runInit`, `runSync`, `runVerify`, `runDoctor` | The harness operations, returning structured reports |
 | `release` | `collectPackageFacts`, `selectAffectedPackages`, `planReleaseGates`, `classifyGateExecutions`, `buildFailureIssue`, `firstOutputLine` | Pure verified-release engine behind `dz release`: plans 4 HARD gates (tests / `pnpm audit --prod` / `node --check` / bin smoke-boot) as DATA and classifies injected results fail-closed — an unbuilt package (declared `build` script, no dist JS) is a `MISSING_DIST` failure, a template-only pack is a named `SKIP_NO_ARTIFACTS` skip, `selectAffectedPackages` fail-opens to the full set when the changed-file list is unavailable |
 | `parity` | `TARGET_CAPABILITIES`, `PARITY_FEATURES`, `computeParity`, `buildParityMatrix` | Declarative target-parity model behind `dz parity`: verified capability flags per target × feature FORMS with requirements; the feature×target matrix is always COMPUTED (never hand-written), and the model must classify exactly `TARGET_NAMES` — an unclassified new target refuses to compile |

package/dist/cost-ledger.d.ts

@@ -0,0 +1,318 @@
+/**
+ * Per-stage cost ledger with a reconciliation invariant for feature-adr runs
+ * (feature `cost-ledger`, ADR-001/ADR-002/ADR-003).
+ *
+ * A feature-adr run reports ONE number. The recorded run `wf_0576bd7d-797` has
+ * `totalTokens: 623290` — the "623k subagent tokens" figure in project memory. That number cannot
+ * be attributed to a stage, so "where the budget burns" is a feeling. feature-adr ALREADY labels
+ * every stage via `stageLabel()` and the harness ALREADY persists those labels next to per-agent
+ * transcripts; nothing joined labels to spend. This module is that join.
+ *
+ * ## What this is
+ *
+ * A POST-HOC DERIVER (ADR-001). It reads what is already on disk —
+ * `<session>/workflows/wf_<runId>.json` for the stage labels and
+ * `<session>/subagents/workflows/<runId>/agent-<agentId>.jsonl` for the spend — and never edits
+ * `.claude/workflows/feature-adr.js`. A killed run is still derivable, which a stage-boundary
+ * writer could not manage; 5 of 29 recorded runs on this machine are killed.
+ *
+ * ## The invariant (ADR-002 — the load-bearing half)
+ *
+ * The obvious run total, the record's own `totalTokens`, is EXACTLY `Σ workflowProgress[].tokens`
+ * in 29 of 29 recorded runs. Reconciling against it can never fail: a vacuous gate that would print
+ * BALANCED forever and be believed. So the right-hand side comes from the run's transcript
+ * DIRECTORY LISTING — a source independent of the record — and both sides run the SAME estimator
+ * (`weightedTokensOf`, shared with `dz usage`):
+ *
+ * ```
+ *   accountedTokens + unaccountedTokens      === runTotalTokens
+ *   accountedTokens + doubleAttributedTokens === stageTokensSum
+ * ```
+ *
+ * Raw integer equality, no epsilon: rounding happens exactly once, per sample, at extraction.
+ * {@link verifyCostLedgerReport} re-derives both identities from the emitted report — the writer
+ * clamps, the verifier enforces raw equality (the `event-chain.ts` house pattern). A mismatch is a
+ * NAMED defect from {@link COST_LEDGER_DEFECT_KINDS}, never a rounding remainder.
+ *
+ * ## What this is NOT — read {@link COST_LEDGER_SCOPE} before describing it to anyone
+ *
+ * The totals are LOCAL TRANSCRIPT ESTIMATES. No billing API is consulted. The invariant therefore
+ * catches ATTRIBUTION errors — a double-counted stage, a stage missing from the ledger — and says
+ * NOTHING about whether the prices are right. The USD column is a secondary figure derived from a
+ * static table that has no `claude-fable` entry, so it falls back to sonnet-class pricing for the
+ * default model of every recorded run; the fallback is REPORTED, per ADR-003, not hidden.
+ *
+ * The ADR-158 reference implementation this feature is grounded in quotes a ~50.5% figure. That
+ * number is SYNTHETIC, belongs to their document, and is never a measurement of this repo.
+ *
+ * @packageDocumentation
+ */
+/** The one sentence that states what the ledger is and is not. Printed by EVERY surface (ADR-003). */
+export declare const COST_LEDGER_SCOPE: string;
+export type CostLedgerDefectKind = 
+/** Run spend attributed to no stage — an agent transcript with no `workflowProgress[]` entry. */
+'Unaccounted'
+/** One usage sample claimed by more than one stage. */
+ | 'DoubleAttributed'
+/** A stage claims a sample absent from the run's universe — the join went outside the run. */
+ | 'ForeignSample'
+/** A stage present in the run record has no transcript, or a transcript with no usage samples. */
+ | 'MissingStageTranscript'
+/** A record or sample whose fields are missing, mistyped or non-finite — never silently ignored. */
+ | 'MalformedRecord'
+/** The transcript listing hit the file cap — the run total is INCOMPLETE, so no verdict may be
+ *  built on it (Codex QE HIGH: a silent cap could emit BALANCED from a partial directory). */
+ | 'TruncatedListing';
+/**
+ * The defect vocabulary, as data. Deliberately absent: any name implying these are BILLED amounts —
+ * that name would assert exactly the promise {@link COST_LEDGER_SCOPE} refuses. A test pins this
+ * list so the vocabulary cannot quietly grow such a name.
+ */
+export declare const COST_LEDGER_DEFECT_KINDS: readonly CostLedgerDefectKind[];
+/**
+ * Three values, not two. `INSUFFICIENT_DATA` is NOT success: a caller must not read
+ * `verdict !== 'DEFECT'` as "reconciled" (ADR-003).
+ */
+export type CostLedgerVerdict = 'BALANCED' | 'DEFECT' | 'INSUFFICIENT_DATA';
+export declare const COST_LEDGER_VERDICTS: readonly CostLedgerVerdict[];
+/**
+ * Default reconciliation tolerance, as a FRACTION of the run total. Zero, because the arithmetic is
+ * exact integer — there is no rounding remainder for a tolerance to absorb, so any remainder is a
+ * defect. A caller may raise it to tolerate small orphans; its value is always printed.
+ */
+export declare const DEFAULT_COST_LEDGER_EPSILON = 0;
+/** One deduped usage sample extracted from a transcript. */
+export interface CostLedgerSample {
+    /** Dedup key: `message.id + ':' + requestId`, or a content key when both are absent. */
+    readonly key: string;
+    /** Epoch ms, or `null` when the record carried no parseable timestamp. */
+    readonly ts: number | null;
+    /** Cost-weighted input-equivalent tokens, ROUNDED — the single rounding point of the feature. */
+    readonly weighted: number;
+    readonly input: number;
+    readonly cacheWrite: number;
+    readonly cacheRead: number;
+    readonly output: number;
+    readonly model: string | null;
+}
+/** One `type: "workflow_agent"` entry of a run record, after clamping. */
+export interface WorkflowStageEntry {
+    /** `stageLabel()` output, VERBATIM — the ledger invents no taxonomy (FR-2). */
+    readonly label: string;
+    readonly agentId: string;
+    readonly model: string;
+    readonly phase: string | null;
+    readonly startedAtMs: number | null;
+    readonly durationMs: number | null;
+    readonly state: string | null;
+    /** The record's own per-agent token count. Reported for traceability; NOT the invariant's input. */
+    readonly recordTokens: number | null;
+}
+/** A parsed `wf_<runId>.json` workflow run record. */
+export interface WorkflowRunRecord {
+    readonly runId: string;
+    readonly workflowName: string | null;
+    readonly slug: string | null;
+    readonly status: string | null;
+    readonly startedAtMs: number | null;
+    readonly durationMs: number | null;
+    /** The record's cached `Σ workflowProgress[].tokens` — RAW, unweighted, and NOT the run total. */
+    readonly recordTotalTokens: number | null;
+    readonly stages: readonly WorkflowStageEntry[];
+    /** Non-fatal problems found while parsing — surfaced as `MalformedRecord` defects. */
+    readonly malformed: readonly string[];
+}
+/** One ledger row: a stage's aggregated spend (FR-1). */
+export interface CostLedgerRow {
+    readonly runId: string;
+    readonly slug: string | null;
+    /** `stageLabel()` output, verbatim. */
+    readonly stage: string;
+    readonly phase: string | null;
+    /** The stage's model id, or `'mixed'` when several agents share a label with different models. */
+    readonly model: string;
+    readonly agentIds: readonly string[];
+    readonly tokensIn: number;
+    readonly tokensCacheWrite: number;
+    readonly tokensCacheRead: number;
+    readonly tokensOut: number;
+    /** Cost-weighted input-equivalent tokens — the PRIMARY number of the row. */
+    readonly weightedTokens: number;
+    /** Secondary, derived estimate. `pricingKnown === false` ⇒ sonnet-class fallback pricing. */
+    readonly costUsd: number;
+    readonly pricingKnown: boolean;
+    /** ISO, from the run record's stage boundaries (ADR-001) — `null` when the record lacked them. */
+    readonly startedTs: string | null;
+    readonly endedTs: string | null;
+    /** Number of deduped usage samples (billed calls) attributed to this stage. */
+    readonly calls: number;
+}
+export interface CostLedgerDefect {
+    readonly kind: CostLedgerDefectKind;
+    readonly detail: string;
+    /** Weighted tokens implicated, when the defect is quantitative. */
+    readonly tokens?: number;
+    /** Stage labels or agent ids implicated, when the defect is locatable. */
+    readonly subjects?: readonly string[];
+}
+export interface CostLedgerReconciliation {
+    /** RIGHT side — dedup-union over the run's transcript DIRECTORY (independent of the record). */
+    readonly runTotalTokens: number;
+    /** Dedup-union of samples claimed by at least one stage. */
+    readonly accountedTokens: number;
+    /** Σ of the per-stage sums. Exceeds `accountedTokens` exactly when a sample is double-claimed. */
+    readonly stageTokensSum: number;
+    /** `runTotalTokens - accountedTokens`. */
+    readonly unaccountedTokens: number;
+    /** `stageTokensSum - accountedTokens`. */
+    readonly doubleAttributedTokens: number;
+    /** Tolerance as a FRACTION of the run total; `0` by default (ADR-002). */
+    readonly epsilon: number;
+    /** Both raw integer identities held when the report was built. */
+    readonly identityHolds: boolean;
+    readonly verdict: CostLedgerVerdict;
+    readonly defects: readonly CostLedgerDefect[];
+}
+export interface CostLedgerReport {
+    readonly runId: string;
+    readonly slug: string | null;
+    readonly workflowName: string | null;
+    readonly status: string | null;
+    readonly startedTs: string | null;
+    readonly rows: readonly CostLedgerRow[];
+    readonly reconciliation: CostLedgerReconciliation;
+    /** The record's cached raw sum — reported, never the invariant's right-hand side (ADR-002). */
+    readonly recordTotalTokens: number | null;
+    readonly totalCostUsd: number;
+    /** Model ids whose USD figures used sonnet-class fallback pricing (ADR-003). */
+    readonly pricingFallbackModels: readonly string[];
+    /** ALWAYS `true` — a local aggregation, not an official API (mirrors `dz usage`). */
+    readonly estimated: true;
+    /** ALWAYS {@link COST_LEDGER_SCOPE}. */
+    readonly scope: string;
+}
+/** FR-8 feed-forward aggregate. WIRING INTO auto-cost ROUTING IS OUT OF SCOPE — this is a reader. */
+export interface StageCostAggregate {
+    readonly stage: string;
+    readonly model: string;
+    readonly avgTokens: number;
+    readonly runs: number;
+    readonly totalTokens: number;
+    readonly avgCostUsd: number;
+}
+/**
+ * Extract deduped, weighted usage samples from ONE transcript's text. Pure and never-throw — a
+ * corrupt line is skipped, exactly as `computeUsage` does.
+ *
+ * `weighted` is `Math.round(weightedTokensOf(...))`: the SINGLE rounding point of the feature, so
+ * every sum downstream is exact integer arithmetic and the reconciliation identity is raw equality
+ * rather than a float comparison (ADR-002).
+ */
+export declare function extractCostSamples(text: string): CostLedgerSample[];
+/**
+ * Parse a `wf_<runId>.json` object into a {@link WorkflowRunRecord}. Pure and never-throw; every
+ * number is clamped and every unusable field is RECORDED in `malformed` rather than dropped, so it
+ * can surface as a `MalformedRecord` defect (the vocabulary refuses silent ignores).
+ *
+ * `args` is stored as a JSON STRING in the recorded runs on this machine and as an object in
+ * others; both shapes are accepted.
+ */
+export declare function parseWorkflowRunRecord(raw: unknown): WorkflowRunRecord | null;
+/** Per-stage sample sets, keyed by the `stageLabel()` string. */
+export interface StageSampleSet {
+    readonly stage: string;
+    readonly samples: readonly CostLedgerSample[];
+}
+export interface BuildCostLedgerInput {
+    readonly record: WorkflowRunRecord;
+    /** LEFT side — one entry per `agentId` that had a transcript. */
+    readonly stageSamples: readonly {
+        readonly agentId: string;
+        readonly samples: readonly CostLedgerSample[];
+    }[];
+    /** RIGHT side — the dedup-union over the run's transcript DIRECTORY (ADR-002). */
+    readonly runSamples: readonly CostLedgerSample[];
+    /** Agent transcripts present in the run directory with no `workflowProgress[]` entry. */
+    readonly orphanAgentIds?: readonly string[];
+    /** Fraction of the run total tolerated as unaccounted. Default {@link DEFAULT_COST_LEDGER_EPSILON}. */
+    readonly epsilon?: number;
+    /** True when the transcript listing hit the file cap — the run total is incomplete (Codex QE HIGH). */
+    readonly transcriptListingTruncated?: boolean;
+}
+/**
+ * Build the report and evaluate the invariant. PURE — no filesystem, no clock. Every number that
+ * enters is clamped here (the writer clamps; {@link verifyCostLedgerReport} enforces raw equality).
+ */
+export declare function buildCostLedger(input: BuildCostLedgerInput): CostLedgerReport;
+/**
+ * Re-derive both identities from an EMITTED report — the verifier half of the house pattern. It
+ * trusts nothing the builder computed except the numbers it printed, so a future writer bug shows
+ * up as a `MalformedRecord` finding instead of a plausible table.
+ */
+export declare function verifyCostLedgerReport(report: CostLedgerReport): readonly CostLedgerDefect[];
+/**
+ * Aggregate per-stage cost across runs, for a future auto-cost router that today chooses models
+ * from a STATIC assumptions table.
+ *
+ * **WIRING INTO ROUTING IS OUT OF SCOPE for this feature** — this returns data and nothing consumes
+ * it yet. That is deliberate: an ESTIMATED number must not drive an expensive routing decision
+ * until it has been calibrated. Rows from runs whose verdict is not `BALANCED` are EXCLUDED, so a
+ * run with a known attribution defect can never quietly become a routing input.
+ */
+export declare function stageCostAggregates(reports: readonly CostLedgerReport[]): StageCostAggregate[];
+/** Human table + reconciliation line + verdict + the honest-scope note (ADR-003). */
+export declare function renderCostLedger(report: CostLedgerReport): string;
+/**
+ * FR-7 serialization: one JSON object per line. The first line is a `kind: "cost-ledger-scope"`
+ * header carrying {@link COST_LEDGER_SCOPE}, so the honest scope travels with the file; the last is
+ * the reconciliation. This is a REGENERABLE REPORT, never a read-back source of truth (ADR-001).
+ */
+export declare function costLedgerJsonl(report: CostLedgerReport): string;
+export interface CostLedgerIoOptions {
+    /** Override the `~/.claude/projects` root. Defaults to {@link claudeProjectsRoot}. */
+    readonly projectsRoot?: string;
+    /** Munged project directory name (e.g. `-home-user-repo`). Absent ⇒ scan every project. */
+    readonly projectDir?: string;
+    readonly epsilon?: number;
+}
+export interface CostLedgerRunRef {
+    readonly runId: string;
+    readonly slug: string | null;
+    readonly workflowName: string | null;
+    readonly status: string | null;
+    readonly startedAtMs: number | null;
+    /** Absolute path of the `wf_*.json` record. */
+    readonly recordPath: string;
+    /** Absolute path of `<session>/subagents/workflows/<runId>` — may not exist. */
+    readonly transcriptDir: string;
+}
+/**
+ * Enumerate workflow run records, newest first. NEVER throws — an unreadable tree yields `[]`.
+ * READONLY. `lstat` everywhere, so a symlinked session or run directory is never walked.
+ */
+export declare function listCostLedgerRuns(opts?: CostLedgerIoOptions): CostLedgerRunRef[];
+export interface DeriveCostLedgerOptions extends CostLedgerIoOptions {
+    /** Exact run id. Must match `[A-Za-z0-9_.-]{1,128}` — it becomes a path segment. */
+    readonly runId?: string;
+    /** Most recent run with this `args.slug`. Same pattern restriction. */
+    readonly slug?: string;
+}
+/**
+ * Derive the ledger for ONE run. Returns `null` when no run matches — an ABSENT run is never a
+ * BALANCED empty report (ADR-003). NEVER throws; READONLY.
+ */
+export declare function deriveCostLedger(opts?: DeriveCostLedgerOptions): CostLedgerReport | null;
+/**
+ * FR-8 IO wrapper: derive every run and aggregate. Runs that do not reconcile are excluded by
+ * {@link stageCostAggregates}. NEVER throws; READONLY. Still NOT wired into routing.
+ */
+export declare function deriveStageCostAggregates(opts?: CostLedgerIoOptions & {
+    readonly maxRuns?: number;
+}): StageCostAggregate[];
+/**
+ * FR-7 opt-in materialization. Atomic: writes a sibling `.tmp` then `renameSync`s over the target,
+ * and removes the temp file if the rename fails, so a crash can never leave a half-written ledger.
+ * Returns `true` on success; never throws.
+ */
+export declare function writeCostLedgerJsonl(path: string, report: CostLedgerReport): boolean;
+//# sourceMappingURL=cost-ledger.d.ts.map

package/dist/cost-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost-ledger.d.ts","sourceRoot":"","sources":["../src/cost-ledger.ts"],"names":[],"mappings":"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"}