@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/comms.test.mjs

@@ -1,41 +0,0 @@
-/**
- * comms.test.mjs — tests for the archetype communication-profile resolver.
- * Run: `node --test lib/comms.test.mjs`
- * @module comms.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { resolveCommsProfile, CHANNEL_STRATEGY, REGISTER_BY_ALTITUDE, listCommsFunctions } from "./comms.mjs";
-
-test("comms profile carries altitude register + function channel strategy + voice modes", async () => {
-  const p = await resolveCommsProfile({ function: "compliance-officer", altitude: "c-suite" });
-  assert.equal(p.register, REGISTER_BY_ALTITUDE["c-suite"]);
-  assert.deepEqual(p.channelStrategy, CHANNEL_STRATEGY["compliance-officer"]);
-  assert.ok(p.channelStrategy.includes("filings-portal"));
-  assert.ok(p.voiceModes.length >= 4);
-  assert.ok(["high", "medium", "relaxed"].includes(p.formality));
-  assert.equal(p.styleRef, "policies/communication-style.md");
-});
-
-test("function changes the channel strategy (technical → github; commercial → linkedin)", async () => {
-  const tech = await resolveCommsProfile({ function: "technical-leader", altitude: "vp" });
-  const comm = await resolveCommsProfile({ function: "commercial-leader", altitude: "vp" });
-  assert.ok(tech.channelStrategy.includes("github"));
-  assert.ok(comm.channelStrategy.includes("linkedin"));
-  assert.notDeepEqual(tech.channelStrategy, comm.channelStrategy);
-});
-
-test("altitude changes the register (founder direct vs c-suite board-ready)", async () => {
-  const founder = await resolveCommsProfile({ function: "executive-operator", altitude: "founder" });
-  const cSuite = await resolveCommsProfile({ function: "executive-operator", altitude: "c-suite" });
-  assert.match(founder.register, /direct/i);
-  assert.match(cSuite.register, /board-ready/i);
-  assert.ok(founder.channelStrategy.includes("whatsapp") || founder.channelStrategy.includes("voice"));
-});
-
-test("listCommsFunctions covers the seven functions (incl. finance-leader)", () => {
-  assert.equal(listCommsFunctions().length, 7);
-});

package/lib/context/budget.test.mjs

@@ -1,252 +0,0 @@
-/**
- * budget.test.mjs — the declared token budget (spec §5.4, SDK half).
- *
- * Three properties are under test throughout:
- *   1. the budget is DECLARED per tier, not discovered by a char clamp;
- *   2. sections are filled in PRIORITY order, so the trigger survives a budget
- *      that the backlog cannot, and RENDERED in cache order, which is a
- *      different order for a different reason; and
- *   3. every drop is VISIBLE in the rendered text. A silent drop is the bug —
- *      the reader cannot tell an absent turn from a turn that never happened.
- *
- * Run: node --test lib/context/budget.test.mjs
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  TIER_BUDGETS,
-  SECTION_ORDER,
-  FILL_PRIORITY,
-  RENDER_ORDER,
-  CHARS_PER_TOKEN,
-  budgetFor,
-  estimateTokens,
-  fitSections,
-} from "./budget.mjs";
-
-const turns = (n, text = "x".repeat(40)) => Array.from({ length: n }, (_, i) => `s${i}: ${text}`);
-
-// ---------------------------------------------------------------------------
-// the declared budget
-// ---------------------------------------------------------------------------
-
-test("each tier declares its own budget, and the table is frozen", () => {
-  assert.equal(TIER_BUDGETS.answer, 6000);
-  assert.equal(TIER_BUDGETS.work, 12000);
-  assert.equal(TIER_BUDGETS.plan, 20000);
-  assert.equal(Object.isFrozen(TIER_BUDGETS), true);
-});
-
-test("an unknown tier takes the WORK budget rather than an unbounded one", () => {
-  assert.equal(budgetFor("plan"), 20000);
-  assert.equal(budgetFor("nonsense"), TIER_BUDGETS.work);
-  assert.equal(budgetFor(undefined), TIER_BUDGETS.work);
-});
-
-test("estimateTokens is the declared chars-per-token ratio, rounded up", () => {
-  assert.equal(estimateTokens(""), 0);
-  assert.equal(estimateTokens("a".repeat(CHARS_PER_TOKEN)), 1);
-  assert.equal(estimateTokens("a".repeat(CHARS_PER_TOKEN + 1)), 2);
-  assert.equal(estimateTokens(null), 0);
-});
-
-// ---------------------------------------------------------------------------
-// fitting
-// ---------------------------------------------------------------------------
-
-test("everything that fits is kept, verbatim, with no drop notes", () => {
-  const out = fitSections({
-    tier: "plan",
-    sections: [
-      { name: "trigger", text: "fix the invoice total" },
-      { name: "thread", turns: turns(3) },
-    ],
-  });
-  assert.equal(out.drops.length, 0);
-  assert.match(out.text, /fix the invoice total/);
-  assert.doesNotMatch(out.text, /not shown/);
-  assert.ok(out.usedTokens <= out.budgetTokens);
-});
-
-test("an overflowing thread keeps the NEWEST turns and says how many it dropped", () => {
-  const out = fitSections({
-    tier: "answer",
-    budgetTokens: 60, // ~240 chars
-    sections: [
-      { name: "trigger", text: "which one?" },
-      { name: "thread", turns: turns(20, "y".repeat(60)) },
-    ],
-  });
-  const thread = out.sections.find((s) => s.name === "thread");
-  assert.ok(thread.keptTurns > 0, "at least one turn survives");
-  assert.ok(thread.droppedTurns > 0, "the rest were dropped");
-  assert.equal(thread.keptTurns + thread.droppedTurns, 20);
-  // The newest turn is the one nearest the message being answered.
-  assert.match(out.text, /s19:/);
-  assert.doesNotMatch(out.text, /s0:/);
-  assert.match(out.text, new RegExp(`… ${thread.droppedTurns} earlier turns not shown`));
-});
-
-test("the drop note is singular for exactly one dropped turn", () => {
-  // Two turns, and room for the newest one plus its drop note but not for both.
-  const out = fitSections({
-    tier: "answer",
-    budgetTokens: 60,
-    sections: [{ name: "thread", turns: [`s0: ${"a".repeat(200)}`, `s1: ${"b".repeat(200)}`] }],
-  });
-  const thread = out.sections.find((s) => s.name === "thread");
-  assert.equal(thread.keptTurns, 1);
-  assert.equal(thread.droppedTurns, 1);
-  assert.match(out.text, /… 1 earlier turn not shown/);
-  assert.doesNotMatch(out.text, /earlier turns not shown/);
-});
-
-test("sections fill in priority order — the trigger outranks the backlog", () => {
-  const out = fitSections({
-    tier: "answer",
-    budgetTokens: 12,
-    sections: [
-      { name: "backlog", turns: turns(6, "b".repeat(80)) },
-      { name: "trigger", text: "the one question that matters" },
-    ],
-  });
-  assert.match(out.text, /the one question that matters/);
-  const backlog = out.sections.find((s) => s.name === "backlog");
-  assert.equal(backlog.included, false);
-});
-
-test("a section dropped WHOLE is still visible — never silently absent", () => {
-  const out = fitSections({
-    tier: "answer",
-    budgetTokens: 20,
-    sections: [
-      { name: "trigger", text: "t".repeat(60) },
-      { name: "memory", turns: turns(4, "m".repeat(100)) },
-    ],
-  });
-  const memory = out.sections.find((s) => s.name === "memory");
-  assert.equal(memory.included, false);
-  assert.match(out.text, /… memory not shown/);
-  assert.equal(out.drops.some((d) => d.section === "memory"), true);
-});
-
-test("a long text section is clipped and says how many characters went", () => {
-  const body = "z".repeat(4000);
-  const out = fitSections({
-    tier: "answer",
-    budgetTokens: 100,
-    sections: [{ name: "entity", title: "Document", text: body }],
-  });
-  const entity = out.sections.find((s) => s.name === "entity");
-  assert.ok(entity.droppedChars > 0);
-  assert.match(out.text, /characters not shown/);
-  assert.ok(out.usedTokens <= out.budgetTokens);
-});
-
-test("the trigger is never dropped whole — it is the thing being answered", () => {
-  const out = fitSections({
-    tier: "answer",
-    budgetTokens: 5,
-    sections: [{ name: "trigger", text: "q".repeat(2000) }],
-  });
-  const trigger = out.sections.find((s) => s.name === "trigger");
-  assert.equal(trigger.included, true);
-  assert.ok(trigger.text.length > 0);
-});
-
-test("rendered order is CACHE order — stable first, the trigger last", () => {
-  // Fill priority and render order are two different questions. The trigger
-  // WINS the budget (it is the thing being answered) and RENDERS last (it is
-  // the only section that changes on every inbound). A block that opened with
-  // the trigger would have a zero-length stable prefix, so WP-4's cache_control
-  // breakpoint would sit after volatile content and every cache read would miss
-  // silently — design §4, "any byte change before a breakpoint invalidates
-  // everything after it".
-  const out = fitSections({
-    tier: "plan",
-    sections: [
-      { name: "memory", turns: ["m: one"] },
-      { name: "trigger", text: "the ask" },
-      { name: "thread", turns: ["t: two"] },
-      { name: "entity", text: "the card" },
-    ],
-  });
-  assert.deepEqual(out.sections.map((s) => s.name), ["entity", "memory", "thread", "trigger"]);
-  assert.ok(out.text.indexOf("the card") < out.text.indexOf("m: one"));
-  assert.ok(out.text.indexOf("m: one") < out.text.indexOf("t: two"));
-  assert.ok(out.text.indexOf("t: two") < out.text.indexOf("the ask"));
-  assert.ok(out.text.endsWith("the ask"), "the volatile section is the tail, so everything before it can be cached");
-});
-
-test("FILL priority still decides who is dropped — the trigger wins the budget", () => {
-  // Same four sections, a budget only one of them fits. Render order must not
-  // become a fill order by accident: `entity` renders first but `trigger` is
-  // what survives.
-  const out = fitSections({
-    budgetTokens: 8,
-    sections: [
-      { name: "entity", text: "E".repeat(400) },
-      { name: "backlog", text: "B".repeat(400) },
-      { name: "trigger", text: "the ask itself" },
-    ],
-  });
-  const byName = Object.fromEntries(out.sections.map((s) => [s.name, s]));
-  assert.equal(byName.trigger.included, true, "the trigger is filled first, whatever it renders after");
-  assert.equal(byName.trigger.droppedChars, 0, "…and it is filled WHOLE");
-  assert.match(out.text, /the ask itself/);
-  assert.equal(byName.backlog.included, false, "the last section in fill priority is the first to go");
-  assert.ok(byName.entity.droppedChars > 0, "and the higher-priority one is only trimmed");
-  assert.equal(out.text.endsWith("the ask itself"), true, "render order is unchanged by who was dropped");
-});
-
-test("FILL_PRIORITY and RENDER_ORDER name the same sections, and are not the same array", () => {
-  assert.deepEqual([...FILL_PRIORITY].sort(), [...RENDER_ORDER].sort(),
-    "a section that can be filled must be renderable, and vice versa");
-  assert.notDeepEqual([...FILL_PRIORITY], [...RENDER_ORDER]);
-  assert.equal(FILL_PRIORITY[0], "trigger", "the trigger wins the budget");
-  assert.equal(RENDER_ORDER[RENDER_ORDER.length - 1], "trigger", "…and renders last, so the prefix is cacheable");
-});
-
-test("an unknown section name sorts after every declared one, keeping its order", () => {
-  const out = fitSections({
-    tier: "plan",
-    sections: [
-      { name: "weather", text: "w" },
-      { name: "trigger", text: "t" },
-      { name: "tides", text: "d" },
-    ],
-  });
-  assert.deepEqual(out.sections.map((s) => s.name), ["trigger", "weather", "tides"]);
-  assert.equal(SECTION_ORDER.includes("trigger"), true);
-  assert.equal(SECTION_ORDER.includes("weather"), false);
-});
-
-// ---------------------------------------------------------------------------
-// purity
-// ---------------------------------------------------------------------------
-
-test("pure: same input, same output, and the caller's arrays are untouched", () => {
-  const input = { tier: "work", sections: [{ name: "thread", turns: turns(50) }] };
-  const before = JSON.stringify(input);
-  const a = fitSections(input);
-  const b = fitSections(input);
-  assert.deepEqual(a, b);
-  assert.equal(JSON.stringify(input), before, "fitSections mutated its argument");
-});
-
-test("no sections is an empty block, not a throw", () => {
-  const out = fitSections({ tier: "answer", sections: [] });
-  assert.equal(out.text, "");
-  assert.equal(out.usedTokens, 0);
-  assert.deepEqual(out.drops, []);
-});
-
-test("a malformed section is ignored rather than taking the prompt down", () => {
-  const out = fitSections({ tier: "answer", sections: [null, { text: "no name" }, { name: "trigger", text: "ok" }] });
-  assert.equal(out.sections.length, 1);
-  assert.match(out.text, /ok/);
-});

package/lib/context/history-scope.test.mjs

@@ -1,79 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  isPrivateConversation,
-  historyDirNames,
-  interactionWriteDirNames,
-} from "./history-scope.mjs";
-
-test("is_dm is the authoritative signal, in both directions", () => {
-  assert.equal(isPrivateConversation({ is_dm: true }), true);
-  assert.equal(isPrivateConversation({ is_dm: false, channel_type: "im" }), false,
-    "an explicit is_dm:false is an assertion of 'room' and outranks a stale channel_type");
-});
-
-test("Slack's channel_type and the D-prefixed channel id both read as private", () => {
-  assert.equal(isPrivateConversation({ service: "slack", channel_type: "im" }), true);
-  assert.equal(isPrivateConversation({ service: "slack", channel_type: "mpim" }), true);
-  assert.equal(isPrivateConversation({ service: "slack", channel_id: "D099N1JGKRQ" }), true);
-  assert.equal(isPrivateConversation({ service: "slack", channel_id: "C099N1JGKRQ" }), false);
-  assert.equal(isPrivateConversation({ service: "slack", channel_type: "channel", channel_id: "D1" }), false);
-});
-
-test("a missing service reads as Slack — the historical default both readers use", () => {
-  assert.equal(isPrivateConversation({ channel_id: "D001TESTCH" }), true);
-  assert.equal(isPrivateConversation({ channel_id: "C001TESTCH" }), false);
-  assert.deepEqual(
-    historyDirNames({ channelId: "D001TESTCH", senderSlug: "alice-smith", isPrivate: true }),
-    ["D001TESTCH", "dm-alice-smith", "alice-smith"],
-    "…including its legacy bare-slug directory",
-  );
-});
-
-test("a dm/<name> label counts, and everything unknown is a ROOM", () => {
-  assert.equal(isPrivateConversation({ service: "telegram", channel: "dm/dana" }), true);
-  assert.equal(isPrivateConversation({ service: "cohort", channel_id: "c_capital_formation" }), false,
-    "unknown is not private — guessing wrong here puts a private sentence in a public room");
-  assert.equal(isPrivateConversation(null), false);
-  assert.equal(isPrivateConversation("nope"), false);
-});
-
-test("a shared room reads ONLY the room's own log — never a per-person directory", () => {
-  const dirs = historyDirNames({
-    channelId: "c_capital_formation", senderSlug: "dana", isPrivate: false, service: "cohort",
-  });
-  assert.deepEqual(dirs, ["c_capital_formation"]);
-  assert.equal(dirs.some((d) => d.includes("dana")), false);
-});
-
-test("a DM reads the room and the person; Slack also keeps its legacy bare slug", () => {
-  assert.deepEqual(
-    historyDirNames({ channelId: "c_dm", senderSlug: "dana", isPrivate: true, service: "cohort" }),
-    ["c_dm", "dm-dana"],
-  );
-  assert.deepEqual(
-    historyDirNames({ channelId: "D1", senderSlug: "dana", isPrivate: true, service: "slack" }),
-    ["D1", "dm-dana", "dana"],
-  );
-});
-
-test("the WRITER is gated by the same rule, so per-person logs stay per-person", () => {
-  assert.deepEqual(
-    interactionWriteDirNames({ channelId: "c_public", senderSlug: "dana", isPrivate: false }),
-    ["c_public"],
-  );
-  assert.deepEqual(
-    interactionWriteDirNames({ channelId: "c_dm", senderSlug: "dana", isPrivate: true }),
-    ["c_dm", "dm-dana"],
-  );
-  assert.deepEqual(
-    interactionWriteDirNames({ channelId: null, senderSlug: "dana", isPrivate: true }),
-    ["dm-dana"],
-  );
-  assert.deepEqual(
-    interactionWriteDirNames({ channelId: null, senderSlug: "dana", isPrivate: false }),
-    [],
-    "a room exchange with no room id is not filed under the person as a consolation prize",
-  );
-});

package/lib/cost/ledger-row.test.mjs

@@ -1,183 +0,0 @@
-/**
- * lib/cost/ledger-row.test.mjs — the measured / unmeasured / non-LLM contract.
- *
- * The bug these lock down: an absent token count and a genuine zero used to
- * produce identical rows, and every reader summed both as $0. That is what made
- * the budget governor unable to trip.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  classifyRow,
-  billableUsd,
-  summariseRows,
-  imputeUnmeasured,
-  MEASURED,
-  UNKNOWN,
-  NON_LLM,
-  INVALID,
-} from "./ledger-row.mjs";
-
-// A real dispatcher row copied from the live ledger (2026-08-12). Note the
-// shape that broke the old estimator: 16 uncached input tokens against 553k
-// cache reads, and an authoritative cost 7x the token-table estimate.
-const REAL_ROW = {
-  ts: "2026-08-12T00:09:36.073Z", cadence: "inbox", source: "dispatcher",
-  model: "sonnet", duration_ms: 64728, input_tokens: 16, output_tokens: 5000,
-  exit_code: 0, cache_read_input_tokens: 553181,
-  estimated_usd: 0.075048, total_cost_usd: 0.533412,
-};
-
-test("classifyRow: explicit measurement wins", () => {
-  assert.equal(classifyRow({ measurement: "measured", input_tokens: 1 }), MEASURED);
-  assert.equal(classifyRow({ measurement: "unknown", input_tokens: null }), UNKNOWN);
-  assert.equal(classifyRow({ measurement: "n/a" }), NON_LLM);
-  assert.equal(classifyRow(null), INVALID);
-  assert.equal(classifyRow("nope"), INVALID);
-});
-
-test("classifyRow: legacy rows are inferred without a migration", () => {
-  // Real dispatcher row, no `measurement` field.
-  assert.equal(classifyRow(REAL_ROW), MEASURED);
-  // Real messaging attribution row: no model, zero tokens => not a session.
-  assert.equal(
-    classifyRow({ source: "messaging", model: null, input_tokens: 0, output_tokens: 0, estimated_usd: 0 }),
-    NON_LLM
-  );
-  // Null tokens on both sides => unmeasured.
-  assert.equal(classifyRow({ model: "sonnet", input_tokens: null, output_tokens: null }), UNKNOWN);
-});
-
-test("classifyRow: a real session that used zero output tokens is still MEASURED", () => {
-  // The distinction that matters: a model ran and produced nothing is a
-  // measurement; it must not be confused with "we never looked".
-  assert.equal(classifyRow({ model: "sonnet", input_tokens: 120, output_tokens: 0 }), MEASURED);
-});
-
-test("billableUsd: authoritative CLI cost beats the local estimate", () => {
-  const { usd, basis } = billableUsd(REAL_ROW);
-  assert.equal(basis, "authoritative");
-  assert.equal(usd, 0.533412);
-  // The whole point: the old path would have billed the estimate.
-  assert.notEqual(usd, REAL_ROW.estimated_usd);
-});
-
-test("billableUsd: falls back to the estimate and says so", () => {
-  const { usd, basis } = billableUsd({ ...REAL_ROW, total_cost_usd: undefined });
-  assert.equal(basis, "estimated");
-  assert.equal(usd, 0.075048);
-});
-
-test("billableUsd: an unmeasured session costs NULL, not zero", () => {
-  const { usd, basis } = billableUsd({ measurement: "unknown", input_tokens: null, output_tokens: null });
-  assert.equal(usd, null);
-  assert.equal(basis, "unmeasured");
-});
-
-test("billableUsd: usage with no price is UNPRICED — a distinct bug from unmeasured, and still not free", () => {
-  const { usd, basis, cls } = billableUsd({ model: "sonnet", input_tokens: 5, output_tokens: 5 });
-  assert.equal(usd, null, "never 0 — a pricing outage must not read as a free session");
-  assert.equal(basis, "unpriced", "the telemetry worked; the PRICING did not");
-  assert.equal(cls, UNKNOWN);
-});
-
-test("billableUsd: a $0 price on a row that named a model is unpriceable, not free", () => {
-  // lib/model-router/ledger.mjs used to default `estimated_usd` to 0 whenever
-  // estimateCost returned null (a model missing from the catalog), and that 0
-  // billed as a measured free session. Both zeroes now fall through.
-  const zeroed = billableUsd({ model: "opus", input_tokens: 900, output_tokens: 40, total_cost_usd: 0, estimated_usd: 0 });
-  assert.equal(zeroed.usd, null);
-  assert.equal(zeroed.basis, "unpriced");
-});
-
-test("billableUsd: a zero-model attribution row is a real $0, not a gap", () => {
-  const { usd, basis } = billableUsd({ source: "messaging", model: null, input_tokens: 0, output_tokens: 0 });
-  assert.equal(usd, 0);
-  assert.equal(basis, "non_llm");
-});
-
-test("summariseRows: separates sessions from attribution rows", () => {
-  const s = summariseRows([
-    REAL_ROW,
-    { ...REAL_ROW, total_cost_usd: 1 },
-    { source: "messaging", model: null, input_tokens: 0, output_tokens: 0 },
-    { measurement: "unknown", input_tokens: null, output_tokens: null },
-  ]);
-  assert.equal(s.sessions, 3, "2 measured + 1 unmeasured; the send is not a session");
-  assert.equal(s.measured, 2);
-  assert.equal(s.unmeasured, 1);
-  assert.equal(s.nonLlmRows, 1);
-  assert.equal(s.measuredUsd, 1.533412);
-  assert.equal(s.blind, false);
-});
-
-test("summariseRows: blind only when sessions ran and NONE were measured", () => {
-  assert.equal(summariseRows([]).blind, false, "an empty ledger is quiet, not blind");
-  assert.equal(
-    summariseRows([{ source: "messaging", model: null, input_tokens: 0, output_tokens: 0 }]).blind,
-    false,
-    "attribution rows alone must not arm the alarm"
-  );
-  assert.equal(
-    summariseRows([{ measurement: "unknown", input_tokens: null, output_tokens: null }]).blind,
-    true
-  );
-});
-
-test("summariseRows: every degradation is reported, never swallowed", () => {
-  const s = summariseRows([
-    { measurement: "unknown", input_tokens: null, output_tokens: null },
-    { ...REAL_ROW, total_cost_usd: undefined },
-    "malformed",
-  ]);
-  assert.equal(s.degradations.length, 3);
-  assert.match(s.degradations.join(" | "), /recorded NO token counts/);
-  assert.match(s.degradations.join(" | "), /no authoritative total_cost_usd/);
-  assert.match(s.degradations.join(" | "), /malformed/);
-});
-
-test("imputeUnmeasured: unmeasured sessions cost the day's mean, not zero", () => {
-  const s = summariseRows([
-    { ...REAL_ROW, total_cost_usd: 2 },
-    { measurement: "unknown", input_tokens: null, output_tokens: null },
-    { measurement: "unknown", input_tokens: null, output_tokens: null },
-  ]);
-  const imp = imputeUnmeasured(s);
-  assert.equal(imp.basis, "day_mean");
-  assert.equal(imp.perSessionUsd, 2);
-  assert.equal(imp.imputedUsd, 4);
-});
-
-test("imputeUnmeasured: a blind day imputes from the PERIOD mean when the day has nothing", () => {
-  // The anti-starvation property, without a magic number. The old fallback was a
-  // hard-coded $0.25/session — ~8x below this fleet's observed $1.95 mean — so a
-  // total outage on a day that really cost $68.40 (274% of a $25 cap) imputed
-  // $8.75 and reported band 0. Under-imputing is the silent-governor bug.
-  const s = summariseRows([{ measurement: "unknown", input_tokens: null, output_tokens: null }]);
-  const imp = imputeUnmeasured(s, { fallbackPerSessionUsd: 1.95 });
-  assert.equal(imp.basis, "period_mean");
-  assert.equal(imp.perSessionUsd, 1.95);
-  assert.equal(imp.imputedUsd, 1.95);
-  assert.equal(imp.unpriceable, false);
-});
-
-test("imputeUnmeasured: with NO evidence at any horizon it refuses to invent a price", () => {
-  // And says so. The caller (lib/budget-guard.dailyStatus) floors the band at
-  // DEGRADE on `unpriceable`, which needs no price table: we cannot measure,
-  // therefore we degrade. Returning a made-up dollar figure here is what let a
-  // $68 day read as band 0.
-  const s = summariseRows([{ measurement: "unknown", input_tokens: null, output_tokens: null }]);
-  const imp = imputeUnmeasured(s);
-  assert.equal(imp.basis, "unpriceable");
-  assert.equal(imp.imputedUsd, 0);
-  assert.equal(imp.unpriceable, true);
-  assert.equal(s.blind, true, "the signal the band floor keys off");
-});
-
-test("imputeUnmeasured: nothing unmeasured means nothing imputed", () => {
-  const imp = imputeUnmeasured(summariseRows([REAL_ROW]));
-  assert.equal(imp.imputedUsd, 0);
-  assert.equal(imp.basis, "none");
-});