humanish 0.106.1 → 0.108.0

package/dist/verify/actor.d.ts

@@ -2,26 +2,26 @@ import { type PreparedRunArtifactPaths } from "../run/paths.js";
 import { type RunBundle } from "../run/bundle.js";
 export declare function isZeroEventTerminalTrace(value: unknown): boolean;
 /**
- * Verifier for the terminal-product real-agent lane (the in-sandbox command-scoped key route). A
- * LIVE terminal stream must carry the durable proof the safety contract requires, and must FAIL
- * CLOSED when any of it is missing — a blocked/failed agent run stays structurally verifiable (the
- * failure is the evidence) ONLY when the substrate/cleanup/interventions ledgers are present; it
+ * Verifier for the terminal-product real-agent route (the in-sandbox command-scoped key route). A
+ * live terminal stream must carry the durable proof the safety contract requires, and must fail
+ * closed when any of it is missing. A blocked/failed agent run stays structurally verifiable (the
+ * failure is the evidence) only when the substrate/cleanup/interventions ledgers are present; it
  * must never become a hollow pass. Credential-shape leakage across every artifact file is already
- * caught by scanRunPublicSafetyArtifacts; this check enforces the STRUCTURAL evidence + the
+ * caught by scanRunPublicSafetyArtifacts; this check enforces the structural evidence + the
  * proven-teardown invariant. Dry-run/contract bundles are exempt (mode !== live).
  */
 export declare function validateTerminalProductEvidence(runPaths: PreparedRunArtifactPaths, bundle: RunBundle): Promise<string[]>;
 export declare function validateCodexAppServerEvidence(runPaths: PreparedRunArtifactPaths, bundle: RunBundle): Promise<string[]>;
 /**
- * Independent mirror of the producer-side no-engagement guard (routes/computer-use/lanes.ts): a
- * LIVE actor trace claiming goal_satisfied while carrying zero action-bearing items AND zero
- * message items is a hollow run — the actor neither did nor said anything — and must not verify as
- * evidence (invariant 4: evidence verifies fail-closed). Live-vs-dry-run is judged exactly as the
- * producer judges it, from bundle.mode alone; dry-run/contract bundles legitimately carry no
- * actions and stay exempt. Engagement is accepted from EITHER surface — itemized trace items or the
- * producer's counts — because providers differ in what they itemize; a hollow run reports zero on
- * both. The trace is read defensively: isRunStream does not validate the actor seam, and verify
- * must not throw on a malformed one.
+ * Independent mirror of the producer-side no-engagement guard
+ * (routes/computer-use/participant-execution.ts): a live actor trace claiming goal_satisfied while
+ * carrying zero action-bearing items and zero message items is a hollow run (the actor neither did
+ * nor said anything) and must not verify as evidence: evidence verifies fail-closed.
+ * Live-vs-dry-run is judged exactly as the producer judges it, from bundle.mode alone;
+ * dry-run/contract bundles legitimately carry no actions and stay exempt. Engagement is accepted
+ * from either surface (itemized trace items or the producer's counts), because providers differ in
+ * what they itemize; a hollow run reports zero on both. The trace is read defensively: isRunStream
+ * does not validate the actor seam, and verify must not throw on a malformed one.
  */
 export declare function noEngagementActorFindings(bundle: RunBundle): string[];
 export declare function actorVerdictConsistencyFindings(bundle: RunBundle): string[];

package/dist/verify/actor.js

