humanish 0.17.0 → 0.19.0

package/dist/run.js

@@ -18,6 +18,7 @@ import { mapWithConcurrency } from "./concurrency.js";
 import { screenshotEvidenceError } from "./image-evidence.js";
 import { buildObserverData } from "./observer-data.js";
 import { parseResolvedPersona, personaToDirectives, renderPersonaPromptSection } from "./persona.js";
+import { round6 } from "./pricing.js";
 import { containsSensitive, digestText, redactText, redactToSecretLabel, tailText } from "./redaction.js";
 import { bindExistingRunArtifactPaths, RUNS_RELATIVE_ROOT, isSafeRunIdSegment, prepareRunArtifactPaths, resolveExistingRunDirectory, resolveLatestRunDirectory, resolveRunsRoot, validatePreparedRunArtifactPaths } from "./run-paths.js";
 import { assertPreparedSelectedOutputDirectory, assertSafeOutputPathSegment, bindExistingManagedHumanishOutputDirectory, prepareContainedOutputDirectory, prepareContainedOutputDirectoryRoot, prepareContainedOutputFile, prepareSelectedOutputDirectory, readContainedRegularFile, writeContainedOutputFile, writePreparedRunLatestPointer } from "./selected-output-paths.js";
@@ -2460,6 +2461,18 @@ async function verifyPreparedRun(cwd, runInput, runPaths) {
             ? "rerun bundles either are absent or link selected lanes to prior lane status and a fan-out rerun event"
             : `rerun lineage findings: ${rerunFindings.join(", ")}`
     });
+    // Cost is ADVISORY on magnitude, FAIL-CLOSED on labeling/provenance (claims match mechanism).
+    // Absence PASSES (fail-open on display); a claimed dollar figure without its ratesAsOf date +
+    // source, or a total that does not match its known lines, FAILS. Magnitude is never inspected —
+    // a correctly-labeled huge estimate still passes.
+    const costFindings = isRunBundle(bundle) ? costLabelingFindings(bundle) : [];
+    checks.push({
+        name: "cost estimate labeling",
+        ok: costFindings.length === 0,
+        message: costFindings.length === 0
+            ? "cost figures are absent, or every claimed estimate carries its ratesAsOf date + source and the total matches its known lines (estimates never presented as exact)"
+            : `cost labeling findings: ${costFindings.join(", ")}`
+    });
     const ok = checks.every((check) => check.ok);
     const warnings = isRunBundle(bundle)
         ? [...rawScreenshotPostureWarnings(bundle), ...undeclaredSubjectStateWarnings(bundle), ...desktopGeometryWarnings(bundle)]
@@ -3809,6 +3822,79 @@ function rerunLineageFindings(bundle) {
     }
     return findings;
 }
+/**
+ * Verify the LABELING/provenance of any cost figure a bundle CLAIMS — never its magnitude. Returns
+ * [] (pass) unless a dollar claim lacks its provenance (invariant 6) or a total misreports its
+ * known lines. ABSENCE always passes (fail-open on display, discipline #3): a bundle with no cost,
+ * a null estimate, or a lane without estimatedCost is fine. A NON-NULL figure must carry its
+ * ratesAsOf date + source; a NUMBER total must equal round6(sum of ONLY the non-null lines) and a
+ * null line may never be coerced to 0. A null estimate must be declared honestly (a reason + null
+ * ratesAsOf), mirroring the terminal no-spend proof's null-discipline.
+ */
+function costLabelingFindings(bundle) {
+    const findings = [];
+    const cost = bundle.cost;
+    if (cost) {
+        if (cost.schema !== "humanish.run-cost-summary.v1") {
+            findings.push(`run cost summary schema is ${String(cost.schema)}, expected humanish.run-cost-summary.v1`);
+        }
+        let knownSum = 0;
+        let anyKnown = false;
+        for (const [index, line] of (cost.breakdown ?? []).entries()) {
+            if (line.estimatedCostUsd === null) {
+                continue;
+            }
+            anyKnown = true;
+            knownSum += line.estimatedCostUsd;
+            if (typeof line.ratesAsOf !== "string" || line.ratesAsOf.length === 0) {
+                findings.push(`cost breakdown line ${index} (${line.kind}) claims $${line.estimatedCostUsd} without a ratesAsOf date`);
+            }
+            if (typeof line.source !== "string" || line.source.length === 0) {
+                findings.push(`cost breakdown line ${index} (${line.kind}) claims $${line.estimatedCostUsd} without a pricing source`);
+            }
+        }
+        if (cost.estimatedTotalUsd !== null) {
+            if (typeof cost.ratesAsOf !== "string" || cost.ratesAsOf.length === 0) {
+                findings.push("run cost summary claims a number estimatedTotalUsd without a ratesAsOf date");
+            }
+            if (round6(cost.estimatedTotalUsd) !== round6(knownSum)) {
+                findings.push(`run cost estimatedTotalUsd ${cost.estimatedTotalUsd} does not equal the sum of its known breakdown lines (${round6(knownSum)})`);
+            }
+        }
+        else if (anyKnown) {
+            // Every-line-null is the only honest null total; a null total beside a known line hides spend.
+            findings.push("run cost estimatedTotalUsd is null but a breakdown line carries a known (non-null) cost");
+        }
+    }
+    for (const stream of bundle.streams) {
+        const estimate = stream.actor?.estimatedCost;
+        if (!estimate) {
+            continue;
+        }
+        const laneLabel = stream.laneId ?? stream.id;
+        if (estimate.schema !== "humanish.actor-estimated-cost.v1") {
+            findings.push(`lane ${laneLabel} actor estimatedCost schema is ${String(estimate.schema)}, expected humanish.actor-estimated-cost.v1`);
+        }
+        if (estimate.estimatedCostUsd !== null) {
+            if (typeof estimate.ratesAsOf !== "string" || estimate.ratesAsOf.length === 0) {
+                findings.push(`lane ${laneLabel} claims a model-token cost $${estimate.estimatedCostUsd} without a ratesAsOf date`);
+            }
+            if (typeof estimate.source !== "string" || estimate.source.length === 0) {
+                findings.push(`lane ${laneLabel} claims a model-token cost $${estimate.estimatedCostUsd} without a pricing source`);
+            }
+        }
+        else {
+            // Declared-absent honesty (invariant 5): a null estimate must say WHY and carry null ratesAsOf.
+            if (estimate.reason === undefined) {
+                findings.push(`lane ${laneLabel} records a null cost estimate without a reason`);
+            }
+            if (estimate.ratesAsOf !== null) {
+                findings.push(`lane ${laneLabel} records a null cost estimate but carries a non-null ratesAsOf`);
+            }
+        }
+    }
+    return findings;
+}
 // SEQUENTIAL: the three disclosures a sequential shared-world bundle MUST pin (verify fails closed
 // if any is absent — omission overclaims): sequential turns only, no concurrency/races handled, and
 // a checkpoint delta is attributed to the TURN it followed, not a specific action (correlation).