@iowarp/clio-coder 0.4.8 → 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-K45LHSCI.js → chunk-2VBWFXYE.js}

@@ -2,13 +2,13 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   isSessionEntry,
   isSessionHeader
-} from "./chunk-6R5MBXBJ.js";
+} from "./chunk-NBPA5QM6.js";
 import {
   atomicWrite,
   cwdHash,
   readSessionFileEntries,
   sessionPaths
-} from "./chunk-36XSBPXL.js";
+} from "./chunk-3RDHGNU7.js";
 import {
   clioStateDir
 } from "./chunk-CTTI7G3T.js";
@@ -91,6 +91,10 @@ function extractMessageText(payload) {
   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;
@@ -191,4 +195,4 @@ export {
   listSessionsForCwd,
   enrichForkMeta
 };
-//# sourceMappingURL=chunk-K45LHSCI.js.map
+//# sourceMappingURL=chunk-2VBWFXYE.js.map

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

@@ -2,39 +2,39 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   appendOutOfTurnUsageRow,
   readAccountabilitySummary
-} from "./chunk-W7KNI3F5.js";
+} from "./chunk-3AND2EFU.js";
 import {
   createWorkerProgressFold
-} from "./chunk-K3W6BF5C.js";
-import {
-  buildEvidence,
-  createCostTracker
-} from "./chunk-5W4FRA5Q.js";
-import {
-  summarizeTrustStatus
-} from "./chunk-FB3KTE2J.js";
+} from "./chunk-7JSOSVLP.js";
 import {
   truncateToWidth
-} from "./chunk-V4ZKOKRB.js";
-import {
-  uncachedPrefillTokens
-} from "./chunk-QH3ZTUOA.js";
+} from "./chunk-434LRQ6Z.js";
 import {
   writeEvidenceIndexRowQueued
-} from "./chunk-XC5POIL4.js";
+} from "./chunk-G5R53COU.js";
 import {
   createDispatchTraceMirror,
   traceDatabasePath
 } from "./chunk-GM4TY6VN.js";
+import {
+  buildEvidence,
+  createCostTracker
+} from "./chunk-F2YM3JY4.js";
+import {
+  summarizeTrustStatus
+} from "./chunk-IALZJE37.js";
+import {
+  uncachedPrefillTokens
+} from "./chunk-QH3ZTUOA.js";
 import {
   cloneRunToolBudgetEnvelope
-} from "./chunk-MWMW53WW.js";
+} from "./chunk-4ATBOFRP.js";
 import {
   sanitizeCallTargetText
-} from "./chunk-2GPGAE5W.js";
+} from "./chunk-XNIZBOFV.js";
 import {
   resolveCostProvenance
-} from "./chunk-GVU4CXPJ.js";
+} from "./chunk-4HFJKRGZ.js";
 import {
   BusChannels
 } from "./chunk-W5RM7YAH.js";
@@ -332,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;
@@ -377,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();
@@ -1010,4 +1015,4 @@ export {
   ObservabilityDomainModule,
   createObservabilityDomainModule
 };
-//# sourceMappingURL=chunk-XTLJDC2X.js.map
+//# sourceMappingURL=chunk-2X2R3UTH.js.map

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

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

package/dist/{chunk-W7KNI3F5.js → chunk-3AND2EFU.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  FAILURE_CAUSE_TAGS
-} from "./chunk-5W4FRA5Q.js";
 import {
   readEvidenceIndex
-} from "./chunk-XC5POIL4.js";
+} from "./chunk-G5R53COU.js";
+import {
+  FAILURE_CAUSE_TAGS
+} from "./chunk-F2YM3JY4.js";
 import {
   withStateFileLockSync
 } from "./chunk-DVJL77SO.js";
@@ -212,4 +212,4 @@ export {
   appendOutOfTurnUsageRow,
   readOutOfTurnUsageRows
 };
-//# sourceMappingURL=chunk-W7KNI3F5.js.map
+//# sourceMappingURL=chunk-3AND2EFU.js.map