@fgv/ts-extras 5.1.0-55 → 5.1.0-57

package/lib/packlets/ai-assist/promptCacheAnthropicBreakpointHarness.js

@@ -0,0 +1,208 @@
+"use strict";
+// Copyright (c) 2026 Erik Fortune
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAnthropicBreakpointPrefix = buildAnthropicBreakpointPrefix;
+exports.withAnthropicZeroDefaults = withAnthropicZeroDefaults;
+exports.runPromptCacheAnthropicBreakpointArm = runPromptCacheAnthropicBreakpointArm;
+exports.runPromptCacheAnthropicBreakpointHarness = runPromptCacheAnthropicBreakpointHarness;
+exports.describeAnthropicBreakpointUsage = describeAnthropicBreakpointUsage;
+exports.formatAnthropicBreakpointVerdict = formatAnthropicBreakpointVerdict;
+/**
+ * Pure logic and injectable transport for `perf/promptCacheAnthropicBreakpoint.js` — the first
+ * measurement of whether C3's Anthropic `cache_control` emission (`IAiCacheRequest.systemBreakpoints`)
+ * actually produces a cache hit against a live provider.
+ *
+ * @remarks
+ * Every prompt-cache measurement shipped by this stream so far (`promptCacheObservability.js`,
+ * `promptCacheRoutingAb.js`) ran against xAI, whose caching is automatic — no request-side
+ * directive is sent, so neither harness exercises C3's emit path at all. Anthropic's cache is the
+ * sharp case: it is opt-in **per content block** via `cache_control`, with no automatic path, so a
+ * breakpoint is the only thing that can produce a hit. This harness is an A/B rather than a single
+ * standing assertion (unlike `promptCacheObservabilityHarness.ts`) precisely because Anthropic has
+ * no automatic caching to fall back on: without a negative control that reliably shows no hit, a
+ * hit in the positive arm could not be attributed to `systemBreakpoints` at all.
+ *
+ * Reuses {@link compareCacheHitRatios} / {@link computeCacheUsageRatio} /
+ * {@link formatCacheRatioPercent} from `promptCacheUsageMath.ts` rather than re-deriving the
+ * ratio/verdict arithmetic — see {@link withAnthropicZeroDefaults} for the one Anthropic-specific
+ * wrinkle those shared functions need help with. Also reuses
+ * {@link describeObservabilityUsage} from `promptCacheObservabilityHarness.ts` to print reads and
+ * writes separately, rather than writing a third formatter for the same shape.
+ * @packageDocumentation
+ */
+const ts_utils_1 = require("@fgv/ts-utils");
+const promptCacheObservabilityHarness_1 = require("./promptCacheObservabilityHarness");
+const promptCacheUsageMath_1 = require("./promptCacheUsageMath");
+/**
+ * Builds one arm's stable system prefix. Same shape as `buildObservabilityStablePrefix` /
+ * `buildRoutingAbPrefix` (~8,700 tokens measured for this exact 400-line generator against a
+ * comparable provider in this stream's earlier runs) — comfortably above every
+ * `minCacheablePrefixTokens` entry design.md §7 lists for Anthropic, including Haiku-class models'
+ * 4,096-token floor, not just the 1,024-token floor this harness's target model (`claude-sonnet-5`,
+ * the `'base'` tier this stream's other harnesses also default to) actually needs. `salt` and `arm`
+ * both feed the text so the two arms — and two separate runs — never warm each other's cache.
+ * @internal
+ */
+function buildAnthropicBreakpointPrefix(salt, arm) {
+    const lines = [];
+    for (let i = 0; i < 400; i++) {
+        lines.push(`Directive ${salt}-${arm}-${i}: when asked about topic ${i}, respond precisely and cite source ${i}-${i * 7}.`);
+    }
+    return `You are a careful assistant operating under the following fixed policy document.\n\n${lines.join('\n')}`;
+}
+/**
+ * Fills Anthropic's cache-usage fields with their design-mandated zero default when the wire
+ * response omits them, before feeding a usage block to {@link compareCacheHitRatios}.
+ *
+ * @remarks
+ * `normalizeAnthropicUsage` always reports `reports: 'reads-and-writes'` for this provider, and
+ * design.md §8 states the semantics that follow from it explicitly: *"Under `'reads-and-writes'`,
+ * an absent `cacheWriteTokens` genuinely means zero were written."* The same reasoning covers
+ * `cachedInputTokens` and `uncachedInputTokens`. So for an Anthropic usage block specifically, an
+ * absent field is a **known** zero, not an unknown value — applying the default here does not
+ * violate design.md's R-c ("unknown is reported as unknown, never defaulted to a number"); it is
+ * what R-c's own `reports` discriminator exists to allow. This is deliberately narrower than
+ * {@link computeCacheUsageRatio}, which stays provider-agnostic (a `'reads'`-only provider's
+ * absent field genuinely is ambiguous, per design.md §8's own OQ-1 discussion) — the default is
+ * applied here, once, rather than widening the shared function's semantics for every caller.
+ *
+ * Display (`describeObservabilityUsage`) is untouched by this and keeps printing the raw wire
+ * value, so a reader can still see whether a field was actually reported or defaulted.
+ * @internal
+ */
+function withAnthropicZeroDefaults(usage) {
+    var _a, _b, _c;
+    if (usage === undefined || usage.reports !== 'reads-and-writes') {
+        return usage;
+    }
+    return Object.assign(Object.assign({}, usage), { cachedInputTokens: (_a = usage.cachedInputTokens) !== null && _a !== void 0 ? _a : 0, uncachedInputTokens: (_b = usage.uncachedInputTokens) !== null && _b !== void 0 ? _b : 0, cacheWriteTokens: (_c = usage.cacheWriteTokens) !== null && _c !== void 0 ? _c : 0 });
+}
+/**
+ * Runs one arm: a cold call, then a warm call sharing the same
+ * {@link buildAnthropicBreakpointPrefix} system prompt and differing only in the final user turn —
+ * optionally supplying `cache.systemBreakpoints`. A single breakpoint is placed one character short
+ * of the end of `system`, marking essentially the whole fixed prefix as cacheable (design.md §6.1:
+ * offsets must be strictly `< system.length`).
+ * @internal
+ */
+async function runPromptCacheAnthropicBreakpointArm(deps, params) {
+    const { descriptor, apiKey, label, salt, arm, withBreakpoint } = params;
+    const system = buildAnthropicBreakpointPrefix(salt, arm);
+    const cache = withBreakpoint
+        ? { systemBreakpoints: [system.length - 1] }
+        : undefined;
+    const call = (content) => deps.callCompletion({
+        descriptor,
+        apiKey,
+        system,
+        messages: [{ role: 'user', content }],
+        cache
+    });
+    const cold = await call('In one sentence, what is directive 12 about?');
+    if (cold.isFailure()) {
+        return (0, ts_utils_1.fail)(`${label}: cold call failed: ${cold.message}`);
+    }
+    // Only the tail differs from the cold call — the system prefix is byte-identical.
+    const warm = await call('In one sentence, what is directive 99 about?');
+    if (warm.isFailure()) {
+        return (0, ts_utils_1.fail)(`${label}: warm call failed: ${warm.message}`);
+    }
+    return (0, ts_utils_1.succeed)({ label, coldUsage: cold.value.usage, warmUsage: warm.value.usage });
+}
+/**
+ * Runs both arms of the Anthropic breakpoint A/B and classifies the result.
+ *
+ * @remarks
+ * Both warm usages are passed through {@link withAnthropicZeroDefaults} before comparison, so the
+ * negative control (`withoutBreakpoint`) is correctly read as "no cache activity" even if
+ * Anthropic's wire response omits the cache fields entirely on a request that sends no
+ * `cache_control` — the expected shape for that arm — rather than being scored `'inconclusive'`
+ * by {@link compareCacheHitRatios}'s provider-agnostic "absent field = unknown" default.
+ * @internal
+ */
+async function runPromptCacheAnthropicBreakpointHarness(deps, params) {
+    const { descriptor, apiKey, salt } = params;
+    const withoutBreakpointResult = await runPromptCacheAnthropicBreakpointArm(deps, {
+        descriptor,
+        apiKey,
+        label: 'arm 1: WITHOUT systemBreakpoints (negative control)',
+        salt,
+        arm: 'a',
+        withBreakpoint: false
+    });
+    if (withoutBreakpointResult.isFailure()) {
+        return (0, ts_utils_1.fail)(withoutBreakpointResult.message);
+    }
+    const withBreakpointResult = await runPromptCacheAnthropicBreakpointArm(deps, {
+        descriptor,
+        apiKey,
+        label: 'arm 2: WITH systemBreakpoints (C3 emission under test)',
+        salt,
+        arm: 'b',
+        withBreakpoint: true
+    });
+    if (withBreakpointResult.isFailure()) {
+        return (0, ts_utils_1.fail)(withBreakpointResult.message);
+    }
+    const comparison = (0, promptCacheUsageMath_1.compareCacheHitRatios)(withAnthropicZeroDefaults(withoutBreakpointResult.value.warmUsage), withAnthropicZeroDefaults(withBreakpointResult.value.warmUsage));
+    return (0, ts_utils_1.succeed)({
+        withoutBreakpoint: withoutBreakpointResult.value,
+        withBreakpoint: withBreakpointResult.value,
+        verdict: comparison.verdict,
+        withoutBreakpointWarmRatio: comparison.baselineRatio,
+        withBreakpointWarmRatio: comparison.candidateRatio
+    });
+}
+/**
+ * One line per call, reusing `describeObservabilityUsage` so reads and writes are printed
+ * separately (`uncached=… cached=… written=…`) rather than collapsed into a single ratio, per
+ * this measurement's requirement to report Anthropic's `reads-and-writes` fields individually.
+ * @internal
+ */
+function describeAnthropicBreakpointUsage(label, usage) {
+    return (0, promptCacheObservabilityHarness_1.describeObservabilityUsage)(label, usage);
+}
+/**
+ * Formats the A/B's closing verdict line(s).
+ * @internal
+ */
+function formatAnthropicBreakpointVerdict(result) {
+    const a = (0, promptCacheUsageMath_1.formatCacheRatioPercent)(result.withoutBreakpointWarmRatio);
+    const b = (0, promptCacheUsageMath_1.formatCacheRatioPercent)(result.withBreakpointWarmRatio);
+    switch (result.verdict) {
+        case 'confirms':
+            return (`arm 1 (no breakpoints) warm ${a} -> arm 2 (systemBreakpoints) warm ${b}\n` +
+                'CONFIRMS the prediction: Anthropic cache_control breakpoints produce a cache hit that an ' +
+                'otherwise-identical request with no cache directive does not.');
+        case 'misses':
+            return (`arm 1 (no breakpoints) warm ${a} -> arm 2 (systemBreakpoints) warm ${b}\n` +
+                "MISSES the prediction: arm 2 did not clear the floor. Either C3's Anthropic cache_control " +
+                "emission is wrong, or this harness's model/threshold assumptions are — revise the design " +
+                'or the code, do not re-run for a better number. (Re-run once with a fresh SALT first, to ' +
+                'rule out a TTL-tainted reading.)');
+        case 'ambiguous':
+            return (`arm 1 (no breakpoints) warm ${a} -> arm 2 (systemBreakpoints) warm ${b}\n` +
+                'AMBIGUOUS: neither arm clearly separates. Re-run with a fresh SALT.');
+        case 'inconclusive':
+            return 'inconclusive: cache-hit ratio not computable for at least one arm — a call may have failed.';
+    }
+}
+//# sourceMappingURL=promptCacheAnthropicBreakpointHarness.js.map

