tickmarkr 2.8.7 → 2.8.9

package/dist/gates/run-gates.js

@@ -1147,7 +1147,21 @@ export async function runGates(task, ctx) {
                 invocations: [],
             };
         }
-        const judgeAdapter = getAdapter(ctx.cfg.judge.adapter, ctx.adapters);
+        // Queue row 34(a) (D-2134 R5): resolve every lifetime author through both role pools.
+        const channels = [...(ctx.judgeChannels ?? []), ...ctx.channels];
+        const authors = ctx.carriedAuthors?.length ? ctx.carriedAuthors : [channelKey(ctx.author)];
+        const authorVendors = carriedAuthorVendors(channels, authors);
+        const independent = (seat) => !!seat.vendor
+            && !authorVendors.has(seat.vendor) && !authors.includes(channelKey(seat));
+        const judgePool = () => (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
+        const rankJudges = (pool) => [...pool]
+            .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y));
+        const pickJudge = (pool, adapter) => rankJudges(pool.filter((c) => c.adapter !== adapter))[0] ?? rankJudges(pool)[0];
+        const configured = channels.find((c) => channelKey(c) === channelKey(ctx.cfg.judge));
+        const primary = authors.includes(channelKey(ctx.cfg.judge)) || (configured && authorVendors.has(configured.vendor))
+            ? pickJudge(judgePool().filter(independent), ctx.cfg.judge.adapter) ?? ctx.cfg.judge
+            : ctx.cfg.judge;
+        const judgeAdapter = getAdapter(primary.adapter, ctx.adapters);
         const jvia = via
             ? { driver: via.driver, keep: via.keep, onSlot: via.onSlot, name: via.nameFor("judge", judgeAdapter.id), label: via.labelFor("judge") }
             : undefined;
@@ -1181,11 +1195,11 @@ export async function runGates(task, ctx) {
                     ...(unparseable ? { transcript: output } : {}),
                 });
             }
-            return captured.value;
+            const result = captured.value;
+            const seat = channels.find((c) => channelKey(c) === result.meta?.judge);
+            return typeof result.meta?.judge === "string" && result.meta.unparseable !== true && (!seat || !independent(seat))
+                ? { ...result, meta: { ...result.meta, judgeIndependent: false } } : result;
         };
-        const judgePool = () => (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
-        const rankJudges = (pool) => [...pool]
-            .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y));
         // OBS-1151 (+add.1): the fresh judgment always stands on its own reading — a prior PASS is never
         // reused. Only a criterion that REVERSES the newest prior ruling on the same subject key over
         // identical cited blobs needs a second, distinct judge; agreement stands (a sound FAIL included),