@@ -14,12 +14,12 @@ export function isZeroEventTerminalTrace(value) {
         value.counts.terminalEvents === 0);
 }
 /**
- * Verifier for the terminal-product real-agent lane (the in-sandbox command-scoped key route). A
- * LIVE terminal stream must carry the durable proof the safety contract requires, and must FAIL
- * CLOSED when any of it is missing — a blocked/failed agent run stays structurally verifiable (the
- * failure is the evidence) ONLY when the substrate/cleanup/interventions ledgers are present; it
+ * Verifier for the terminal-product real-agent route (the in-sandbox command-scoped key route). A
+ * live terminal stream must carry the durable proof the safety contract requires, and must fail
+ * closed when any of it is missing. A blocked/failed agent run stays structurally verifiable (the
+ * failure is the evidence) only when the substrate/cleanup/interventions ledgers are present; it
  * must never become a hollow pass. Credential-shape leakage across every artifact file is already
- * caught by scanRunPublicSafetyArtifacts; this check enforces the STRUCTURAL evidence + the
+ * caught by scanRunPublicSafetyArtifacts; this check enforces the structural evidence + the
  * proven-teardown invariant. Dry-run/contract bundles are exempt (mode !== live).
  */
 export async function validateTerminalProductEvidence(runPaths, bundle) {
@@ -27,20 +27,20 @@ export async function validateTerminalProductEvidence(runPaths, bundle) {
         return [];
     }
     const findings = [];
-    // Detect the terminal-PRODUCT lane by its unique actor-trace protocol ("terminal-exec"), NOT by
-    // the broad stream.kind "terminal" — the existing local codex-exec/TUI lanes also use terminal
-    // streams (with a different protocol) and must not be held to this lane's ledger contract.
+    // Detect the terminal-product route by its unique actor-trace protocol ("terminal-exec") instead of
+    // the broad stream.kind "terminal": the existing local codex-exec/TUI routes also use terminal
+    // streams (with a different protocol) and must not be held to this route's ledger contract.
     const terminalStreams = bundle.streams.filter((stream) => stream.actor?.protocol === "terminal-exec" && stream.status !== "contract_proof_only");
     if (terminalStreams.length === 0) {
         return findings;
     }
-    // The lane writes exactly one terminal run's ledgers/evidence at fixed paths in the run root.
+    // The route writes exactly one terminal run's ledgers/evidence at fixed paths in the run root.
     const ledgers = await readSafeRunArtifactJson(runPaths, TERMINAL_LEDGERS_ARTIFACT);
     if (!isRecord(ledgers) || ledgers.schema !== "humanish.terminal-ledgers.v1") {
         findings.push(`missing or malformed ${TERMINAL_LEDGERS_ARTIFACT} (humanish.terminal-ledgers.v1)`);
         return findings;
     }
-    // Substrate lifecycle ledger: must record at least sandbox creation AND teardown.
+    // Substrate lifecycle ledger: must record at least sandbox creation and teardown.
     const lifecycle = Array.isArray(ledgers.lifecycle) ? ledgers.lifecycle : [];
     if (lifecycle.length === 0) {
         findings.push("substrate lifecycle ledger is empty (expected create -> ready -> exec -> cleanup events)");
@@ -50,25 +50,25 @@ export async function validateTerminalProductEvidence(runPaths, bundle) {
     if (!Array.isArray(ledgers.commandLog)) {
         findings.push("command log ledger is missing or not an array");
     }
-    // Interventions ledger: must be PRESENT (an array). Empty is valid and expected (stdin disabled,
-    // no assisted-input path) — but absent fails, so an assisted run can never masquerade as one
+    // Interventions ledger: must be present (an array). Empty is valid and expected (stdin disabled,
+    // no assisted-input path), but absent fails, so an assisted run can never masquerade as one
     // without an interventions record.
     if (!Array.isArray(ledgers.interventions)) {
         findings.push("interventions ledger is missing (an empty array is required-present, not optional)");
     }
-    // Cleanup proof: the sandbox must be killed and proven reclaimed BY EXACT ID (remaining===0).
+    // Cleanup proof: the sandbox must be killed and proven reclaimed by exact ID (remaining===0).
     // humanish never calls Sandbox.list to derive this field; a live run that cannot prove teardown
     // fails closed (remaining===1 still-present-unconfirmed, remaining===-1 kill(id) itself
-    // failed -- the server-side kill-on-timeout is the backstop for both).
+    // failed; the server-side kill-on-timeout is the backstop for both).
     const cleanup = isRecord(ledgers.cleanup) ? ledgers.cleanup : undefined;
     if (!cleanup) {
         findings.push("cleanup proof is missing");
     }
     else if (cleanup.killed !== true || cleanup.remaining !== 0) {
-        findings.push(`cleanup not proven by id (killed=${String(cleanup.killed)}, remaining=${String(cleanup.remaining)}); a run that cannot prove sandbox teardown fails closed`);
+        findings.push(`sandbox cleanup is not proven by id (killed=${String(cleanup.killed)}, remaining=${String(cleanup.remaining)}), so the run cannot pass`);
     }
-    // The redacted exec-stream + normalized transcript artifacts must be WRITTEN (the producer
-    // always writes them on the live path, even empty for a no-output blocked run — so absence is a
+    // The redacted exec-stream + normalized transcript artifacts must be written (the producer
+    // always writes them on the live path, even empty for a no-output blocked run, so absence is a
     // real evidence gap, while emptiness is legitimate and keeps blocked runs verifiable).
     if (!(await readSafeRunArtifactBytes(runPaths, TERMINAL_EVENTS_ARTIFACT))) {
         findings.push(`missing terminal event stream artifact (${TERMINAL_EVENTS_ARTIFACT})`);
@@ -76,7 +76,7 @@ export async function validateTerminalProductEvidence(runPaths, bundle) {
     if (!(await readSafeRunArtifactBytes(runPaths, TERMINAL_TRANSCRIPT_ARTIFACT))) {
         findings.push(`missing normalized terminal transcript artifact (${TERMINAL_TRANSCRIPT_ARTIFACT})`);
     }
-    // The provider-neutral actor trace must be on the terminal lane with redaction passed.
+    // The provider-neutral actor trace must have `lane: "terminal"` with redaction passed.
     for (const stream of terminalStreams) {
         const traceArtifact = stream.artifacts.find((artifact) => artifact.kind === "trace");
         const tracePath = traceArtifact?.path ?? "actor.json";
@@ -94,19 +94,19 @@ export async function validateTerminalProductEvidence(runPaths, bundle) {
     return findings;
 }
 /**
- * Verifier for the terminal cost ledger and no-spend proof. A LIVE terminal-product bundle MUST
- * carry both (fail closed if absent on a live run). The load-bearing honesty check: the no-spend
- * proof may NOT claim zero on a line the ledger marks `null`
- * (UNMEASURED) — a proof can never claim more than the ledger measured. And the observed KNOWN
- * spend may not exceed the declared cap (the proof's own maxUsd) — fail-closed, not advisory.
- * The null discipline is enforced here too: a present line's `usd` must be a number OR literally
+ * Verifier for the terminal cost ledger and no-spend proof. A live terminal-product bundle must
+ * carry both (fail closed if absent on a live run). The main check: the no-spend
+ * proof may not claim zero on a line the ledger marks `null`
+ * (unmeasured): a proof can never claim more than the ledger measured. And the observed known
+ * spend may not exceed the declared cap (the proof's own maxUsd): fail-closed, not advisory.
+ * The null discipline is enforced here too: a present line's `usd` must be a number or literally
  * null (never undefined/omitted), so "not measured" can never be silently dropped.
  */
 function validateTerminalCostEvidence(ledgers) {
     const findings = [];
     const cost = isRecord(ledgers.cost) ? ledgers.cost : undefined;
     if (!cost || cost.schema !== "humanish.terminal-cost-ledger.v1") {
-        findings.push("missing or malformed cost ledger (humanish.terminal-cost-ledger.v1) — a live terminal-product run must derive a cost ledger");
+        findings.push("missing or malformed cost ledger (humanish.terminal-cost-ledger.v1): a live terminal-product run must record one");
         return findings;
     }
     const lines = isRecord(cost.lines) ? cost.lines : undefined;
@@ -114,8 +114,8 @@ function validateTerminalCostEvidence(ledgers) {
         findings.push("cost ledger has no lines block");
         return findings;
     }
-    // The null discipline: every applicable category line must be PRESENT with `usd` as a number or
-    // literally null. `undefined`/omitted is forbidden — that would silently lose the "not measured"
+    // The null discipline: every applicable category line must be present with `usd` as a number or
+    // literally null. `undefined`/omitted is forbidden because it would silently lose the "not measured"
     // distinction. Track which categories the ledger marks null so the no-spend proof cannot lie about them.
     const nullCategories = new Set();
     for (const category of COST_CATEGORIES) {
@@ -136,28 +136,28 @@ function validateTerminalCostEvidence(ledgers) {
     }
     const proof = isRecord(ledgers.noSpendProof) ? ledgers.noSpendProof : undefined;
     if (!proof || proof.schema !== "humanish.terminal-no-spend-proof.v1") {
-        findings.push("missing or malformed no-spend proof (humanish.terminal-no-spend-proof.v1) — the no-spend proof must be derived from the ledger");
+        findings.push("missing or malformed no-spend proof (humanish.terminal-no-spend-proof.v1): a live terminal-product run must derive one from its cost ledger");
         return findings;
     }
-    // HONESTY CHECK: the no-spend proof must NOT claim zero on a line the ledger marks `null`. A
+    // Claim check: the no-spend proof must not claim zero on a line the ledger marks `null`. A
     // knownZeroLines entry that is actually unmeasured in the ledger means the proof claimed more than
-    // it measured — fail closed.
+    // it measured, so it fails closed.
     const knownZeroLines = Array.isArray(proof.knownZeroLines) ? proof.knownZeroLines : [];
     for (const category of knownZeroLines) {
         if (nullCategories.has(String(category))) {
-            findings.push(`no-spend proof claims zero on line "${String(category)}" but the cost ledger marks it null (UNMEASURED); a proof may not claim zero on a line it did not measure`);
+            findings.push(`the no-spend proof claims zero on line "${String(category)}", but the cost ledger marks that line unmeasured (null), and a proof may not claim zero for a line it did not measure`);
         }
     }
-    // FAIL-CLOSED CAP: observed KNOWN spend may not exceed the declared cap (the proof's maxUsd). The
+    // Fail-closed cap: observed known spend may not exceed the declared cap (the proof's maxUsd). The
     // ledger's knownTotalUsd is the measured spend; null lines do not count toward it (and the proof
     // reports them as unmeasured). A satisfied proof whose known total exceeds its cap is contradictory.
     const knownTotalUsd = typeof cost.knownTotalUsd === "number" ? cost.knownTotalUsd : Number.NaN;
     const maxUsd = typeof proof.maxUsd === "number" ? proof.maxUsd : null;
     if (maxUsd !== null && Number.isFinite(knownTotalUsd) && knownTotalUsd > maxUsd) {
-        findings.push(`observed KNOWN spend ${knownTotalUsd} USD exceeds the declared cap maxUsd=${maxUsd}; the run must fail closed, not verify green`);
+        findings.push(`measured spend ${knownTotalUsd} USD is over the declared cap maxUsd=${maxUsd}, so the run cannot pass verification`);
     }
     // A proof that asserts `satisfied:true` while a known line is non-zero (knownNonZeroLines) is
-    // self-contradictory — reject it (the proof's own derived state must be internally consistent).
+    // self-contradictory; reject it (the proof's own derived state must be internally consistent).
     const knownNonZeroLines = Array.isArray(proof.knownNonZeroLines) ? proof.knownNonZeroLines : [];
     if (proof.satisfied === true && knownNonZeroLines.length > 0) {
         findings.push(`no-spend proof claims satisfied:true but reports known non-zero spend lines (${knownNonZeroLines.map(String).join(", ")})`);
@@ -205,7 +205,7 @@ export async function validateCodexAppServerEvidence(runPaths, bundle) {
     }
     return findings;
 }
-// Trace item kinds that show the actor DID something (drove UI, ran a command, called a tool,
+// Trace item kinds that show the actor did something (drove UI, ran a command, called a tool,
 // changed a file). reasoning/screenshot/plan/notice items are observation, not engagement.
 const ACTION_BEARING_ACTOR_ITEM_KINDS = new Set([
     "ui_action",
@@ -214,15 +214,15 @@ const ACTION_BEARING_ACTOR_ITEM_KINDS = new Set([
     "file_change",
 ]);
 /**
- * Independent mirror of the producer-side no-engagement guard (routes/computer-use/lanes.ts): a
- * LIVE actor trace claiming goal_satisfied while carrying zero action-bearing items AND zero
- * message items is a hollow run — the actor neither did nor said anything — and must not verify as
- * evidence (invariant 4: evidence verifies fail-closed). Live-vs-dry-run is judged exactly as the
- * producer judges it, from bundle.mode alone; dry-run/contract bundles legitimately carry no
- * actions and stay exempt. Engagement is accepted from EITHER surface — itemized trace items or the
- * producer's counts — because providers differ in what they itemize; a hollow run reports zero on
- * both. The trace is read defensively: isRunStream does not validate the actor seam, and verify
- * must not throw on a malformed one.
+ * Independent mirror of the producer-side no-engagement guard
+ * (routes/computer-use/participant-execution.ts): a live actor trace claiming goal_satisfied while
+ * carrying zero action-bearing items and zero message items is a hollow run (the actor neither did
+ * nor said anything) and must not verify as evidence: evidence verifies fail-closed.
+ * Live-vs-dry-run is judged exactly as the producer judges it, from bundle.mode alone;
+ * dry-run/contract bundles legitimately carry no actions and stay exempt. Engagement is accepted
+ * from either surface (itemized trace items or the producer's counts), because providers differ in
+ * what they itemize; a hollow run reports zero on both. The trace is read defensively: isRunStream
+ * does not validate the actor seam, and verify must not throw on a malformed one.
  */
 export function noEngagementActorFindings(bundle) {
     if (bundle.mode !== "live") {
@@ -264,7 +264,7 @@ function hasStopWhenObservationEvidence(items, screenshotCount) {
             item.screenshotRef.path.length > 0);
     if (!hasScreenshot)
         return false;
-    // A matched stopWhen, or a declared dwell window that ended the session (#510): both are
+    // A matched stopWhen, or a declared dwell window that ended the session: both are
     // structured, harness-owned completion, with frames behind them.
     return items.some((item) => isRecord(item) &&
         item.kind === "notice" &&

package/dist/verify/artifacts.d.ts

@@ -6,15 +6,15 @@ export declare function missingLocalEvidenceArtifacts(runPaths: PreparedRunArtif
 /**
  * The PNG frames that actor traces register as stream screenshots, relative to the run root.
  * RAW_SCREENSHOTS grades these, so the public-safety scan does not report them as unread. Only
- * frames under screenshots/ count: the computer-use lane writer and the scripted-browser steps
+ * frames under screenshots/ count: the computer-use frame writer and the scripted-browser steps
  * write every frame there, and nothing else in the harness does. A trace reference elsewhere (an
  * adapter's PNG, say) stays required evidence but goes to UNSCANNED_ARTIFACT.
  */
 export declare function streamScreenshotPaths(bundle: RunBundle): Set<string>;
 export declare function invalidRunEvidenceReferences(bundle: RunBundle): string[];
 /**
- * redaction.screenshots: "raw" is the SUPPORTED local default (full-fidelity frames in
- * gitignored .humanish), not a verify failure — but ok: true must never read as "share-ready",
+ * redaction.screenshots: "raw" is the supported local default (full-fidelity frames in
+ * gitignored .humanish), not a verify failure, but ok: true must never read as "share-ready",
  * so verify surfaces the posture as a warning in both human and JSON output. Read defensively
  * for the same reason as noEngagementActorFindings.
  */

package/dist/verify/artifacts.js

@@ -1,7 +1,7 @@
 import { lstat, readdir } from "node:fs/promises";
 import path from "node:path";
 import { isRedactedFrameShape, screenshotEvidenceError } from "../evidence/image.js";
-import { isStudyAnalysisRecordPath } from "../analysis/sharing.js";
+import { isAnalysisRecordPath } from "../analysis/sharing.js";
 import { scanEncodedTextCached } from "../evidence/encoded-text.js";
 import { readPlainText } from "../evidence/plain-text.js";
 import { containsSensitive } from "../evidence/redaction.js";
@@ -130,7 +130,7 @@ function declaredActorScreenshotReferences(stream) {
 /**
  * The PNG frames that actor traces register as stream screenshots, relative to the run root.
  * RAW_SCREENSHOTS grades these, so the public-safety scan does not report them as unread. Only
- * frames under screenshots/ count: the computer-use lane writer and the scripted-browser steps
+ * frames under screenshots/ count: the computer-use frame writer and the scripted-browser steps
  * write every frame there, and nothing else in the harness does. A trace reference elsewhere (an
  * adapter's PNG, say) stays required evidence but goes to UNSCANNED_ARTIFACT.
  */
@@ -213,8 +213,8 @@ export function invalidRunEvidenceReferences(bundle) {
     return findings.slice(0, MAX_REPORTED_FINDINGS);
 }
 /**
- * redaction.screenshots: "raw" is the SUPPORTED local default (full-fidelity frames in
- * gitignored .humanish), not a verify failure — but ok: true must never read as "share-ready",
+ * redaction.screenshots: "raw" is the supported local default (full-fidelity frames in
+ * gitignored .humanish), not a verify failure, but ok: true must never read as "share-ready",
  * so verify surfaces the posture as a warning in both human and JSON output. Read defensively
  * for the same reason as noEngagementActorFindings.
  */
@@ -224,7 +224,7 @@ export function rawScreenshotPostureWarnings(bundle, redactedShapeFrames) {
         return [];
     }
     return [
-        `Screenshots are FULL-FIDELITY (raw) or carry no redaction claim on ${rawStreamIds.join(", ")} — supported for local use, NOT publish-safe as-is. Verify ok does not mean share-ready; set policies.redactScreenshots: true to blur a share-as-is bundle.`,
+        `Screenshots on ${rawStreamIds.join(", ")} are unblurred, or do not say whether they were blurred. That is fine for local use, but the bundle is not safe to publish as it is: verify ok does not mean share-ready. Set policies.redactScreenshots: true to blur screenshots in a bundle you plan to share.`,
     ];
 }
 /**
@@ -302,7 +302,7 @@ async function scanRunPublicSafetyDirectory(runPaths, relativeDirectory, finding
         const relativePath = relativeDirectory ? `${relativeDirectory}/${entryName}` : entryName;
         const stats = await lstat(path.join(current, entryName), { bigint: true }).catch(() => null);
         const selectedFindings = !stats?.isDirectory() &&
-            (relativePath === "observer/study-analysis.json" || isStudyAnalysisRecordPath(relativePath))
+            (relativePath === "observer/study-analysis.json" || isAnalysisRecordPath(relativePath))
             ? derivedFindings
             : findings;
         if (isRiskyPublicArtifactPath(relativePath) || containsSensitive(relativePath)) {

package/dist/verify/context-growth.d.ts

@@ -0,0 +1,9 @@
+import type { RunBundle } from "../run/bundle.js";
+/**
+ * The median prompt of the last three turns over that of turns 2 to 4, from a trace's
+ * `tokenUsage.turns`. Turn 1 is left out: it carries the instructions alone. Undefined when fewer
+ * than six turns report their input.
+ */
+export declare function contextGrowth(turns: readonly unknown[]): number | undefined;
+/** One warning per live participant whose prompt stayed the same size from turn 2 on. */
+export declare function flatContextWarnings(bundle: RunBundle): string[];

package/dist/verify/context-growth.js

@@ -0,0 +1,62 @@
+import { ACTOR_TRACE_SCHEMA } from "../actors/contract.js";
+import { isRecord } from "../run/type-guards.js";
+/** Fewer turns with usage than this say nothing about whether the prompt grew. */
+const MIN_TURNS = 6;
+/**
+ * A participant that remembers sends a longer prompt each turn: every turn adds a screenshot and a
+ * reply. Over 113 participant traces from live runs (OpenAI computer-use, the Codex participant and
+ * the Claude session), the median prompt of the last three turns was at least 1.21 times that of
+ * turns 2 to 4. A participant that carries only its last turn stays flat: about 3,100 tokens from
+ * turn 2 to turn 527 in one zero-data-retention run, a ratio near 1.0.
+ */
+const MIN_GROWTH = 1.1;
+/**
+ * The whole prompt one turn sent. `input` includes the cached parts, except in Claude session
+ * traces written before that was fixed, which recorded the uncached part alone; there the cached
+ * parts are larger than `input`, and the three are added.
+ */
+function promptTokens(turn) {
+    if (!isRecord(turn) || typeof turn.input !== "number")
+        return undefined;
+    const cached = typeof turn.cachedInput === "number" ? turn.cachedInput : 0;
+    const written = typeof turn.cacheWriteInput === "number" ? turn.cacheWriteInput : 0;
+    return cached + written > turn.input ? turn.input + cached + written : turn.input;
+}
+function median(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+/**
+ * The median prompt of the last three turns over that of turns 2 to 4, from a trace's
+ * `tokenUsage.turns`. Turn 1 is left out: it carries the instructions alone. Undefined when fewer
+ * than six turns report their input.
+ */
+export function contextGrowth(turns) {
+    const sizes = turns.map(promptTokens);
+    if (sizes.length < MIN_TURNS || sizes.some((size) => size === undefined))
+        return undefined;
+    const later = sizes.slice(1);
+    const early = median(later.slice(0, 3));
+    return early > 0 ? median(later.slice(-3)) / early : undefined;
+}
+/** One warning per live participant whose prompt stayed the same size from turn 2 on. */
+export function flatContextWarnings(bundle) {
+    if (bundle.mode !== "live")
+        return [];
+    const warnings = [];
+    for (const stream of bundle.streams) {
+        const trace = stream.actor;
+        if (!isRecord(trace) || trace.schema !== ACTOR_TRACE_SCHEMA)
+            continue;
+        const turns = isRecord(trace.tokenUsage) ? trace.tokenUsage.turns : undefined;
+        if (!Array.isArray(turns))
+            continue;
+        const growth = contextGrowth(turns);
+        if (growth === undefined || growth >= MIN_GROWTH)
+            continue;
+        const near = Math.round(median(turns.slice(1).map((turn) => promptTokens(turn))));
+        warnings.push(`${stream.id}: its context did not grow. Its prompt stayed near ${near} tokens from turn 2 to turn ${turns.length}, so it likely answered each turn without the earlier ones.`);
+    }
+    return warnings;
+}

package/dist/verify/costs.d.ts

@@ -1,5 +1,5 @@
 import type { RunBundle } from "../run/bundle.js";
-/** Account lanes must never acquire a price through an aggregate or ambiguous model line. */
+/** Account-billed participants must never acquire a price through an aggregate or ambiguous model line. */
 export declare function contradictsAccountBilling(streams: readonly {
     id?: string;
     laneId?: string;
@@ -18,12 +18,12 @@ export declare function contradictsAccountBilling(streams: readonly {
     breakdown?: unknown;
 } | undefined): boolean;
 /**
- * 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
+ * Verify the labeling/provenance of any cost figure a bundle claims, and never its magnitude. Returns
+ * [] (pass) unless a dollar claim lacks its provenance or a total misreports its
+ * known lines. Absence always passes (fail-open on display): a bundle with no cost,
+ * a null estimate, or a participant 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 (a reason + null
  * ratesAsOf), mirroring the terminal no-spend proof's null-discipline. Account-billed participants
  * also have their execution profile and provider request receipts checked here.
  */

package/dist/verify/costs.js

@@ -2,7 +2,7 @@
 // totals match their known lines, and account-billed participants never acquire a price.
 import { validActorExecutionProfile, validActorProviderRequests } from "../actors/contract.js";
 import { round6 } from "../run/pricing.js";
-/** Account lanes must never acquire a price through an aggregate or ambiguous model line. */
+/** Account-billed participants must never acquire a price through an aggregate or ambiguous model line. */
 export function contradictsAccountBilling(streams, cost) {
     const account = (stream) => (stream.liveActor?.executionProfile ?? stream.actor?.executionProfile)?.billing ===
         "account-unknown";
@@ -22,12 +22,12 @@ export function contradictsAccountBilling(streams, cost) {
     });
 }
 /**
- * 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
+ * Verify the labeling/provenance of any cost figure a bundle claims, and never its magnitude. Returns
+ * [] (pass) unless a dollar claim lacks its provenance or a total misreports its
+ * known lines. Absence always passes (fail-open on display): a bundle with no cost,
+ * a null estimate, or a participant 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 (a reason + null
  * ratesAsOf), mirroring the terminal no-spend proof's null-discipline. Account-billed participants
  * also have their execution profile and provider request receipts checked here.
  */
@@ -76,7 +76,7 @@ function costSummaryFindings(cost) {
         }
     }
     else if (anyKnown) {
-        // Every-line-null is the only honest null total; a null total beside a known line hides spend.
+        // Every-line-null is the only valid 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");
     }
     return findings;
@@ -117,7 +117,7 @@ function participantEstimateFindings(stream) {
         }
     }
     else {
-        // Declared-absent honesty (invariant 5): a null estimate must say WHY and carry null ratesAsOf.
+        // Declared absence: a null estimate must say why and carry null ratesAsOf.
         if (estimate.reason === undefined) {
             findings.push(`participant ${participantLabel} records a null cost estimate without a reason`);
         }

package/dist/verify/liveness.d.ts

@@ -2,6 +2,6 @@ import type { RunBundle } from "../run/bundle.js";
 import type { PreparedRunArtifactPaths } from "../run/paths.js";
 /**
  * One warning when the run is not finished, by the run index's rule: its status record when it
- * has a usable one, else a simulation still `running` in its bundle. Empty for a finished run.
+ * has a usable one, else a participant still `running` in its bundle's `simulations[]`. Empty for a finished run.
  */
 export declare function runNotFinishedWarnings(runPaths: PreparedRunArtifactPaths, bundle: RunBundle, nowMs?: number): Promise<string[]>;

package/dist/verify/liveness.js

@@ -13,7 +13,7 @@ const RUN_NOT_FINISHED = "RUN_NOT_FINISHED";
 const GONE_STATES = new Set(["killed", "already-gone"]);
 /**
  * One warning when the run is not finished, by the run index's rule: its status record when it
- * has a usable one, else a simulation still `running` in its bundle. Empty for a finished run.
+ * has a usable one, else a participant still `running` in its bundle's `simulations[]`. Empty for a finished run.
  */
 export async function runNotFinishedWarnings(runPaths, bundle, nowMs = Date.now()) {
     const runId = path.basename(runPaths.absoluteRunRoot);
@@ -29,6 +29,9 @@ export async function runNotFinishedWarnings(runPaths, bundle, nowMs = Date.now(
     else if (liveness === "running") {
         seen.push(`${RUN_STATUS_FILE} state is ${record.state} and its owner updated it at ${record.updatedAt}, so the run may still be writing`);
     }
+    else if (record.state === "interrupted") {
+        seen.push(`${RUN_STATUS_FILE} state is interrupted${record.signal === undefined ? "" : ` by ${record.signal}`} at ${record.updatedAt}`);
+    }
     else {
         seen.push(`${RUN_STATUS_FILE} state is ${record.state} and its owner stopped updating it at ${record.updatedAt}`);
     }

package/dist/verify/rerun.d.ts

@@ -1,3 +1,3 @@
 import type { RunBundle } from "../run/bundle.js";
-/** A rerun bundle must link each selected lane to its prior status and a fan-out rerun event. */
+/** A rerun bundle must link each selected participant to its prior status and a fan-out rerun event. */
 export declare function rerunLineageFindings(bundle: RunBundle): string[];

package/dist/verify/rerun.js

@@ -1,4 +1,4 @@
-/** A rerun bundle must link each selected lane to its prior status and a fan-out rerun event. */
+/** A rerun bundle must link each selected participant to its prior status and a fan-out rerun event. */
 export function rerunLineageFindings(bundle) {
     const rerun = bundle.rerun;
     if (!rerun) {

package/dist/verify/shared-world-concurrent.d.ts

@@ -1,8 +1,8 @@
 import type { RunBundle } from "../run/bundle.js";
 import { type SharedWorldEvidence } from "../run/shared-world-evidence.js";
 /**
- * CONCURRENT branch: N personas drove ONE getHost-exposed plane at once. Verify fail-closed: the
- * shape (laneWindows + stateSeries + outcomes, NO timeline); the required and forbidden
+ * Concurrent branch: N personas drove one getHost-exposed plane at once. Verify fail-closed: the
+ * shape (laneWindows + stateSeries + outcomes, no timeline); the required and forbidden
  * attributionLimits; the harness-minted getHost target every actor drove; the synthetic-subject
  * provenance gate; digest-only state series with the allowed-keys tripwire; single-plane
  * provenance; and the concurrency-on-pass gate (genuine overlap and a state delta at or after an