@iowarp/clio-coder 0.4.7 → 0.4.9

package/dist/chunk-2KUBKL63.js

@@ -0,0 +1,336 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/verify/numeric.ts
+init_esm_shims();
+var DEFAULT_NUMERIC_COMBINE = "all";
+var DEFAULT_NUMERIC_NON_FINITE = "fail";
+var MAX_ULP_TOLERANCE = Number.MAX_SAFE_INTEGER;
+function reportedNumber(value) {
+  if (Number.isNaN(value)) return "NaN";
+  if (value === Number.POSITIVE_INFINITY) return "Infinity";
+  if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+  return value;
+}
+var NUMERIC_PAYLOAD_CAPS = Object.freeze({
+  keys: 4096,
+  elements: 1e6
+});
+var TOLERANCE_FIELDS = /* @__PURE__ */ new Set(["relative", "absolute", "ulp", "combine", "nonFinite"]);
+var TOLERANCE_KINDS = ["relative", "absolute", "ulp"];
+function normalizeNumericTolerance(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return new Error("tolerance must be an object with relative, absolute, or ulp");
+  }
+  const record = value;
+  const unknown = Object.keys(record).filter((key) => !TOLERANCE_FIELDS.has(key));
+  if (unknown.length > 0) return new Error(`tolerance has unknown field(s): ${unknown.sort().join(", ")}`);
+  const tolerance = {};
+  for (const kind of ["relative", "absolute"]) {
+    if (!Object.hasOwn(record, kind)) continue;
+    const bound = record[kind];
+    if (typeof bound !== "number" || !Number.isFinite(bound) || bound < 0) {
+      return new Error(`tolerance.${kind} must be a finite non-negative number`);
+    }
+    tolerance[kind] = bound;
+  }
+  if (Object.hasOwn(record, "ulp")) {
+    const bound = record.ulp;
+    if (typeof bound !== "number" || !Number.isInteger(bound) || bound < 0) {
+      return new Error("tolerance.ulp must be a non-negative integer");
+    }
+    if (bound > MAX_ULP_TOLERANCE) {
+      return new Error(`tolerance.ulp must not exceed ${MAX_ULP_TOLERANCE} (Number.MAX_SAFE_INTEGER)`);
+    }
+    tolerance.ulp = bound;
+  }
+  if (tolerance.relative === void 0 && tolerance.absolute === void 0 && tolerance.ulp === void 0) {
+    return new Error("tolerance must name at least one of relative, absolute, or ulp");
+  }
+  if (Object.hasOwn(record, "combine")) {
+    const combine = record.combine;
+    if (combine !== "all" && combine !== "any") return new Error("tolerance.combine must be all or any");
+    tolerance.combine = combine;
+  }
+  if (Object.hasOwn(record, "nonFinite")) {
+    const policy = record.nonFinite;
+    if (policy !== "fail" && policy !== "match") return new Error("tolerance.nonFinite must be fail or match");
+    tolerance.nonFinite = policy;
+  }
+  return tolerance;
+}
+var ORDERED_VIEW = new DataView(new ArrayBuffer(8));
+function orderedBits(value) {
+  ORDERED_VIEW.setFloat64(0, value);
+  const bits = ORDERED_VIEW.getBigInt64(0);
+  return bits < 0n ? -(bits & 0x7fffffffffffffffn) : bits;
+}
+function ulpDistance(actual, expected) {
+  if (!Number.isFinite(actual) || !Number.isFinite(expected)) return Number.POSITIVE_INFINITY;
+  const distance = orderedBits(actual) - orderedBits(expected);
+  const magnitude = distance < 0n ? -distance : distance;
+  return magnitude > BigInt(Number.MAX_SAFE_INTEGER) ? Number.POSITIVE_INFINITY : Number(magnitude);
+}
+function parseNumericPayload(text, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return new Error(`${label} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return new Error(`${label} must be a JSON object of string -> number | number[]`);
+  }
+  const record = parsed;
+  const keys = Object.keys(record);
+  if (keys.length > NUMERIC_PAYLOAD_CAPS.keys)
+    return new Error(`${label} exceeds the ${NUMERIC_PAYLOAD_CAPS.keys}-key cap`);
+  const entries = [];
+  let elements = 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number") {
+      entries.push([key, value]);
+      elements += 1;
+    } else if (Array.isArray(value) && value.every((entry) => typeof entry === "number")) {
+      entries.push([key, [...value]]);
+      elements += value.length;
+    } else {
+      return new Error(`${label}.${key} must be a number or an array of numbers`);
+    }
+    if (elements > NUMERIC_PAYLOAD_CAPS.elements) {
+      return new Error(`${label} exceeds the ${NUMERIC_PAYLOAD_CAPS.elements}-element cap`);
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function effectiveNumericCombine(tolerance) {
+  return tolerance.combine ?? DEFAULT_NUMERIC_COMBINE;
+}
+function effectiveNumericNonFinite(tolerance) {
+  return tolerance.nonFinite ?? DEFAULT_NUMERIC_NON_FINITE;
+}
+function namedKinds(tolerance) {
+  return TOLERANCE_KINDS.filter((kind) => tolerance[kind] !== void 0);
+}
+function nonFinitePairMatches(actual, expected) {
+  if (Number.isNaN(actual) && Number.isNaN(expected)) return true;
+  return actual === expected && !Number.isFinite(actual);
+}
+function reportDeviation(item) {
+  return {
+    ...item,
+    actual: reportedNumber(item.actual),
+    expected: reportedNumber(item.expected),
+    absolute: reportedNumber(item.absolute),
+    relative: item.relative === null ? null : reportedNumber(item.relative),
+    ulp: item.ulp === null ? null : reportedNumber(item.ulp)
+  };
+}
+function deviation(actual, expected, index, nonFinite) {
+  const finite = Number.isFinite(actual) && Number.isFinite(expected);
+  if (!finite) {
+    const matched = nonFinite === "match" && nonFinitePairMatches(actual, expected);
+    return {
+      ...index !== void 0 ? { index } : {},
+      actual,
+      expected,
+      absolute: matched ? 0 : Number.POSITIVE_INFINITY,
+      relative: matched ? 0 : null,
+      ulp: matched ? 0 : null,
+      nonFinite: matched ? "matched" : "mismatched"
+    };
+  }
+  const absolute = Math.abs(actual - expected);
+  let relative = expected === 0 ? absolute === 0 ? 0 : null : absolute / Math.abs(expected);
+  if (!Number.isFinite(absolute)) {
+    relative = Math.abs(actual / expected - 1);
+  }
+  return {
+    ...index !== void 0 ? { index } : {},
+    actual,
+    expected,
+    absolute,
+    relative,
+    ulp: ulpDistance(actual, expected)
+  };
+}
+function violatedTolerances(item, tolerance) {
+  const failed = [];
+  if (tolerance.relative !== void 0 && (item.relative === null || item.relative > tolerance.relative)) {
+    failed.push("relative");
+  }
+  if (tolerance.absolute !== void 0 && item.absolute > tolerance.absolute) failed.push("absolute");
+  if (tolerance.ulp !== void 0 && (item.ulp === null || item.ulp > tolerance.ulp)) failed.push("ulp");
+  return failed;
+}
+function judgeDeviation(item, tolerance, combine) {
+  if (item.nonFinite === "mismatched") return { failed: ["not-finite"], held: [], violated: [] };
+  if (item.nonFinite === "matched") return { failed: [], held: [], violated: [] };
+  const violated = violatedTolerances(item, tolerance);
+  const held = namedKinds(tolerance).filter((kind) => !violated.includes(kind));
+  const passed = combine === "all" ? violated.length === 0 : held.length > 0;
+  return { failed: passed ? [] : violated, held, violated };
+}
+function severity(judgement) {
+  if (judgement.failed.length > 0) return 2;
+  return judgement.violated.length > 0 ? 1 : 0;
+}
+function formatNumber(value) {
+  if (!Number.isFinite(value)) return String(value);
+  const [mantissa = "", exponent] = value.toPrecision(6).split("e");
+  const trimmed = mantissa.includes(".") ? mantissa.replace(/\.?0+$/u, "") : mantissa;
+  return exponent === void 0 ? trimmed : `${trimmed}e${exponent}`;
+}
+function describeDeviation(item) {
+  const where = item.index === void 0 ? "" : `[${item.index}]`;
+  if (item.nonFinite === "matched") {
+    return `${where} actual=${String(item.actual)} expected=${String(item.expected)} (non-finite values match by policy)`;
+  }
+  const relative = item.relative === null ? "undefined" : formatNumber(item.relative);
+  const ulp = item.ulp === null ? "undefined" : String(item.ulp);
+  const zeroReference = item.nonFinite === void 0 && item.expected === 0 && item.actual !== 0 ? "; relative undefined: reference is zero" : "";
+  return `${where} actual=${formatNumber(item.actual)} expected=${formatNumber(item.expected)} abs=${formatNumber(item.absolute)} rel=${relative} ulp=${ulp}${zeroReference}`;
+}
+function formatBound(value) {
+  if (value === 0) return "0";
+  const magnitude = Math.abs(value);
+  return magnitude < 1e-3 || magnitude >= 1e6 ? value.toExponential() : String(value);
+}
+function describeBound(kind, tolerance) {
+  return `${kind}<=${formatBound(tolerance[kind] ?? 0)}`;
+}
+function describeNumericRule(tolerance) {
+  const bounds = namedKinds(tolerance).map((kind) => describeBound(kind, tolerance));
+  const combine = effectiveNumericCombine(tolerance);
+  const clause = bounds.length === 1 ? `${bounds[0]} must hold` : combine === "all" ? `all of ${bounds.join(", ")} must hold` : `any of ${bounds.join(", ")} may hold`;
+  const nonFinite = effectiveNumericNonFinite(tolerance) === "match" ? "NaN matches NaN and same-signed infinities match" : "non-finite values fail";
+  return `${clause}; ${nonFinite}`;
+}
+function passedDetail(key, judgement, worst) {
+  if (worst.nonFinite === "matched")
+    return `${key}: non-finite values match by policy, worst${describeDeviation(worst)}`;
+  const partial = judgement.violated.length > 0 ? ` by ${judgement.held.join(", ")} (${judgement.violated.join(", ")} violated)` : "";
+  return `${key}: within tolerance${partial}, worst${describeDeviation(worst)}`;
+}
+function compareElements(key, actual, expected, tolerance, combine, nonFinite) {
+  let worst;
+  let worstJudgement = { failed: [], held: [], violated: [] };
+  for (let index = 0; index < expected.length; index += 1) {
+    const item = deviation(
+      actual[index],
+      expected[index],
+      expected.length === 1 && actual.length === 1 ? void 0 : index,
+      nonFinite
+    );
+    const judgement = judgeDeviation(item, tolerance, combine);
+    const rank = severity(judgement);
+    const worstRank = severity(worstJudgement);
+    const worse = worst === void 0 || rank > worstRank || rank === worstRank && item.absolute > worst.absolute;
+    if (worse) {
+      worst = item;
+      worstJudgement = judgement;
+    }
+  }
+  if (worst === void 0) {
+    return { key, passed: true, failed: [], held: [], violated: [], detail: `${key}: empty array matches` };
+  }
+  const passed = worstJudgement.failed.length === 0;
+  return {
+    key,
+    passed,
+    failed: worstJudgement.failed,
+    held: worstJudgement.held,
+    violated: worstJudgement.violated,
+    worst: reportDeviation(worst),
+    detail: passed ? passedDetail(key, worstJudgement, worst) : `${key}: failed ${worstJudgement.failed.join(", ")} at worst${describeDeviation(worst)}`
+  };
+}
+function structuralFailure(key, reason, detail) {
+  return { key, passed: false, failed: [reason], held: [], violated: [], detail };
+}
+function compareNumeric(actual, reference, tolerance) {
+  const combine = effectiveNumericCombine(tolerance);
+  const nonFinite = effectiveNumericNonFinite(tolerance);
+  const keys = [.../* @__PURE__ */ new Set([...Object.keys(reference), ...Object.keys(actual)])].sort();
+  const reports = [];
+  for (const key of keys) {
+    const got = actual[key];
+    const want = reference[key];
+    if (got === void 0) {
+      reports.push(structuralFailure(key, "missing-actual", `${key}: missing from the command output`));
+      continue;
+    }
+    if (want === void 0) {
+      reports.push(structuralFailure(key, "missing-reference", `${key}: missing from the reference`));
+      continue;
+    }
+    if (Array.isArray(got) !== Array.isArray(want)) {
+      reports.push(
+        structuralFailure(
+          key,
+          "shape-mismatch",
+          `${key}: ${Array.isArray(got) ? "array" : "scalar"} in the command output but ${Array.isArray(want) ? "array" : "scalar"} in the reference`
+        )
+      );
+      continue;
+    }
+    const gotList = Array.isArray(got) ? got : [got];
+    const wantList = Array.isArray(want) ? want : [want];
+    if (gotList.length !== wantList.length) {
+      reports.push(
+        structuralFailure(
+          key,
+          "length-mismatch",
+          `${key}: ${gotList.length} element(s) in the command output but ${wantList.length} in the reference`
+        )
+      );
+      continue;
+    }
+    reports.push(compareElements(key, gotList, wantList, tolerance, combine, nonFinite));
+  }
+  const failedKeys = reports.filter((report) => !report.passed).map((report) => report.key);
+  const passed = failedKeys.length === 0;
+  return {
+    kind: "numeric-compare",
+    passed,
+    tolerance: { ...tolerance },
+    combine,
+    nonFinite,
+    rule: describeNumericRule(tolerance),
+    keys: reports,
+    failedKeys,
+    summary: passed ? `numeric-compare passed: ${reports.length} key(s) within tolerance` : `numeric-compare failed: ${failedKeys.length} of ${reports.length} key(s) out of tolerance (${failedKeys.join(", ")})`
+  };
+}
+function renderNumericReport(report) {
+  const lines = [report.summary, `rule: ${report.rule}`, `tolerance: ${JSON.stringify(report.tolerance)}`];
+  if (report.reference !== void 0) {
+    lines.push(
+      `reference: ${report.reference.path ?? report.reference.source} sha256=${report.reference.sha256.slice(0, 12)} (${report.reference.bytes}B)`
+    );
+  }
+  if (report.actual !== void 0) {
+    lines.push(`actual: sha256=${report.actual.sha256.slice(0, 12)} (${report.actual.bytes}B)`);
+  }
+  for (const key of report.keys) lines.push(`- ${key.detail}`);
+  return lines.join("\n");
+}
+
+// src/domains/evidence/ordering.ts
+init_esm_shims();
+function compareCodepoints(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+export {
+  compareCodepoints,
+  MAX_ULP_TOLERANCE,
+  normalizeNumericTolerance,
+  parseNumericPayload,
+  compareNumeric,
+  renderNumericReport
+};
+//# sourceMappingURL=chunk-2KUBKL63.js.map

package/dist/chunk-2VBWFXYE.js

@@ -0,0 +1,198 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  isSessionEntry,
+  isSessionHeader
+} from "./chunk-NBPA5QM6.js";
+import {
+  atomicWrite,
+  cwdHash,
+  readSessionFileEntries,
+  sessionPaths
+} from "./chunk-3RDHGNU7.js";
+import {
+  clioStateDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/session/compaction/session-entries.ts
+init_esm_shims();
+function collectSessionEntries(turns, filePath) {
+  const out = [];
+  for (const raw of turns) {
+    if (!isSessionEntry(raw)) {
+      throw new Error(
+        `session ledger contains an unreadable entry (missing kind discriminant): ${filePath}. Remove or compact the session to reset.`
+      );
+    }
+    out.push(raw);
+  }
+  return out;
+}
+
+// src/domains/session/history.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+function listSessionsForCwd(cwd) {
+  const hash = cwdHash(cwd);
+  const dir = join(clioStateDir(), "sessions", hash);
+  if (!existsSync(dir)) return [];
+  const metas = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const sessionDir = join(dir, entry.name);
+    const metaPath = join(sessionDir, "meta.json");
+    if (!existsSync(metaPath)) continue;
+    let meta;
+    try {
+      if (!statSync(metaPath).isFile()) continue;
+      const raw = readFileSync(metaPath, "utf8");
+      meta = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    enrichMetaForListing(meta, join(sessionDir, "current.jsonl"));
+    metas.push(meta);
+  }
+  metas.sort((a, b) => {
+    const aKey = a.lastActivityAt ?? a.createdAt ?? "";
+    const bKey = b.lastActivityAt ?? b.createdAt ?? "";
+    return aKey === bKey ? 0 : aKey > bKey ? -1 : 1;
+  });
+  return metas;
+}
+var PREVIEW_MAX_CHARS = 240;
+function collapseWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function rawMessageText(payload) {
+  if (typeof payload === "string") return payload.trim().length > 0 ? payload : null;
+  if (!payload || typeof payload !== "object") return null;
+  const obj = payload;
+  if (typeof obj.text === "string" && obj.text.trim().length > 0) return obj.text;
+  if (Array.isArray(obj.content)) {
+    const parts = [];
+    for (const part of obj.content) {
+      if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
+        parts.push(part.text);
+      }
+    }
+    const joined = parts.join("\n");
+    if (joined.trim().length > 0) return joined;
+  }
+  return null;
+}
+function extractMessageText(payload) {
+  const raw = rawMessageText(payload);
+  if (raw === null) return null;
+  const collapsed = collapseWhitespace(raw);
+  return collapsed.length > 0 ? collapsed : null;
+}
+function operatorTextOfUserPayload(payload) {
+  if (payload && typeof payload === "object" && typeof payload.displayText === "string") {
+    const typed = collapseWhitespace(payload.displayText);
+    if (typed.length > 0) return typed;
+  }
+  if (payload && typeof payload === "object" && typeof payload.operatorText === "string") {
+    const collapsed = collapseWhitespace(payload.operatorText);
+    return collapsed.length > 0 ? collapsed : null;
+  }
+  const text = rawMessageText(payload);
+  if (text === null) return null;
+  const stripped = collapseWhitespace(stripInjectedPreamble(text));
+  return stripped.length > 0 ? stripped : null;
+}
+var LEADING_SYSTEM_REMINDER = /^\s*<system-reminder>[\s\S]*?<\/system-reminder>\s*/u;
+var LEADING_SKILL_REQUEST = /^\s*\[Skill request\][\s\S]*?Only these pending skill names are allowed this turn\.[^\n]*\s*/u;
+function stripInjectedPreamble(text) {
+  let current = text;
+  for (; ; ) {
+    const next = current.replace(LEADING_SYSTEM_REMINDER, "").replace(LEADING_SKILL_REQUEST, "");
+    if (next === current) return current;
+    current = next;
+  }
+}
+function scanCurrentJsonl(currentPath) {
+  const result = {
+    firstUserMessage: null,
+    firstAssistantMessage: null,
+    messageCount: 0,
+    lastTimestamp: null,
+    name: null,
+    labels: /* @__PURE__ */ new Map()
+  };
+  if (!existsSync(currentPath)) return result;
+  const records = readSessionFileEntries(currentPath).filter((entry) => !isSessionHeader(entry));
+  for (const parsed of collectSessionEntries(records, currentPath)) {
+    if (result.lastTimestamp === null || parsed.timestamp > result.lastTimestamp) {
+      result.lastTimestamp = parsed.timestamp;
+    }
+    if (parsed.kind === "message" && parsed.role === "user") {
+      result.messageCount += 1;
+      if (result.firstUserMessage === null) {
+        const text = operatorTextOfUserPayload(parsed.payload);
+        if (text !== null) result.firstUserMessage = text;
+      }
+    }
+    if (parsed.kind === "message" && parsed.role === "assistant" && result.firstAssistantMessage === null) {
+      const text = extractMessageText(parsed.payload);
+      if (text !== null) result.firstAssistantMessage = text;
+    }
+    if (parsed.kind === "sessionInfo") {
+      const info = parsed;
+      if (info.name !== void 0) {
+        const trimmed = info.name.trim();
+        result.name = trimmed.length > 0 ? trimmed : null;
+      }
+      if (info.targetTurnId && info.label !== void 0) {
+        const existing = result.labels.get(info.targetTurnId);
+        if (!existing || existing.timestamp <= info.timestamp) {
+          result.labels.set(info.targetTurnId, { label: info.label, timestamp: info.timestamp });
+        }
+      }
+    }
+    if (parsed.kind === "label") {
+      const label = parsed;
+      const existing = result.labels.get(label.targetTurnId);
+      if (!existing || existing.timestamp <= label.timestamp) {
+        result.labels.set(label.targetTurnId, { label: label.label ?? "", timestamp: label.timestamp });
+      }
+    }
+  }
+  return result;
+}
+function enrichMetaForListing(meta, currentPath) {
+  const scan = scanCurrentJsonl(currentPath);
+  if (scan.name) meta.name = scan.name;
+  const labelValues = [...scan.labels.values()].map((entry) => entry.label.trim()).filter((label) => label.length > 0);
+  if (labelValues.length > 0) meta.labels = labelValues;
+  const preview = scan.firstUserMessage ?? scan.firstAssistantMessage;
+  if (preview) {
+    meta.firstMessagePreview = preview.length > PREVIEW_MAX_CHARS ? `${preview.slice(0, PREVIEW_MAX_CHARS - 1)}\u2026` : preview;
+  }
+  if (scan.messageCount > 0) meta.messageCount = scan.messageCount;
+  const fallbackMtime = readMtimeIso(currentPath);
+  const activity = scan.lastTimestamp ?? fallbackMtime ?? meta.endedAt ?? meta.createdAt ?? null;
+  if (activity) meta.lastActivityAt = activity;
+}
+function readMtimeIso(path) {
+  try {
+    return statSync(path).mtime.toISOString();
+  } catch {
+    return null;
+  }
+}
+function enrichForkMeta(meta, parentSessionId, parentTurnId) {
+  Object.assign(meta, { parentSessionId, parentTurnId });
+  const paths = sessionPaths(meta);
+  atomicWrite(paths.meta, JSON.stringify(meta, null, 2));
+}
+
+export {
+  collectSessionEntries,
+  listSessionsForCwd,
+  enrichForkMeta
+};
+//# sourceMappingURL=chunk-2VBWFXYE.js.map

package/dist/{chunk-XZ6UFQ52.js → chunk-2X2R3UTH.js}

@@ -1,41 +1,43 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   appendOutOfTurnUsageRow,
-  readAccountabilitySummary,
-  writeEvidenceIndexRowQueued
-} from "./chunk-6LRLOJHQ.js";
+  readAccountabilitySummary
+} from "./chunk-3AND2EFU.js";
 import {
   createWorkerProgressFold
-} from "./chunk-UA6W4XFJ.js";
+} from "./chunk-7JSOSVLP.js";
+import {
+  truncateToWidth
+} from "./chunk-434LRQ6Z.js";
+import {
+  writeEvidenceIndexRowQueued
+} from "./chunk-G5R53COU.js";
 import {
   createDispatchTraceMirror,
   traceDatabasePath
-} from "./chunk-LZBMXNLP.js";
-import {
-  truncateToWidth
-} from "./chunk-V4ZKOKRB.js";
+} from "./chunk-GM4TY6VN.js";
 import {
   buildEvidence,
   createCostTracker
-} from "./chunk-WN552PKN.js";
+} from "./chunk-F2YM3JY4.js";
 import {
   summarizeTrustStatus
-} from "./chunk-IQCNVLO6.js";
+} from "./chunk-IALZJE37.js";
 import {
   uncachedPrefillTokens
 } from "./chunk-QH3ZTUOA.js";
 import {
   cloneRunToolBudgetEnvelope
-} from "./chunk-NO7J45X6.js";
+} from "./chunk-4ATBOFRP.js";
 import {
   sanitizeCallTargetText
-} from "./chunk-2GPGAE5W.js";
+} from "./chunk-XNIZBOFV.js";
 import {
   resolveCostProvenance
-} from "./chunk-WT5TRMO4.js";
+} from "./chunk-4HFJKRGZ.js";
 import {
   BusChannels
-} from "./chunk-6CB2IL4N.js";
+} from "./chunk-W5RM7YAH.js";
 import {
   clioDataDir,
   clioStateDir
@@ -330,6 +332,7 @@ function createObservabilityProjection(bus, deps) {
   }
   function applyIdentity(summary, id) {
     delete summary.trust;
+    delete summary.resultContract;
     if (typeof id.agentId === "string" && id.agentId.length > 0) summary.agentId = id.agentId;
     if (typeof id.targetId === "string" && id.targetId.length > 0) summary.targetId = id.targetId;
     if (typeof id.wireModelId === "string" && id.wireModelId.length > 0) summary.modelId = id.wireModelId;
@@ -375,10 +378,14 @@ function createObservabilityProjection(bus, deps) {
     markChanged();
   }
   function settleFromReceipt(summary) {
+    delete summary.resultContract;
     try {
       const facts = runReaders.readReceipt?.(summary.runId);
       const text = facts?.trust?.artifactIntegrity.state === "verified" ? facts.text : void 0;
       summary.progressFold.settle(typeof text === "string" && text.trim().length > 0 ? text : void 0);
+      if (typeof text === "string" && text.trim().length > 0 && typeof facts?.contractKind === "string" && typeof facts.contract === "string") {
+        summary.resultContract = { kind: facts.contractKind, conformance: facts.contract };
+      }
       if (facts?.trust !== void 0) summary.trust = summarizeTrustStatus(facts.trust);
     } catch {
       summary.progressFold.settle();
@@ -745,6 +752,7 @@ function recordDispatchCost(telemetry, cost, payload) {
       output: payload.outputTokenCount ?? 0,
       cacheRead: payload.cacheReadTokenCount ?? 0,
       cacheWrite: payload.cacheWriteTokenCount ?? 0,
+      ...payload.cacheWrite1hTokenCount === void 0 ? {} : { cacheWrite1h: payload.cacheWrite1hTokenCount },
       reasoningTokens: payload.reasoningTokenCount ?? 0,
       totalTokens: payload.tokenCount
     },
@@ -936,6 +944,7 @@ function backgroundMemoryUsageRow(usage, options) {
       output: usage.output,
       cacheRead: usage.cacheRead,
       cacheWrite: usage.cacheWrite,
+      ...usage.cacheWrite1h === void 0 ? {} : { cacheWrite1h: usage.cacheWrite1h },
       reasoning: usage.reasoning,
       totalTokens: usage.totalTokens,
       costUsd: usage.costUsd,
@@ -971,6 +980,7 @@ function recordBackgroundMemoryStep(input) {
       output: input.usage.output,
       cacheRead: input.usage.cacheRead,
       cacheWrite: input.usage.cacheWrite,
+      ...input.usage.cacheWrite1h === void 0 ? {} : { cacheWrite1h: input.usage.cacheWrite1h },
       reasoningTokens: input.usage.reasoning,
       totalTokens: input.usage.totalTokens,
       apiCalls: 1
@@ -1005,4 +1015,4 @@ export {
   ObservabilityDomainModule,
   createObservabilityDomainModule
 };
-//# sourceMappingURL=chunk-XZ6UFQ52.js.map
+//# sourceMappingURL=chunk-2X2R3UTH.js.map

package/dist/{chunk-M6Z2V6YU.js → chunk-37LW32LZ.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
 import {
   StringEnum
-} from "./chunk-5CMARGPF.js";
+} from "./chunk-UIU7MGZ3.js";
 import {
   typebox_exports
 } from "./chunk-GH5ZR6JP.js";
-import {
-  ToolNames
-} from "./chunk-WLHX3MM5.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -29,4 +29,4 @@ var steerToolSurface = {
 export {
   steerToolSurface
 };
-//# sourceMappingURL=chunk-M6Z2V6YU.js.map
+//# sourceMappingURL=chunk-37LW32LZ.js.map