tickmarkr 2.8.6 → 2.8.8

package/dist/report/compare.js

@@ -1,43 +1,50 @@
+import { normalizeGateOutcome } from "../run/outcome.js";
 import { estimateCosts } from "./cost.js";
 export function hasRunStart(events) {
     return events.some((e) => e.event === "run-start");
 }
-// First run-start's environment, fail-closed on a missing or malformed stamp.
-export function recordedEnvironment(events) {
-    for (const e of events) {
-        if (e.event !== "run-start")
-            continue;
-        const env = e.data.environment;
-        if (!env || typeof env !== "object" || Array.isArray(env))
-            return undefined;
-        const o = env;
-        if (typeof o.tickmarkrVersion !== "string" || typeof o.configHash !== "string")
-            return undefined;
-        if (!o.adapterVersions || typeof o.adapterVersions !== "object" || Array.isArray(o.adapterVersions))
+// Queue 35 (D-2134 R6): validate each session's stamp before folding the run's identity.
+function parseEnvironment(env) {
+    if (!env || typeof env !== "object" || Array.isArray(env))
+        return undefined;
+    const o = env;
+    if (typeof o.tickmarkrVersion !== "string" || !o.tickmarkrVersion.trim()
+        || typeof o.configHash !== "string" || !o.configHash.trim())
+        return undefined;
+    if (!o.adapterVersions || typeof o.adapterVersions !== "object" || Array.isArray(o.adapterVersions))
+        return undefined;
+    const adapterVersions = {};
+    for (const [k, v] of Object.entries(o.adapterVersions)) {
+        if (typeof v !== "string")
             return undefined;
-        const adapterVersions = {};
-        for (const [k, v] of Object.entries(o.adapterVersions)) {
-            if (typeof v !== "string")
-                return undefined;
-            adapterVersions[k] = v;
-        }
-        // Capacity arrived in v2.0 as a pair. Two absent fields are an honest older record; one without
-        // the other is a malformed new record and fails closed instead of being compared as legacy.
-        const hasCores = Object.hasOwn(o, "cores");
-        const hasForkCap = Object.hasOwn(o, "forkCap");
-        if (hasCores !== hasForkCap)
-            return undefined;
-        if (hasCores && (typeof o.cores !== "number" || !Number.isFinite(o.cores) || o.cores <= 0
-            || typeof o.forkCap !== "number" || !Number.isFinite(o.forkCap) || o.forkCap <= 0))
-            return undefined;
-        return {
-            tickmarkrVersion: o.tickmarkrVersion,
-            configHash: o.configHash,
-            adapterVersions,
-            ...(hasCores ? { cores: o.cores, forkCap: o.forkCap } : {}),
-        };
+        adapterVersions[k] = v;
     }
-    return undefined;
+    // Capacity arrived in v2.0 as a pair. Two absent fields are an honest older record; one without
+    // the other is a malformed new record and fails closed instead of being compared as legacy.
+    const hasCores = Object.hasOwn(o, "cores");
+    const hasForkCap = Object.hasOwn(o, "forkCap");
+    if (hasCores !== hasForkCap)
+        return undefined;
+    if (hasCores && (typeof o.cores !== "number" || !Number.isFinite(o.cores) || o.cores <= 0
+        || typeof o.forkCap !== "number" || !Number.isFinite(o.forkCap) || o.forkCap <= 0))
+        return undefined;
+    return {
+        tickmarkrVersion: o.tickmarkrVersion,
+        configHash: o.configHash,
+        adapterVersions,
+        ...(hasCores ? { cores: o.cores, forkCap: o.forkCap } : {}),
+    };
+}
+export function recordedEnvironments(events) {
+    return events.flatMap((e) => e.event === "run-start" || e.event === "run-resume"
+        ? [{ event: e.event, ts: e.ts, environment: parseEnvironment(e.data.environment) }]
+        : []);
+}
+export function recordedEnvironment(events) {
+    const sessions = recordedEnvironments(events);
+    const first = sessions[0]?.environment;
+    return first && sessions.every(({ environment }) => environment && envEqual(first, environment))
+        ? first : undefined;
 }
 // Canonical identity string for the `recorded` field — configHash is the axis the acceptance
 // criteria name; full environment equality still decides .comparable.
@@ -81,12 +88,14 @@ export function runMetrics(events, rows = [], cost = {}) {
             durationMs = to - from;
     }
     const gates = events.filter((e) => e.event === "gate-result");
-    const gatePass = gates.filter((e) => e.data.pass === true).length;
-    const gateFail = gates.filter((e) => e.data.pass === false).length;
+    const gatePass = gates.filter((e) => normalizeGateOutcome(e.data).kind === "passed").length;
+    const gateFail = gates.filter((e) => normalizeGateOutcome(e.data).kind === "failed").length;
     let costUsd;
     let costSum = 0;
     let hasCost = false;
-    for (const p of estimateCosts(rows, cost)) {
+    const prices = estimateCosts(rows, cost);
+    const costPartial = prices.some((p) => p.partialMetering);
+    for (const p of prices) {
         if (p.apiUsd !== undefined) {
             costSum += p.apiUsd;
             hasCost = true;
@@ -110,7 +119,7 @@ export function runMetrics(events, rows = [], cost = {}) {
     }
     if (hasTokens)
         tokensTotal = tokenSum;
-    return { durationMs, gatePass, gateFail, gateTotal: gates.length, costUsd, tokensTotal };
+    return { durationMs, gatePass, gateFail, gateTotal: gates.length, costUsd, costPartial, tokensTotal };
 }
 const n = (x) => x.toLocaleString("en-US");
 const EM = "—";
@@ -161,6 +170,9 @@ function comparabilityLine(cmp, baselineEnv, currentEnv) {
     if (cmp.reason === "unbound") {
         return "comparability caveat — one or both runs lack a recorded environment identity; not apples-to-apples";
     }
+    if (cmp.mixedSessions) {
+        return "comparability caveat — environment identity disagrees across mixed sessions; not apples-to-apples";
+    }
     const base = baselineEnv?.configHash ?? EM;
     const cur = currentEnv?.configHash ?? EM;
     return `comparability caveat — environment identity disagrees (baseline configHash=${base} ≠ current configHash=${cur}; recorded baseline ${cmp.recorded}); not apples-to-apples`;
@@ -182,7 +194,7 @@ export function renderComparison(opts) {
         `| duration | ${fmtDuration(baseline.durationMs)} | ${fmtDuration(current.durationMs)} | ${fmtSignedDuration(delta.durationMs)} |`,
         `| gate failures | ${fmtInt(baseline.gateFail)} | ${fmtInt(current.gateFail)} | ${fmtSignedInt(delta.gateFail)} |`,
         `| gate pass rate | ${baseline.gateTotal ? `${baseline.gatePass}/${baseline.gateTotal}` : EM} | ${current.gateTotal ? `${current.gatePass}/${current.gateTotal}` : EM} | ${EM} |`,
-        `| cost | ${fmtUsd(baseline.costUsd)} | ${fmtUsd(current.costUsd)} | ${fmtSignedUsd(delta.costUsd)} |`,
+        `| cost | ${fmtUsd(baseline.costUsd)}${baseline.costPartial ? " (partial)" : ""} | ${fmtUsd(current.costUsd)}${current.costPartial ? " (partial)" : ""} | ${fmtSignedUsd(delta.costUsd)}${delta.costPartial ? " (partial)" : ""} |`,
         `| tokens | ${fmtInt(baseline.tokensTotal)} | ${fmtInt(current.tokensTotal)} | ${fmtSignedInt(delta.tokensTotal)} |`,
         "",
     ];
@@ -208,10 +220,16 @@ export function compareRuns(opts) {
     }
     const baselineEnv = recordedEnvironment(opts.baselineEvents);
     const currentEnv = recordedEnvironment(opts.events);
-    const comparability = environmentComparable(baselineEnv, currentEnv);
+    const sessions = [...recordedEnvironments(opts.baselineEvents), ...recordedEnvironments(opts.events)];
+    const comparability = sessions.some((s) => !s.environment)
+        ? { comparable: false, reason: "unbound" }
+        : !baselineEnv || !currentEnv
+            ? { comparable: false, reason: "mismatch", recorded: baselineEnv?.configHash ?? "mixed sessions", mixedSessions: true }
+            : environmentComparable(baselineEnv, currentEnv);
     const baseline = runMetrics(opts.baselineEvents, opts.baselineRows ?? [], opts.cost ?? {});
     const current = runMetrics(opts.events, opts.rows ?? [], opts.cost ?? {});
     const delta = {
+        costPartial: current.costPartial || baseline.costPartial,
         durationMs: current.durationMs !== undefined && baseline.durationMs !== undefined
             ? current.durationMs - baseline.durationMs
             : undefined,

package/dist/report/operator-record.js

@@ -37,15 +37,16 @@ export function formatRateBasis(row) {
 export function formatChannelMoney(row) {
     const prices = [];
     const bases = [];
+    const floor = row.partialMetering ? "≥ " : "";
     if (row.apiUsd !== undefined)
-        prices.push(`price: $${row.apiUsd.toFixed(6)}`);
+        prices.push(`price: ${floor}$${row.apiUsd.toFixed(6)}`);
     if (row.amortizedUsd !== undefined && row.subPlan !== undefined) {
         const [low, high] = row.amortizedUsd;
-        prices.push(`price: $${low.toFixed(6)}–$${high.toFixed(6)} amortized`);
+        prices.push(`price: ${floor}$${low.toFixed(6)}–$${high.toFixed(6)} amortized`);
         bases.push(`${n(row.attempts)} windows × $${row.subPlan.planMonthly}/month ÷ ${row.subPlan.windowsPerMonthHigh}–${row.subPlan.windowsPerMonthLow} windows/month`);
     }
     if (row.counterfactualUsd !== undefined)
-        prices.push(`API-equivalent: $${row.counterfactualUsd.toFixed(6)}`);
+        prices.push(`API-equivalent: ${floor}$${row.counterfactualUsd.toFixed(6)}`);
     const basis = formatRateBasis(row);
     if (basis)
         bases.push(basis);

package/dist/run/daemon.d.ts

@@ -3,6 +3,7 @@ import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../
 import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
 import { type Baseline, type BaselineProvenance, type GateEvidenceOptions } from "../gates/baseline.js";
+import { environmentFingerprint } from "../gates/cache.js";
 import type { GateResult } from "../gates/types.js";
 import { type RunGraph, type Task } from "../graph/schema.js";
 import { type PreserveProducer, type RunCapacity } from "./git.js";
@@ -226,6 +227,7 @@ export declare function resetHarvestSilentMsForTests(): void;
 export declare const HARVESTED_RESULT_SUMMARY = "harvested: the worktree carries committed work; the worker emitted no TICKMARKR_RESULT trailer";
 /** T4 (OBS-266): identity of the command SET a tip verify ran — a changed command is a different verify. */
 export declare function commandsHash(commands: Record<string, string>): string;
+type TipEnvironment = ReturnType<typeof environmentFingerprint>;
 export interface TipProof {
     kind: "fresh" | "reused" | "failed" | "incomplete";
     /** Each completed gate keeps its own execution provenance, even in a mixed cycle. */
@@ -261,6 +263,7 @@ export interface TipClose {
     expected?: string;
     identityFailed: boolean;
     deferred: DeferredVerdict[];
+    tipEnvironment?: TipEnvironment;
 }
 interface TipVerifyOptions {
     lastMergedTask?: string;
@@ -293,6 +296,7 @@ export declare function appendIdentityFailure(journal: Journal, f: {
     state?: IntegrationRefState;
     cmdHash: string;
     capacity: RunCapacity;
+    tipEnvironment?: TipEnvironment;
     infra?: boolean;
 }): void;
 /** O: I(expected) — or, with no expected value, the ref must be regular and its commit becomes the expected. */
@@ -309,9 +313,9 @@ export declare function openingIdentity(identity: TipIdentity, journal: Journal)
 /**
  * OBS-34's strict tip verify, but it stops re-paying for an unmoved tip (~334m corpus-wide; 69.5m in
  * one park-heavy run whose 18 resume cycles merged nothing new). The verify journals the SHA it
- * verified and the hash of the command set, so a later run-end can recognize the same verified state:
- * the expected commit equals the LAST green verified SHA and the commands are unchanged → journal
- * `tip-verify-cached` and skip, with no checkout. ANY doubt — moved tip, changed commands, a gate
+ * verified and the hash of the command set, so a later run-end can recognize the same verified state.
+ * Queue row 24 (D-2134): the last green also binds every row's stamped runner and environment identity
+ * and capacity before `tip-verify-cached` can skip with no checkout. ANY doubt — moved tip, changed commands, a gate
  * missing from that cycle's green set, a failure recorded in it, a cycle older than the last one —
  * runs the full verify. 2.8.1 T1 (ANL-023 §7.1): with `identity` (the daemon always passes it) run end
  * verifies a fresh detached checkout of the expected commit under a validated HEAD reflog, never the