package/lib/packlets/ai-assist/promptCacheAnthropicBreakpointHarness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptCacheAnthropicBreakpointHarness.js","sourceRoot":"","sources":["../../../src/packlets/ai-assist/promptCacheAnthropicBreakpointHarness.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) 2026 Erik Fortune\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n/**\n * Pure logic and injectable transport for `perf/promptCacheAnthropicBreakpoint.js` — the first\n * measurement of whether C3's Anthropic `cache_control` emission (`IAiCacheRequest.systemBreakpoints`)\n * actually produces a cache hit against a live provider.\n *\n * @remarks\n * Every prompt-cache measurement shipped by this stream so far (`promptCacheObservability.js`,\n * `promptCacheRoutingAb.js`) ran against xAI, whose caching is automatic — no request-side\n * directive is sent, so neither harness exercises C3's emit path at all. Anthropic's cache is the\n * sharp case: it is opt-in **per content block** via `cache_control`, with no automatic path, so a\n * breakpoint is the only thing that can produce a hit. This harness is an A/B rather than a single\n * standing assertion (unlike `promptCacheObservabilityHarness.ts`) precisely because Anthropic has\n * no automatic caching to fall back on: without a negative control that reliably shows no hit, a\n * hit in the positive arm could not be attributed to `systemBreakpoints` at all.\n *\n * Reuses {@link compareCacheHitRatios} / {@link computeCacheUsageRatio} /\n * {@link formatCacheRatioPercent} from `promptCacheUsageMath.ts` rather than re-deriving the\n * ratio/verdict arithmetic — see {@link withAnthropicZeroDefaults} for the one Anthropic-specific\n * wrinkle those shared functions need help with. Also reuses\n * {@link describeObservabilityUsage} from `promptCacheObservabilityHarness.ts` to print reads and\n * writes separately, rather than writing a third formatter for the same shape.\n * @packageDocumentation\n */\n\nimport { fail, succeed, type Result } from '@fgv/ts-utils';\n\nimport { type IAiCacheRequest } from './cacheRequest';\nimport { type IProviderCompletionParams } from './completionClient';\nimport { type IAiCompletionResponse, type IAiProviderDescriptor } from './model';\nimport { describeObservabilityUsage } from './promptCacheObservabilityHarness';\nimport {\n  type CacheHitComparisonVerdict,\n  compareCacheHitRatios,\n  formatCacheRatioPercent\n} from './promptCacheUsageMath';\nimport { type IAiCompletionUsage } from './usageTypes';\n\n/** Injected transport — only the network call needs a live key. @internal */\nexport interface IPromptCacheAnthropicBreakpointDeps {\n  readonly callCompletion: (params: IProviderCompletionParams) => Promise<Result<IAiCompletionResponse>>;\n}\n\n/**\n * Builds one arm's stable system prefix. Same shape as `buildObservabilityStablePrefix` /\n * `buildRoutingAbPrefix` (~8,700 tokens measured for this exact 400-line generator against a\n * comparable provider in this stream's earlier runs) — comfortably above every\n * `minCacheablePrefixTokens` entry design.md §7 lists for Anthropic, including Haiku-class models'\n * 4,096-token floor, not just the 1,024-token floor this harness's target model (`claude-sonnet-5`,\n * the `'base'` tier this stream's other harnesses also default to) actually needs. `salt` and `arm`\n * both feed the text so the two arms — and two separate runs — never warm each other's cache.\n * @internal\n */\nexport function buildAnthropicBreakpointPrefix(salt: string, arm: string): string {\n  const lines: string[] = [];\n  for (let i = 0; i < 400; i++) {\n    lines.push(\n      `Directive ${salt}-${arm}-${i}: when asked about topic ${i}, respond precisely and cite source ${i}-${\n        i * 7\n      }.`\n    );\n  }\n  return `You are a careful assistant operating under the following fixed policy document.\\n\\n${lines.join(\n    '\\n'\n  )}`;\n}\n\n/**\n * Fills Anthropic's cache-usage fields with their design-mandated zero default when the wire\n * response omits them, before feeding a usage block to {@link compareCacheHitRatios}.\n *\n * @remarks\n * `normalizeAnthropicUsage` always reports `reports: 'reads-and-writes'` for this provider, and\n * design.md §8 states the semantics that follow from it explicitly: *\"Under `'reads-and-writes'`,\n * an absent `cacheWriteTokens` genuinely means zero were written.\"* The same reasoning covers\n * `cachedInputTokens` and `uncachedInputTokens`. So for an Anthropic usage block specifically, an\n * absent field is a **known** zero, not an unknown value — applying the default here does not\n * violate design.md's R-c (\"unknown is reported as unknown, never defaulted to a number\"); it is\n * what R-c's own `reports` discriminator exists to allow. This is deliberately narrower than\n * {@link computeCacheUsageRatio}, which stays provider-agnostic (a `'reads'`-only provider's\n * absent field genuinely is ambiguous, per design.md §8's own OQ-1 discussion) — the default is\n * applied here, once, rather than widening the shared function's semantics for every caller.\n *\n * Display (`describeObservabilityUsage`) is untouched by this and keeps printing the raw wire\n * value, so a reader can still see whether a field was actually reported or defaulted.\n * @internal\n */\nexport function withAnthropicZeroDefaults(\n  usage: IAiCompletionUsage | undefined\n): IAiCompletionUsage | undefined {\n  if (usage === undefined || usage.reports !== 'reads-and-writes') {\n    return usage;\n  }\n  return {\n    ...usage,\n    cachedInputTokens: usage.cachedInputTokens ?? 0,\n    uncachedInputTokens: usage.uncachedInputTokens ?? 0,\n    cacheWriteTokens: usage.cacheWriteTokens ?? 0\n  };\n}\n\n/** One arm's cold-then-warm outcome. @internal */\nexport interface IPromptCacheAnthropicBreakpointArmResult {\n  readonly label: string;\n  readonly coldUsage: IAiCompletionUsage | undefined;\n  readonly warmUsage: IAiCompletionUsage | undefined;\n}\n\n/**\n * Runs one arm: a cold call, then a warm call sharing the same\n * {@link buildAnthropicBreakpointPrefix} system prompt and differing only in the final user turn —\n * optionally supplying `cache.systemBreakpoints`. A single breakpoint is placed one character short\n * of the end of `system`, marking essentially the whole fixed prefix as cacheable (design.md §6.1:\n * offsets must be strictly `< system.length`).\n * @internal\n */\nexport async function runPromptCacheAnthropicBreakpointArm(\n  deps: IPromptCacheAnthropicBreakpointDeps,\n  params: {\n    readonly descriptor: IAiProviderDescriptor;\n    readonly apiKey: string;\n    readonly label: string;\n    readonly salt: string;\n    readonly arm: string;\n    readonly withBreakpoint: boolean;\n  }\n): Promise<Result<IPromptCacheAnthropicBreakpointArmResult>> {\n  const { descriptor, apiKey, label, salt, arm, withBreakpoint } = params;\n  const system = buildAnthropicBreakpointPrefix(salt, arm);\n  const cache: IAiCacheRequest | undefined = withBreakpoint\n    ? { systemBreakpoints: [system.length - 1] }\n    : undefined;\n  const call = (content: string): Promise<Result<IAiCompletionResponse>> =>\n    deps.callCompletion({\n      descriptor,\n      apiKey,\n      system,\n      messages: [{ role: 'user', content }],\n      cache\n    });\n\n  const cold = await call('In one sentence, what is directive 12 about?');\n  if (cold.isFailure()) {\n    return fail(`${label}: cold call failed: ${cold.message}`);\n  }\n\n  // Only the tail differs from the cold call — the system prefix is byte-identical.\n  const warm = await call('In one sentence, what is directive 99 about?');\n  if (warm.isFailure()) {\n    return fail(`${label}: warm call failed: ${warm.message}`);\n  }\n\n  return succeed({ label, coldUsage: cold.value.usage, warmUsage: warm.value.usage });\n}\n\n/** The full A/B: both arms' results and the breakpoint verdict. @internal */\nexport interface IPromptCacheAnthropicBreakpointResult {\n  readonly withoutBreakpoint: IPromptCacheAnthropicBreakpointArmResult;\n  readonly withBreakpoint: IPromptCacheAnthropicBreakpointArmResult;\n  /** Baseline = `withoutBreakpoint`'s warm call; candidate = `withBreakpoint`'s warm call. */\n  readonly verdict: CacheHitComparisonVerdict;\n  readonly withoutBreakpointWarmRatio: number | undefined;\n  readonly withBreakpointWarmRatio: number | undefined;\n}\n\n/**\n * Runs both arms of the Anthropic breakpoint A/B and classifies the result.\n *\n * @remarks\n * Both warm usages are passed through {@link withAnthropicZeroDefaults} before comparison, so the\n * negative control (`withoutBreakpoint`) is correctly read as \"no cache activity\" even if\n * Anthropic's wire response omits the cache fields entirely on a request that sends no\n * `cache_control` — the expected shape for that arm — rather than being scored `'inconclusive'`\n * by {@link compareCacheHitRatios}'s provider-agnostic \"absent field = unknown\" default.\n * @internal\n */\nexport async function runPromptCacheAnthropicBreakpointHarness(\n  deps: IPromptCacheAnthropicBreakpointDeps,\n  params: {\n    readonly descriptor: IAiProviderDescriptor;\n    readonly apiKey: string;\n    readonly salt: string;\n  }\n): Promise<Result<IPromptCacheAnthropicBreakpointResult>> {\n  const { descriptor, apiKey, salt } = params;\n\n  const withoutBreakpointResult = await runPromptCacheAnthropicBreakpointArm(deps, {\n    descriptor,\n    apiKey,\n    label: 'arm 1: WITHOUT systemBreakpoints (negative control)',\n    salt,\n    arm: 'a',\n    withBreakpoint: false\n  });\n  if (withoutBreakpointResult.isFailure()) {\n    return fail(withoutBreakpointResult.message);\n  }\n\n  const withBreakpointResult = await runPromptCacheAnthropicBreakpointArm(deps, {\n    descriptor,\n    apiKey,\n    label: 'arm 2: WITH systemBreakpoints (C3 emission under test)',\n    salt,\n    arm: 'b',\n    withBreakpoint: true\n  });\n  if (withBreakpointResult.isFailure()) {\n    return fail(withBreakpointResult.message);\n  }\n\n  const comparison = compareCacheHitRatios(\n    withAnthropicZeroDefaults(withoutBreakpointResult.value.warmUsage),\n    withAnthropicZeroDefaults(withBreakpointResult.value.warmUsage)\n  );\n  return succeed({\n    withoutBreakpoint: withoutBreakpointResult.value,\n    withBreakpoint: withBreakpointResult.value,\n    verdict: comparison.verdict,\n    withoutBreakpointWarmRatio: comparison.baselineRatio,\n    withBreakpointWarmRatio: comparison.candidateRatio\n  });\n}\n\n/**\n * One line per call, reusing `describeObservabilityUsage` so reads and writes are printed\n * separately (`uncached=… cached=… written=…`) rather than collapsed into a single ratio, per\n * this measurement's requirement to report Anthropic's `reads-and-writes` fields individually.\n * @internal\n */\nexport function describeAnthropicBreakpointUsage(\n  label: string,\n  usage: IAiCompletionUsage | undefined\n): string {\n  return describeObservabilityUsage(label, usage);\n}\n\n/**\n * Formats the A/B's closing verdict line(s).\n * @internal\n */\nexport function formatAnthropicBreakpointVerdict(result: IPromptCacheAnthropicBreakpointResult): string {\n  const a = formatCacheRatioPercent(result.withoutBreakpointWarmRatio);\n  const b = formatCacheRatioPercent(result.withBreakpointWarmRatio);\n  switch (result.verdict) {\n    case 'confirms':\n      return (\n        `arm 1 (no breakpoints) warm ${a} -> arm 2 (systemBreakpoints) warm ${b}\\n` +\n        'CONFIRMS the prediction: Anthropic cache_control breakpoints produce a cache hit that an ' +\n        'otherwise-identical request with no cache directive does not.'\n      );\n    case 'misses':\n      return (\n        `arm 1 (no breakpoints) warm ${a} -> arm 2 (systemBreakpoints) warm ${b}\\n` +\n        \"MISSES the prediction: arm 2 did not clear the floor. Either C3's Anthropic cache_control \" +\n        \"emission is wrong, or this harness's model/threshold assumptions are — revise the design \" +\n        'or the code, do not re-run for a better number. (Re-run once with a fresh SALT first, to ' +\n        'rule out a TTL-tainted reading.)'\n      );\n    case 'ambiguous':\n      return (\n        `arm 1 (no breakpoints) warm ${a} -> arm 2 (systemBreakpoints) warm ${b}\\n` +\n        'AMBIGUOUS: neither arm clearly separates. Re-run with a fresh SALT.'\n      );\n    case 'inconclusive':\n      return 'inconclusive: cache-hit ratio not computable for at least one arm — a call may have failed.';\n  }\n}\n"]}

package/lib/packlets/ai-assist/promptCacheObservabilityHarness.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Pure logic and injectable transport for `perf/promptCacheObservability.js` — the C1 standing
+ * assertion for design.md §8.
+ *
+ * @remarks
+ * Extracted so the ratio arithmetic and the cold/warm verdict can be unit-tested against fixture
+ * usage blocks without live traffic or an API key. Mirrors `samples/testbed`'s `xaiCacheProbe`
+ * scenario, whose `IXaiCacheProbeDeps` seam this design.md §8's addendum names as the shape to
+ * copy: only the network call is injected, everything else is a plain function.
+ * @packageDocumentation
+ */
+import { type Result } from '@fgv/ts-utils';
+import { type IProviderCompletionParams } from './completionClient';
+import { type IAiCompletionResponse, type IAiProviderDescriptor } from './model';
+import { type IAiCompletionUsage } from './usageTypes';
+/**
+ * Injected transport. The harness's value is the arithmetic below; the network call is the only
+ * part that needs a live key, so it is the only part injected.
+ * @internal
+ */
+export interface IPromptCacheObservabilityDeps {
+    readonly callCompletion: (params: IProviderCompletionParams) => Promise<Result<IAiCompletionResponse>>;
+}
+/**
+ * Builds the stable system prefix both calls share. Ported verbatim from the harness's
+ * `stablePrefix()` — repetition, not padding, so the text does not compress into something a
+ * provider's tokenizer collapses, and large enough that a genuine cache hit is unmistakable
+ * against design.md's recorded 128-token cold floor.
+ * @internal
+ */
+export declare function buildObservabilityStablePrefix(): string;
+/**
+ * One line summarizing a call's usage block, e.g.
+ * `cold call : reports=reads uncached=8684 cached=192 (2.2% of input) written=undefined output=20`.
+ * Ported from `summarizeUsage`, now returning the line instead of printing it, and computing the
+ * ratio via {@link computeCacheUsageRatio} instead of an unguarded division (see that function's
+ * remarks for the `NaN%` this replaces).
+ * @internal
+ */
+export declare function describeObservabilityUsage(label: string, usage: IAiCompletionUsage | undefined): string;
+/**
+ * Whether the standing assertion's prediction held: `usage.reports` should be `'reads'` on both
+ * calls, and the warm call's cache-hit ratio should clear the cold call's by a wide margin.
+ * @internal
+ */
+export type PromptCacheObservabilityVerdict = 'confirmed' | 'missed' | 'inconclusive';
+/** The evaluated outcome of one cold/warm pair, per design.md §8's written-down prediction. @internal */
+export interface IPromptCacheObservabilityResult {
+    readonly cold: IAiCompletionUsage | undefined;
+    readonly warm: IAiCompletionUsage | undefined;
+    readonly coldRatio: number | undefined;
+    readonly warmRatio: number | undefined;
+    /** `true` only when both calls reported `usage.reports === 'reads'`, as design.md §8 predicts for xAI. */
+    readonly reportsAsPredicted: boolean;
+    readonly verdict: PromptCacheObservabilityVerdict;
+    readonly detail: string;
+}
+/**
+ * Evaluates the standing assertion's written-down prediction (design.md §8) against a cold/warm
+ * pair of usage blocks.
+ *
+ * @remarks
+ * This is new: the original harness printed both summaries and a static reminder for a human to
+ * judge by eye ("prediction check: reports should read 'reads' on both calls…"). Formalizing that
+ * judgement as a pure function is what makes it testable — and per `TESTING_GUIDELINES.md` §
+ * "Measurement Harnesses", an unevaluated prediction is exactly the kind of thing a broken
+ * harness never gets caught printing.
+ * @internal
+ */
+export declare function evaluateObservabilityPrediction(cold: IAiCompletionUsage | undefined, warm: IAiCompletionUsage | undefined): IPromptCacheObservabilityResult;
+/**
+ * Runs the standing assertion: a cold call, then a warm call sharing the same
+ * {@link buildObservabilityStablePrefix} system prompt and differing only in the final user turn.
+ * @internal
+ */
+export declare function runPromptCacheObservabilityHarness(deps: IPromptCacheObservabilityDeps, descriptor: IAiProviderDescriptor, apiKey: string): Promise<Result<IPromptCacheObservabilityResult>>;
+//# sourceMappingURL=promptCacheObservabilityHarness.d.ts.map

package/lib/packlets/ai-assist/promptCacheObservabilityHarness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptCacheObservabilityHarness.d.ts","sourceRoot":"","sources":["../../../src/packlets/ai-assist/promptCacheObservabilityHarness.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AAEH,OAAO,EAAiB,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAMjF,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,yBAAyB,KAAK,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,CAAC;CACxG;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,IAAI,MAAM,CAUvD;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,SAAS,GAAG,MAAM,CAWvG;AAED;;;;GAIG;AACH,MAAM,MAAM,+BAA+B,GAAG,WAAW,GAAG,QAAQ,GAAG,cAAc,CAAC;AAEtF,yGAAyG;AACzG,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,0GAA0G;IAC1G,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,+BAA+B,CAAC;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,kBAAkB,GAAG,SAAS,EACpC,IAAI,EAAE,kBAAkB,GAAG,SAAS,GACnC,+BAA+B,CAmDjC;AAED;;;;GAIG;AACH,wBAAsB,kCAAkC,CACtD,IAAI,EAAE,6BAA6B,EACnC,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,+BAA+B,CAAC,CAAC,CAwBlD"}

package/lib/packlets/ai-assist/promptCacheObservabilityHarness.js

@@ -0,0 +1,143 @@
+"use strict";
+// Copyright (c) 2026 Erik Fortune
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObservabilityStablePrefix = buildObservabilityStablePrefix;
+exports.describeObservabilityUsage = describeObservabilityUsage;
+exports.evaluateObservabilityPrediction = evaluateObservabilityPrediction;
+exports.runPromptCacheObservabilityHarness = runPromptCacheObservabilityHarness;
+/**
+ * Pure logic and injectable transport for `perf/promptCacheObservability.js` — the C1 standing
+ * assertion for design.md §8.
+ *
+ * @remarks
+ * Extracted so the ratio arithmetic and the cold/warm verdict can be unit-tested against fixture
+ * usage blocks without live traffic or an API key. Mirrors `samples/testbed`'s `xaiCacheProbe`
+ * scenario, whose `IXaiCacheProbeDeps` seam this design.md §8's addendum names as the shape to
+ * copy: only the network call is injected, everything else is a plain function.
+ * @packageDocumentation
+ */
+const ts_utils_1 = require("@fgv/ts-utils");
+const promptCacheUsageMath_1 = require("./promptCacheUsageMath");
+/**
+ * Builds the stable system prefix both calls share. Ported verbatim from the harness's
+ * `stablePrefix()` — repetition, not padding, so the text does not compress into something a
+ * provider's tokenizer collapses, and large enough that a genuine cache hit is unmistakable
+ * against design.md's recorded 128-token cold floor.
+ * @internal
+ */
+function buildObservabilityStablePrefix() {
+    const lines = [];
+    for (let i = 0; i < 400; i++) {
+        lines.push(`Directive ${i}: when asked about topic ${i}, respond precisely and cite source ${i}-${i * 7}.`);
+    }
+    return `You are a careful assistant operating under the following fixed policy document.\n\n${lines.join('\n')}`;
+}
+/**
+ * One line summarizing a call's usage block, e.g.
+ * `cold call : reports=reads uncached=8684 cached=192 (2.2% of input) written=undefined output=20`.
+ * Ported from `summarizeUsage`, now returning the line instead of printing it, and computing the
+ * ratio via {@link computeCacheUsageRatio} instead of an unguarded division (see that function's
+ * remarks for the `NaN%` this replaces).
+ * @internal
+ */
+function describeObservabilityUsage(label, usage) {
+    if (usage === undefined) {
+        return `${label}: usage absent from response`;
+    }
+    const { cachedRatio } = (0, promptCacheUsageMath_1.computeCacheUsageRatio)(usage);
+    return (`${label}: reports=${usage.reports} uncached=${usage.uncachedInputTokens} cached=${usage.cachedInputTokens} ` +
+        `(${(0, promptCacheUsageMath_1.formatCacheRatioPercent)(cachedRatio)} of input) written=${usage.cacheWriteTokens} output=${usage.outputTokens}`);
+}
+/**
+ * Evaluates the standing assertion's written-down prediction (design.md §8) against a cold/warm
+ * pair of usage blocks.
+ *
+ * @remarks
+ * This is new: the original harness printed both summaries and a static reminder for a human to
+ * judge by eye ("prediction check: reports should read 'reads' on both calls…"). Formalizing that
+ * judgement as a pure function is what makes it testable — and per `TESTING_GUIDELINES.md` §
+ * "Measurement Harnesses", an unevaluated prediction is exactly the kind of thing a broken
+ * harness never gets caught printing.
+ * @internal
+ */
+function evaluateObservabilityPrediction(cold, warm) {
+    const comparison = (0, promptCacheUsageMath_1.compareCacheHitRatios)(cold, warm);
+    // `cold`/`warm` undefined is a strict subset of `comparison.verdict === 'inconclusive'` (an
+    // undefined usage block always yields an undefined ratio), but checking it explicitly is what
+    // narrows both to defined below — `reports` is a required field, so once narrowed there is no
+    // "usage present but reports absent" case left to guard against with `?.`/`?? 'absent'`.
+    if (cold === undefined || warm === undefined || comparison.verdict === 'inconclusive') {
+        return {
+            cold,
+            warm,
+            coldRatio: comparison.baselineRatio,
+            warmRatio: comparison.candidateRatio,
+            reportsAsPredicted: false,
+            verdict: 'inconclusive',
+            detail: 'cache-hit ratio not computable for the cold call, the warm call, or both'
+        };
+    }
+    const reportsAsPredicted = cold.reports === 'reads' && warm.reports === 'reads';
+    const common = {
+        cold,
+        warm,
+        coldRatio: comparison.baselineRatio,
+        warmRatio: comparison.candidateRatio,
+        reportsAsPredicted
+    };
+    if (!reportsAsPredicted) {
+        return Object.assign(Object.assign({}, common), { verdict: 'missed', detail: `usage.reports was not 'reads' on both calls (cold=${cold.reports}, warm=${warm.reports})` });
+    }
+    if (comparison.verdict === 'confirms') {
+        return Object.assign(Object.assign({}, common), { verdict: 'confirmed', detail: `warm cache-hit ratio (${(0, promptCacheUsageMath_1.formatCacheRatioPercent)(comparison.candidateRatio)}) clears the ` +
+                `cold floor (${(0, promptCacheUsageMath_1.formatCacheRatioPercent)(comparison.baselineRatio)})` });
+    }
+    return Object.assign(Object.assign({}, common), { verdict: 'missed', detail: `warm cache-hit ratio (${(0, promptCacheUsageMath_1.formatCacheRatioPercent)(comparison.candidateRatio)}) did not clear ` +
+            `the cold floor (${(0, promptCacheUsageMath_1.formatCacheRatioPercent)(comparison.baselineRatio)})` });
+}
+/**
+ * Runs the standing assertion: a cold call, then a warm call sharing the same
+ * {@link buildObservabilityStablePrefix} system prompt and differing only in the final user turn.
+ * @internal
+ */
+async function runPromptCacheObservabilityHarness(deps, descriptor, apiKey) {
+    const system = buildObservabilityStablePrefix();
+    const cold = await deps.callCompletion({
+        descriptor,
+        apiKey,
+        system,
+        messages: [{ role: 'user', content: 'In one sentence, what is directive 12 about?' }]
+    });
+    if (cold.isFailure()) {
+        return (0, ts_utils_1.fail)(`cold call failed: ${cold.message}`);
+    }
+    const warm = await deps.callCompletion({
+        descriptor,
+        apiKey,
+        system,
+        messages: [{ role: 'user', content: 'In one sentence, what is directive 99 about?' }]
+    });
+    if (warm.isFailure()) {
+        return (0, ts_utils_1.fail)(`warm call failed: ${warm.message}`);
+    }
+    return (0, ts_utils_1.succeed)(evaluateObservabilityPrediction(cold.value.usage, warm.value.usage));
+}
+//# sourceMappingURL=promptCacheObservabilityHarness.js.map

package/lib/packlets/ai-assist/promptCacheObservabilityHarness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptCacheObservabilityHarness.js","sourceRoot":"","sources":["../../../src/packlets/ai-assist/promptCacheObservabilityHarness.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) 2026 Erik Fortune\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n/**\n * Pure logic and injectable transport for `perf/promptCacheObservability.js` — the C1 standing\n * assertion for design.md §8.\n *\n * @remarks\n * Extracted so the ratio arithmetic and the cold/warm verdict can be unit-tested against fixture\n * usage blocks without live traffic or an API key. Mirrors `samples/testbed`'s `xaiCacheProbe`\n * scenario, whose `IXaiCacheProbeDeps` seam this design.md §8's addendum names as the shape to\n * copy: only the network call is injected, everything else is a plain function.\n * @packageDocumentation\n */\n\nimport { fail, succeed, type Result } from '@fgv/ts-utils';\n\nimport { type IProviderCompletionParams } from './completionClient';\nimport { type IAiCompletionResponse, type IAiProviderDescriptor } from './model';\nimport {\n  compareCacheHitRatios,\n  computeCacheUsageRatio,\n  formatCacheRatioPercent\n} from './promptCacheUsageMath';\nimport { type IAiCompletionUsage } from './usageTypes';\n\n/**\n * Injected transport. The harness's value is the arithmetic below; the network call is the only\n * part that needs a live key, so it is the only part injected.\n * @internal\n */\nexport interface IPromptCacheObservabilityDeps {\n  readonly callCompletion: (params: IProviderCompletionParams) => Promise<Result<IAiCompletionResponse>>;\n}\n\n/**\n * Builds the stable system prefix both calls share. Ported verbatim from the harness's\n * `stablePrefix()` — repetition, not padding, so the text does not compress into something a\n * provider's tokenizer collapses, and large enough that a genuine cache hit is unmistakable\n * against design.md's recorded 128-token cold floor.\n * @internal\n */\nexport function buildObservabilityStablePrefix(): string {\n  const lines: string[] = [];\n  for (let i = 0; i < 400; i++) {\n    lines.push(\n      `Directive ${i}: when asked about topic ${i}, respond precisely and cite source ${i}-${i * 7}.`\n    );\n  }\n  return `You are a careful assistant operating under the following fixed policy document.\\n\\n${lines.join(\n    '\\n'\n  )}`;\n}\n\n/**\n * One line summarizing a call's usage block, e.g.\n * `cold call : reports=reads uncached=8684 cached=192 (2.2% of input) written=undefined output=20`.\n * Ported from `summarizeUsage`, now returning the line instead of printing it, and computing the\n * ratio via {@link computeCacheUsageRatio} instead of an unguarded division (see that function's\n * remarks for the `NaN%` this replaces).\n * @internal\n */\nexport function describeObservabilityUsage(label: string, usage: IAiCompletionUsage | undefined): string {\n  if (usage === undefined) {\n    return `${label}: usage absent from response`;\n  }\n  const { cachedRatio } = computeCacheUsageRatio(usage);\n  return (\n    `${label}: reports=${usage.reports} uncached=${usage.uncachedInputTokens} cached=${usage.cachedInputTokens} ` +\n    `(${formatCacheRatioPercent(cachedRatio)} of input) written=${usage.cacheWriteTokens} output=${\n      usage.outputTokens\n    }`\n  );\n}\n\n/**\n * Whether the standing assertion's prediction held: `usage.reports` should be `'reads'` on both\n * calls, and the warm call's cache-hit ratio should clear the cold call's by a wide margin.\n * @internal\n */\nexport type PromptCacheObservabilityVerdict = 'confirmed' | 'missed' | 'inconclusive';\n\n/** The evaluated outcome of one cold/warm pair, per design.md §8's written-down prediction. @internal */\nexport interface IPromptCacheObservabilityResult {\n  readonly cold: IAiCompletionUsage | undefined;\n  readonly warm: IAiCompletionUsage | undefined;\n  readonly coldRatio: number | undefined;\n  readonly warmRatio: number | undefined;\n  /** `true` only when both calls reported `usage.reports === 'reads'`, as design.md §8 predicts for xAI. */\n  readonly reportsAsPredicted: boolean;\n  readonly verdict: PromptCacheObservabilityVerdict;\n  readonly detail: string;\n}\n\n/**\n * Evaluates the standing assertion's written-down prediction (design.md §8) against a cold/warm\n * pair of usage blocks.\n *\n * @remarks\n * This is new: the original harness printed both summaries and a static reminder for a human to\n * judge by eye (\"prediction check: reports should read 'reads' on both calls…\"). Formalizing that\n * judgement as a pure function is what makes it testable — and per `TESTING_GUIDELINES.md` §\n * \"Measurement Harnesses\", an unevaluated prediction is exactly the kind of thing a broken\n * harness never gets caught printing.\n * @internal\n */\nexport function evaluateObservabilityPrediction(\n  cold: IAiCompletionUsage | undefined,\n  warm: IAiCompletionUsage | undefined\n): IPromptCacheObservabilityResult {\n  const comparison = compareCacheHitRatios(cold, warm);\n\n  // `cold`/`warm` undefined is a strict subset of `comparison.verdict === 'inconclusive'` (an\n  // undefined usage block always yields an undefined ratio), but checking it explicitly is what\n  // narrows both to defined below — `reports` is a required field, so once narrowed there is no\n  // \"usage present but reports absent\" case left to guard against with `?.`/`?? 'absent'`.\n  if (cold === undefined || warm === undefined || comparison.verdict === 'inconclusive') {\n    return {\n      cold,\n      warm,\n      coldRatio: comparison.baselineRatio,\n      warmRatio: comparison.candidateRatio,\n      reportsAsPredicted: false,\n      verdict: 'inconclusive',\n      detail: 'cache-hit ratio not computable for the cold call, the warm call, or both'\n    };\n  }\n\n  const reportsAsPredicted = cold.reports === 'reads' && warm.reports === 'reads';\n  const common = {\n    cold,\n    warm,\n    coldRatio: comparison.baselineRatio,\n    warmRatio: comparison.candidateRatio,\n    reportsAsPredicted\n  };\n\n  if (!reportsAsPredicted) {\n    return {\n      ...common,\n      verdict: 'missed',\n      detail: `usage.reports was not 'reads' on both calls (cold=${cold.reports}, warm=${warm.reports})`\n    };\n  }\n  if (comparison.verdict === 'confirms') {\n    return {\n      ...common,\n      verdict: 'confirmed',\n      detail:\n        `warm cache-hit ratio (${formatCacheRatioPercent(comparison.candidateRatio)}) clears the ` +\n        `cold floor (${formatCacheRatioPercent(comparison.baselineRatio)})`\n    };\n  }\n  return {\n    ...common,\n    verdict: 'missed',\n    detail:\n      `warm cache-hit ratio (${formatCacheRatioPercent(comparison.candidateRatio)}) did not clear ` +\n      `the cold floor (${formatCacheRatioPercent(comparison.baselineRatio)})`\n  };\n}\n\n/**\n * Runs the standing assertion: a cold call, then a warm call sharing the same\n * {@link buildObservabilityStablePrefix} system prompt and differing only in the final user turn.\n * @internal\n */\nexport async function runPromptCacheObservabilityHarness(\n  deps: IPromptCacheObservabilityDeps,\n  descriptor: IAiProviderDescriptor,\n  apiKey: string\n): Promise<Result<IPromptCacheObservabilityResult>> {\n  const system = buildObservabilityStablePrefix();\n\n  const cold = await deps.callCompletion({\n    descriptor,\n    apiKey,\n    system,\n    messages: [{ role: 'user', content: 'In one sentence, what is directive 12 about?' }]\n  });\n  if (cold.isFailure()) {\n    return fail(`cold call failed: ${cold.message}`);\n  }\n\n  const warm = await deps.callCompletion({\n    descriptor,\n    apiKey,\n    system,\n    messages: [{ role: 'user', content: 'In one sentence, what is directive 99 about?' }]\n  });\n  if (warm.isFailure()) {\n    return fail(`warm call failed: ${warm.message}`);\n  }\n\n  return succeed(evaluateObservabilityPrediction(cold.value.usage, warm.value.usage));\n}\n"]}

package/lib/packlets/ai-assist/promptCacheRoutingAbHarness.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Pure logic and injectable transport for `perf/promptCacheRoutingAb.js` — the A/B that measures
+ * whether `IAiCacheRequest.cacheKey` actually improves the xAI cache-hit rate (design.md §2's
+ * 2026-09-19 measurement note, and result.md's "gating defect in C3").
+ *
+ * @remarks
+ * Extracted for the same reason as `promptCacheObservabilityHarness.ts`: the verdict this harness
+ * prints (CONFIRMS / MISSES / AMBIGUOUS) "has already been used to justify a merge," per this
+ * stream's follow-up task, and had no test checking it classifies correctly.
+ * @packageDocumentation
+ */
+import { type Result } from '@fgv/ts-utils';
+import { type IProviderCompletionParams } from './completionClient';
+import { type IAiCompletionResponse, type IAiProviderDescriptor } from './model';
+import { type CacheHitComparisonVerdict } from './promptCacheUsageMath';
+import { type IAiCompletionUsage } from './usageTypes';
+/** Injected transport — only the network call needs a live key. @internal */
+export interface IPromptCacheRoutingAbDeps {
+    readonly callCompletion: (params: IProviderCompletionParams) => Promise<Result<IAiCompletionResponse>>;
+}
+/**
+ * Builds one arm's stable system prefix. Ported verbatim from the harness's `stablePrefix(arm)`.
+ * `salt` and `arm` both feed the text so the two arms — and two separate runs — never warm each
+ * other's cache.
+ * @internal
+ */
+export declare function buildRoutingAbPrefix(salt: string, arm: string): string;
+/**
+ * One line describing a usage block. Ported from `describeUsage`, now computing the ratio via
+ * {@link computeCacheUsageRatio} instead of an inline calculation that coalesced a missing
+ * `cachedInputTokens` or `uncachedInputTokens` to `0` (see that function's remarks).
+ * @internal
+ */
+export declare function describeRoutingAbUsage(usage: IAiCompletionUsage | undefined): string;
+/** One arm's cold-then-warm outcome. @internal */
+export interface IPromptCacheRoutingAbArmResult {
+    readonly label: string;
+    readonly coldUsage: IAiCompletionUsage | undefined;
+    readonly warmUsage: IAiCompletionUsage | undefined;
+}
+/**
+ * Runs one arm: a cold call, then a warm call sharing the same {@link buildRoutingAbPrefix} system
+ * prompt and differing only in the final user turn — optionally supplying `cacheKey`. Ported from
+ * `runArm`, with the network call injected.
+ * @internal
+ */
+export declare function runPromptCacheRoutingAbArm(deps: IPromptCacheRoutingAbDeps, params: {
+    readonly descriptor: IAiProviderDescriptor;
+    readonly apiKey: string;
+    readonly label: string;
+    readonly salt: string;
+    readonly arm: string;
+    readonly cacheKey?: string;
+}): Promise<Result<IPromptCacheRoutingAbArmResult>>;
+/** The full A/B: both arms' results and the routing-key verdict. @internal */
+export interface IPromptCacheRoutingAbResult {
+    readonly withoutKey: IPromptCacheRoutingAbArmResult;
+    readonly withKey: IPromptCacheRoutingAbArmResult;
+    /** Baseline = `withoutKey`'s warm call; candidate = `withKey`'s warm call. */
+    readonly verdict: CacheHitComparisonVerdict;
+    readonly withoutKeyWarmRatio: number | undefined;
+    readonly withKeyWarmRatio: number | undefined;
+}
+/**
+ * Runs both arms of the routing-key A/B and classifies the result.
+ *
+ * @remarks
+ * The verdict compares each arm's **warm** call against the other's — not an arm's own cold vs.
+ * warm call — because the question is whether the routing key changes the warm hit rate relative
+ * to the no-key baseline, exactly as `promptCacheRoutingAb.js`'s original `main()` computed it
+ * (`pct(withoutKey)` / `pct(withKey)`, both taken from each arm's warm response).
+ * @internal
+ */
+export declare function runPromptCacheRoutingAbHarness(deps: IPromptCacheRoutingAbDeps, params: {
+    readonly descriptor: IAiProviderDescriptor;
+    readonly apiKey: string;
+    readonly salt: string;
+}): Promise<Result<IPromptCacheRoutingAbResult>>;
+/**
+ * Formats the A/B's closing verdict line(s), matching the original harness's console output.
+ * @internal
+ */
+export declare function formatRoutingAbVerdict(result: IPromptCacheRoutingAbResult): string;
+//# sourceMappingURL=promptCacheRoutingAbHarness.d.ts.map

package/lib/packlets/ai-assist/promptCacheRoutingAbHarness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptCacheRoutingAbHarness.d.ts","sourceRoot":"","sources":["../../../src/packlets/ai-assist/promptCacheRoutingAbHarness.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AAEH,OAAO,EAAiB,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAG3D,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACjF,OAAO,EACL,KAAK,yBAAyB,EAI/B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,6EAA6E;AAC7E,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,yBAAyB,KAAK,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,CAAC;CACxG;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAYtE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,SAAS,GAAG,MAAM,CAYpF;AAED,kDAAkD;AAClD,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACnD,QAAQ,CAAC,SAAS,EAAE,kBAAkB,GAAG,SAAS,CAAC;CACpD;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,yBAAyB,EAC/B,MAAM,EAAE;IACN,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,GACA,OAAO,CAAC,MAAM,CAAC,8BAA8B,CAAC,CAAC,CAyBjD;AAED,8EAA8E;AAC9E,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,UAAU,EAAE,8BAA8B,CAAC;IACpD,QAAQ,CAAC,OAAO,EAAE,8BAA8B,CAAC;IACjD,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,yBAAyB,CAAC;IAC5C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,yBAAyB,EAC/B,MAAM,EAAE;IACN,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,GACA,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAAC,CAAC,CAkC9C;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,2BAA2B,GAAG,MAAM,CAwBlF"}