@@ -1210,16 +1224,18 @@ export async function runGates(task, ctx) {
             if (!disputed.length)
                 return stamped;
             await ctx.onGate?.({ phase: "note", gate: "acceptance", name: "judge-disagreement", payload: { primary, commit, disputed } });
+            let notIndependent = fresh.meta?.judgeIndependent === false;
+            const independence = () => notIndependent ? { judgeIndependent: false } : {};
             const park = (why, adjudicator) => ({
                 gate: "acceptance", pass: false,
                 details: `judge disagreement on ${disputed.map((d) => d.id).join(", ")}: ${primary} reverses an earlier ruling over identical cited blobs (${[...new Set(disputed.flatMap((d) => d.paths))].join(", ")}) — ${why}; parked for an operator ruling, no worker charge`,
-                meta: { classification: "infra", infra: true, retryable: false, cause: "judge-disagreement", judge: primary,
+                meta: { classification: "infra", infra: true, retryable: false, cause: "judge-disagreement", judge: primary, ...independence(),
                     judgeDisagreement: { primary, ...(adjudicator ? { adjudicator } : {}), disputed, outcome: why } },
             });
             const primaryAdapter = primary.slice(0, primary.indexOf(":"));
             // One DISTINCT seat: never the primary channel, a different adapter when the pool has one.
             const pool = judgePool().filter((c) => channelKey(c) !== primary);
-            const seat = rankJudges(pool.filter((c) => c.adapter !== primaryAdapter))[0] ?? rankJudges(pool)[0];
+            const seat = pickJudge(pool.filter(independent), primaryAdapter) ?? pickJudge(pool, primaryAdapter);
             if (!seat)
                 return park("no distinct eligible judge is available");
             const adjudicator = channelKey(seat);
@@ -1230,13 +1246,14 @@ export async function runGates(task, ctx) {
             const subjectPark = (leg, found, ran) => ({
                 gate: "acceptance", pass: false,
                 details: `the adjudication subject ${SUBJECT_LEG_TEXT[leg]}: sampled ${commit.slice(0, 12)}, found ${found.slice(0, 12)} (${leg}); parked for an operator ruling, no worker charge`,
-                meta: { classification: "infra", infra: true, retryable: false, cause: "subject-moved", judge: primary,
+                meta: { classification: "infra", infra: true, retryable: false, cause: "subject-moved", judge: primary, ...independence(),
                     adjudication: { primary, ...(ran ? { adjudicator: ran } : {}), sampled: commit, found, leg } },
             });
             const s0 = await openSubjectWitness(ctx.worktree, commit);
             if ("leg" in s0)
                 return subjectPark(s0.leg, s0.leg === "unreadable" ? "unreadable" : commit);
             const second = await invokeJudge(seatAdapter, seat.model, seatVia, configuredEffort(ctx.cfg, seat));
+            notIndependent ||= second.meta?.judgeIndependent === false;
             const changed = await adjudicationSubjectChange(ctx.worktree, commit, s0);
             if (changed)
                 return subjectPark(changed.leg, changed.found, adjudicator);
@@ -1248,10 +1265,10 @@ export async function runGates(task, ctx) {
             const agreed = disputed.every((d) => rulings.some((r) => r.id === d.id && r.met === d.met && r.paths.length > 0));
             if (!agreed)
                 return park("the adjudicating judge split from the fresh ruling", adjudicator);
-            return { ...stamped, meta: { ...stamped.meta, adjudication: { primary, adjudicator, criteria: disputed.map((d) => d.id), agreed: true } } };
+            return { ...stamped, meta: { ...stamped.meta, ...independence(), adjudication: { primary, adjudicator, criteria: disputed.map((d) => d.id), agreed: true } } };
         };
         // OBS-1182: every judge seat launches at its OWN configured effort, never the worker's.
-        let a = await invokeJudge(judgeAdapter, ctx.cfg.judge.model, jvia, configuredEffort(ctx.cfg, ctx.cfg.judge));
+        let a = await invokeJudge(judgeAdapter, primary.model, jvia, configuredEffort(ctx.cfg, primary));
         // GATE-09: an unparseable judge verdict retries the JUDGE exactly once on a failover channel — never
         // the worker (run-20260711-185020 P43-03 L70-72 billed a judge flake as a worker attempt). The flaked
         // first verdict NEVER enters results (no false gate-result journal event, no operator notify, no stale
@@ -1268,18 +1285,10 @@ export async function runGates(task, ctx) {
         if (!cancelled && a.meta?.unparseable === true && typeof a.meta.judge === "string") {
             const flakedKey = a.meta.judge;
             const flakedAdapter = flakedKey.slice(0, flakedKey.indexOf(":"));
-            const pick = (pool) => pool
-                // pickReviewer's sort (review.ts:37): TIER_RANK desc, marginalCostRank asc — proven ordering; both
-                // symbols already imported by a sibling gate file.
-                .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y))[0];
-            // v1.87 T2: the failover seat obeys the same policy the primary judge just passed — a denied
-            // channel is refused here too, never reached by falling through the exclusion arms below.
-            const judgePool = (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
-            const crossAdapter = pick(judgePool.filter((c) => c.adapter !== flakedAdapter));
-            const sameAdapter = pick(judgePool.filter((c) => c.adapter === flakedAdapter && channelKey(c) !== flakedKey));
-            // Prefer a different adapter; if the fleet only has one adapter, retry on a different channel of
-            // that adapter; if the fleet has only one channel, fall back to the original judge config.
-            const retry = crossAdapter ?? sameAdapter ?? judgeSeat;
+            // Queue row 34(a) (D-2134 R5): keep GATE-09's exclusions and fallback when independence is unavailable.
+            const pool = judgePool().filter((c) => channelKey(c) !== flakedKey);
+            const retry = pickJudge(pool.filter(independent), flakedAdapter)
+                ?? pickJudge(pool, flakedAdapter) ?? judgeSeat;
             const retryAdapter = getAdapter(retry.adapter, ctx.adapters);
             const retryJvia = via
                 // unconditional -r1 suffix: under keepPanes:forever a same-channel retry cannot collide with the

package/dist/report/bundle.d.ts

@@ -1,7 +1,8 @@
 import type { EvidenceCitation } from "../gates/acceptance.js";
 import type { RunEnvironment } from "../run/environment.js";
 import type { JournalEvent } from "../run/journal.js";
-export declare const BUNDLE_SCHEMA_VERSION = 2;
+import { type SessionEnvironment } from "./compare.js";
+export declare const BUNDLE_SCHEMA_VERSION = 3;
 export declare const gateDeclined: (data: Record<string, unknown>) => boolean;
 export declare const KNOWN_LIMITS: readonly string[];
 export type BundleEvidence = string | EvidenceCitation;
@@ -18,6 +19,7 @@ export interface BundleGateResult {
     /** T11: true when the gate declined to run (journaled skipped:true, e.g. review below its
      * complexity threshold) — neither a pass nor a fail; the details carry the reason. */
     declined?: boolean;
+    held?: boolean;
     details: string;
 }
 export interface BundleTask {
@@ -28,7 +30,7 @@ export interface BundleTask {
     judgeCriteria: BundleJudgeCriterion[];
 }
 export interface BundleContentHashes {
-    /** sha256 of the canonical JSON of the source journal events used to build this packet. */
+    /** Queue 35 (D-2134 R6): sha256 of JSON.stringify of the parsed source events. */
     journal: string;
     /** graphDefinitionHash from run-start when recorded. */
     graphDefinitionHash?: string;
@@ -38,6 +40,7 @@ export interface ProofBundle {
     schemaVersion: number;
     runId: string;
     environment?: RunEnvironment;
+    environments: SessionEnvironment[];
     contentHashes: BundleContentHashes;
     tasks: BundleTask[];
     /** Plain-language known limits — this is not an unconditional proof of correctness. */

package/dist/report/bundle.js

@@ -4,11 +4,13 @@
 // redactSecrets seam. No I/O and no network: the caller (report CLI) owns the write.
 import { createHash } from "node:crypto";
 import { redactSecrets } from "../run/redact.js";
-import { recordedEnvironment } from "./compare.js";
+import { normalizeGateOutcome } from "../run/outcome.js";
+import { recordedEnvironment, recordedEnvironments } from "./compare.js";
 // Bump when the packet shape changes in a way a future reader must branch on before parsing.
 // 2 (T11): gates gained `declined`, and `pass` narrowed from "the gate did not fail" to "the gate
 // ran and passed" — a schema-1 reader would read a decline as a plain failure.
-export const BUNDLE_SCHEMA_VERSION = 2;
+// Queue 35 (D-2134 R6): held gates and session environments change the packet's meaning.
+export const BUNDLE_SCHEMA_VERSION = 3;
 // T11: the one predicate every decline surface shares — the record, the text tickmark rate, the
 // comparison metrics and this packet must agree on what "never ran" means. Modern runs journal
 // `skipped: true`; runs from before that field carry the same decline only in the details prefix
@@ -19,7 +21,7 @@ export const gateDeclined = (data) => data.skipped === true || /^skipped\b/.test
 export const KNOWN_LIMITS = [
     "This packet is a portable snapshot of journaled run facts, not an independent re-verification of the work or its gates.",
     "Judge evidence citations are copied from the journal as the judge recorded them; this packet does not re-validate citations against the judged diff.",
-    "Content hashes bind this packet to the journal bytes used to build it; they do not prove the underlying gates, merges, or tip verification were correct.",
+    "Content hashes bind this packet to the JSON.stringify serialization of parsed journal events used to build it; they do not prove the underlying gates, merges, or tip verification were correct.",
     "Secret-shaped strings are redacted by local pattern matching only; redaction is not a formal security audit.",
     "Producing this packet never contacts a network and never uploads anything.",
 ];
@@ -135,11 +137,13 @@ export function buildProofBundle(runId, events) {
         const judgeCriteria = [];
         for (const g of gateEvents) {
             const gate = typeof g.data.gate === "string" ? g.data.gate : "unknown";
-            // T11: a declined gate never ran — flagged declined, never a pass.
+            // Queue 35 (D-2134 R6): a passing screen remains held until its full suite speaks.
             const declined = gateDeclined(g.data);
-            const pass = g.data.pass === true && !declined;
+            const outcome = normalizeGateOutcome(g.data);
+            const held = outcome.kind === "held";
+            const pass = outcome.kind === "passed" && !declined;
             const details = typeof g.data.details === "string" ? g.data.details : "";
-            gates.push({ gate, pass, ...(declined ? { declined: true } : {}), details });
+            gates.push({ gate, pass, ...(declined ? { declined: true } : {}), ...(held ? { held: true } : {}), details });
             if (gate === "acceptance") {
                 for (const c of parseJudgeCriteria(g.data))
                     judgeCriteria.push(c);
@@ -156,6 +160,7 @@ export function buildProofBundle(runId, events) {
         schemaVersion: BUNDLE_SCHEMA_VERSION,
         runId,
         ...(environment ? { environment } : {}),
+        environments: recordedEnvironments(events),
         contentHashes: {
             journal: journalHash,
             ...(gHash ? { graphDefinitionHash: gHash } : {}),

package/dist/report/compare.d.ts

@@ -8,11 +8,18 @@ export type EnvironmentCompare = {
     comparable: false;
     reason: "mismatch";
     recorded: string;
+    mixedSessions?: true;
 } | {
     comparable: false;
     reason: "unbound";
 };
 export declare function hasRunStart(events: JournalEvent[]): boolean;
+export interface SessionEnvironment {
+    event: "run-start" | "run-resume";
+    ts: string;
+    environment?: RunEnvironment;
+}
+export declare function recordedEnvironments(events: JournalEvent[]): SessionEnvironment[];
 export declare function recordedEnvironment(events: JournalEvent[]): RunEnvironment | undefined;
 export declare function environmentComparable(baselineEnv: RunEnvironment | undefined, currentEnv: RunEnvironment | undefined): EnvironmentCompare;
 export interface RunMetrics {
@@ -21,6 +28,7 @@ export interface RunMetrics {
     gateFail: number;
     gateTotal: number;
     costUsd: number | undefined;
+    costPartial: boolean;
     tokensTotal: number | undefined;
 }
 export declare function runMetrics(events: JournalEvent[], rows?: TelemetryRow[], cost?: CostConfig): RunMetrics;
@@ -28,6 +36,7 @@ export interface RunDelta {
     durationMs: number | undefined;
     gateFail: number;
     costUsd: number | undefined;
+    costPartial: boolean;
     tokensTotal: number | undefined;
 }
 export type CompareOutcome = {

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