humanish 0.104.3 → 0.106.0

package/dist/verify/artifacts.js

@@ -0,0 +1,373 @@
+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 { scanEncodedTextCached } from "../evidence/encoded-text.js";
+import { readPlainText } from "../evidence/plain-text.js";
+import { containsSensitive } from "../evidence/redaction.js";
+import { isLocalEvidenceArtifactPath, isRiskyPublicArtifactPath, validatePreparedRunArtifactPaths, } from "../run/paths.js";
+import { openContainedRegularFile } from "../run/contained-output.js";
+import { readSafeRunArtifactBytes, readSafeRunArtifactJson } from "../run/locate.js";
+import { isRecord } from "../run/type-guards.js";
+import { TERMINAL_EVENTS_ARTIFACT } from "../run/terminal-contract.js";
+import { isZeroEventTerminalTrace } from "./actor.js";
+/** Public-safety and evidence-reference findings stop at this many per list. */
+export const MAX_REPORTED_FINDINGS = 50;
+export async function missingLocalEvidenceArtifacts(runPaths, bundle) {
+    const recordings = new Map(bundle.streams.flatMap((stream) => stream.recording ? [[stream.recording.path, stream.recording]] : []));
+    const requiredPaths = new Map();
+    const addRequiredPath = (artifactPath, options = {}) => {
+        const existing = requiredPaths.get(artifactPath);
+        requiredPaths.set(artifactPath, {
+            screenshot: Boolean(existing?.screenshot || options.screenshot),
+            // Every consumer must permit emptiness: a terminal log cannot exempt the same path when
+            // another stream, screenshot, or adapter also requires it as nonempty evidence.
+            allowEmpty: options.allowEmpty === true && (existing?.allowEmpty ?? true),
+        });
+    };
+    for (const stream of bundle.streams) {
+        // A session that failed before output (or a silent terminal process) has a real zero-record
+        // NDJSON stream. Both the embedded trace and its retained artifact must declare that fact.
+        const emptyTerminalEvents = isZeroEventTerminalTrace(stream.actor) &&
+            isZeroEventTerminalTrace(await readSafeRunArtifactJson(runPaths, stream.artifacts.find((artifact) => artifact.kind === "trace")?.path ?? "actor.json"));
+        for (const artifact of stream.artifacts) {
+            if (isLocalEvidenceArtifactPath(artifact.path)) {
+                addRequiredPath(artifact.path, {
+                    screenshot: artifact.kind === "screenshot",
+                    allowEmpty: artifact.kind === "log" &&
+                        artifact.path === TERMINAL_EVENTS_ARTIFACT &&
+                        emptyTerminalEvents,
+                });
+            }
+        }
+        const embedPath = normalizeLocalEvidenceReference(stream.embed?.kind === "screenshot" ? stream.embed.url : undefined);
+        if (embedPath) {
+            addRequiredPath(embedPath, { screenshot: true });
+        }
+        const uiScreenshotPath = normalizeLocalEvidenceReference(stream.ui?.screenshotUrl);
+        if (uiScreenshotPath) {
+            addRequiredPath(uiScreenshotPath, { screenshot: true });
+        }
+        if (stream.ui?.nestedObserverPath &&
+            isLocalEvidenceArtifactPath(stream.ui.nestedObserverPath)) {
+            addRequiredPath(stream.ui.nestedObserverPath);
+        }
+        for (const reference of declaredActorScreenshotReferences(stream)) {
+            if (isRunRootEvidenceReference(reference.path)) {
+                addRequiredPath(reference.path, { screenshot: true });
+            }
+        }
+    }
+    for (const artifact of bundle.adapterArtifacts ?? []) {
+        if (isLocalEvidenceArtifactPath(artifact.path)) {
+            addRequiredPath(artifact.path, { screenshot: artifact.kind === "screenshot" });
+        }
+    }
+    for (const candidate of bundle.feedbackCandidates ?? []) {
+        for (const evidence of candidate.evidence) {
+            if (isRunRootEvidenceReference(evidence.path)) {
+                addRequiredPath(evidence.path, {
+                    screenshot: evidence.kind === "screenshot",
+                    // Feedback accepts an existing empty nonimage file. The conjunctive merge above
+                    // keeps any stricter stream, actor, or adapter requirement in force.
+                    allowEmpty: evidence.kind !== "screenshot",
+                });
+            }
+        }
+    }
+    const missing = [];
+    for (const [artifactPath, requirements] of requiredPaths) {
+        const recording = recordings.get(artifactPath);
+        if (recording) {
+            const handle = await openContainedRegularFile(runPaths, artifactPath);
+            try {
+                if (!handle || (await handle.stat()).size !== recording.bytes)
+                    missing.push(artifactPath);
+                else {
+                    const header = Buffer.alloc(12);
+                    const read = await handle.read(header, 0, header.length, 0);
+                    if (read.bytesRead !== header.length || header.toString("ascii", 4, 8) !== "ftyp")
+                        missing.push(`${artifactPath} (invalid MP4 header)`);
+                }
+            }
+            finally {
+                await handle?.close();
+            }
+            continue;
+        }
+        const bytes = await readSafeRunArtifactBytes(runPaths, artifactPath);
+        if (!bytes || (bytes.length === 0 && !requirements.allowEmpty)) {
+            missing.push(artifactPath);
+            continue;
+        }
+        if (requirements.screenshot) {
+            const imageError = screenshotEvidenceError(artifactPath, bytes);
+            if (imageError) {
+                missing.push(`${artifactPath} (${imageError})`);
+            }
+        }
+    }
+    return missing;
+}
+function declaredActorScreenshotReferences(stream) {
+    const references = [];
+    for (const field of ["actor", "liveActor"]) {
+        const trace = stream[field];
+        if (!isRecord(trace) || !Array.isArray(trace.items))
+            continue;
+        trace.items.forEach((item, index) => {
+            if (!isRecord(item) || !Object.hasOwn(item, "screenshotRef"))
+                return;
+            references.push({
+                label: `${stream.id} ${field}.items[${index}].screenshotRef`,
+                path: isRecord(item.screenshotRef) ? item.screenshotRef.path : undefined,
+                redaction: isRecord(item.screenshotRef) ? item.screenshotRef.redaction : undefined,
+            });
+        });
+    }
+    return references;
+}
+/**
+ * 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
+ * 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 function streamScreenshotPaths(bundle) {
+    const paths = new Set();
+    for (const stream of bundle.streams) {
+        for (const reference of declaredActorScreenshotReferences(stream)) {
+            if (!isRunRootEvidenceReference(reference.path))
+                continue;
+            const normalized = normalizedFramePath(reference.path);
+            if (isHarnessScreenshotPath(normalized))
+                paths.add(normalized);
+        }
+    }
+    return paths;
+}
+function isHarnessScreenshotPath(normalized) {
+    return normalized.startsWith("screenshots/") && normalized.toLowerCase().endsWith(".png");
+}
+function isRunRootEvidenceReference(value) {
+    return (typeof value === "string" &&
+        isLocalEvidenceArtifactPath(value) &&
+        !path.win32.isAbsolute(value) &&
+        !value.includes("\0") &&
+        !/^[a-z][a-z\d+.-]*:/i.test(value));
+}
+export function invalidRunEvidenceReferences(bundle) {
+    const findings = [];
+    if (path.isAbsolute(bundle.cwd)) {
+        findings.push(`run bundle persists absolute cwd ${bundle.cwd}`);
+    }
+    const adapterArtifactKeys = new Set();
+    for (const artifact of bundle.adapterArtifacts ?? []) {
+        const key = `${artifact.namespace}:${artifact.kind}:${artifact.path}`;
+        if (adapterArtifactKeys.has(key)) {
+            findings.push(`adapter artifact duplicate ${artifact.namespace}:${artifact.kind}:${artifact.path}`);
+        }
+        adapterArtifactKeys.add(key);
+        if (!isLocalEvidenceArtifactPath(artifact.path)) {
+            findings.push(`adapter artifact ${artifact.namespace}:${artifact.kind} nonlocal artifact ${artifact.path}`);
+        }
+    }
+    for (const candidate of bundle.feedbackCandidates ?? []) {
+        for (const evidence of candidate.evidence) {
+            if (!isRunRootEvidenceReference(evidence.path)) {
+                findings.push(`feedback candidate ${candidate.id} nonlocal evidence ${String(evidence.path)}`);
+            }
+        }
+    }
+    for (const stream of bundle.streams) {
+        const seen = new Set();
+        for (const artifact of stream.artifacts) {
+            const key = `${artifact.kind}:${artifact.path}`;
+            if (seen.has(key)) {
+                findings.push(`${stream.id} duplicate artifact ${artifact.kind}:${artifact.path}`);
+            }
+            seen.add(key);
+            if (!isLocalEvidenceArtifactPath(artifact.path)) {
+                findings.push(`${stream.id} nonlocal artifact ${artifact.kind}:${artifact.path}`);
+            }
+        }
+        if (stream.ui?.nestedObserverPath &&
+            !isLocalEvidenceArtifactPath(stream.ui.nestedObserverPath)) {
+            findings.push(`${stream.id} nonlocal nested observer reference ${stream.ui.nestedObserverPath}`);
+        }
+        if (stream.embed?.kind === "screenshot" &&
+            stream.embed.url &&
+            !normalizeLocalEvidenceReference(stream.embed.url)) {
+            findings.push(`${stream.id} nonlocal screenshot embed ${stream.embed.url}`);
+        }
+        if (stream.ui?.screenshotUrl && !normalizeLocalEvidenceReference(stream.ui.screenshotUrl)) {
+            findings.push(`${stream.id} nonlocal screenshot reference ${stream.ui.screenshotUrl}`);
+        }
+        for (const reference of declaredActorScreenshotReferences(stream)) {
+            if (!isRunRootEvidenceReference(reference.path)) {
+                findings.push(`${reference.label} is malformed or nonlocal`);
+            }
+        }
+    }
+    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",
+ * so verify surfaces the posture as a warning in both human and JSON output. Read defensively
+ * for the same reason as noEngagementActorFindings.
+ */
+export function rawScreenshotPostureWarnings(bundle, redactedShapeFrames) {
+    const rawStreamIds = rawScreenshotStreamIds(bundle, redactedShapeFrames);
+    if (rawStreamIds.length === 0) {
+        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.`,
+    ];
+}
+/**
+ * The declared frames, as normalized run-root paths, whose bytes have the redactor's output shape
+ * (isRedactedFrameShape). A frame that is missing or cannot be read is not in the set.
+ */
+export async function redactedShapeFramePaths(runPaths, bundle) {
+    const shaped = new Set();
+    for (const stream of bundle.streams) {
+        for (const reference of declaredActorScreenshotReferences(stream)) {
+            if (!isRunRootEvidenceReference(reference.path))
+                continue;
+            const normalized = normalizedFramePath(reference.path);
+            if (shaped.has(normalized))
+                continue;
+            const bytes = await readSafeRunArtifactBytes(runPaths, normalized).catch(() => null);
+            if (bytes !== null && isRedactedFrameShape(bytes))
+                shaped.add(normalized);
+        }
+    }
+    return shaped;
+}
+function normalizedFramePath(value) {
+    return path.posix.normalize(value.replace(/\\/g, "/"));
+}
+/**
+ * The streams whose frames count as full-fidelity. A frame is redacted only when its bytes have
+ * the redactor's output shape (`redactedShapeFrames`) and either it claims `blurred`, or it has no
+ * claim and the stream's final trace posture is `blurred`: the computer-use loop blurs every frame
+ * of such a trace, and bundles from before per-frame claims carry only the posture. Every other
+ * frame is raw, including `ocr_scrubbed`, which no writer produces. An aggregate raw posture
+ * outranks every frame claim.
+ */
+export function rawScreenshotStreamIds(bundle, redactedShapeFrames) {
+    const rawStreamIds = [];
+    for (const stream of bundle.streams) {
+        const trace = stream.actor;
+        const posture = isRecord(trace) && isRecord(trace.redaction) ? trace.redaction.screenshots : undefined;
+        const frameRaw = declaredActorScreenshotReferences(stream).some((reference) => {
+            const claimed = reference.redaction === "blurred" ||
+                (reference.redaction === undefined && posture === "blurred");
+            return !(claimed &&
+                typeof reference.path === "string" &&
+                redactedShapeFrames.has(normalizedFramePath(reference.path)));
+        });
+        if (posture === "raw" || frameRaw) {
+            rawStreamIds.push(stream.id);
+        }
+    }
+    return rawStreamIds;
+}
+/**
+ * Scans every run file for secret and path patterns and returns the findings. A file that is not
+ * registered stream media and that the scan cannot read as text (readPlainText), or cannot read at
+ * all, goes to `unscanned`, so the caller can keep the run from grading share_ready.
+ */
+export async function scanRunPublicSafetyArtifacts(runPaths, derivedFindings, media, unscanned) {
+    const findings = [];
+    await validatePreparedRunArtifactPaths(runPaths);
+    await scanRunPublicSafetyDirectory(runPaths, "", findings, derivedFindings, media, unscanned);
+    await validatePreparedRunArtifactPaths(runPaths);
+    return findings;
+}
+async function scanRunPublicSafetyDirectory(runPaths, relativeDirectory, findings, derivedFindings, media, unscanned) {
+    // Each authority has its own finding budget. Derived files must never consume
+    // the source scan's budget and make an unscanned recording appear verified.
+    if (findings.length >= MAX_REPORTED_FINDINGS && derivedFindings.length >= MAX_REPORTED_FINDINGS) {
+        return;
+    }
+    const current = relativeDirectory
+        ? path.join(runPaths.physicalRunRoot, ...relativeDirectory.split("/"))
+        : runPaths.physicalRunRoot;
+    const entries = await readdir(current).catch(() => []);
+    for (const entryName of entries) {
+        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))
+            ? derivedFindings
+            : findings;
+        if (isRiskyPublicArtifactPath(relativePath) || containsSensitive(relativePath)) {
+            if (selectedFindings.length < MAX_REPORTED_FINDINGS)
+                selectedFindings.push(`risky artifact path ${relativePath}`);
+        }
+        // Readers map `\` to `/` and would read some other path, and export refuses the name.
+        if (entryName.includes("\\")) {
+            if (selectedFindings.length < MAX_REPORTED_FINDINGS)
+                selectedFindings.push(`unsafe artifact leaf ${relativePath}`);
+            continue;
+        }
+        if (!stats ||
+            stats.isSymbolicLink() ||
+            (!stats.isDirectory() && !stats.isFile()) ||
+            (stats.isFile() && stats.nlink > 1n)) {
+            if (selectedFindings.length < MAX_REPORTED_FINDINGS)
+                selectedFindings.push(`unsafe artifact leaf ${relativePath}`);
+            continue;
+        }
+        if (stats.isDirectory()) {
+            // A directory named analysis.json is not an owned record. Its children
+            // can contain source evidence even after derived findings are saturated.
+            await scanRunPublicSafetyDirectory(runPaths, relativePath, findings, derivedFindings, media, unscanned);
+            continue;
+        }
+        if (selectedFindings.length >= MAX_REPORTED_FINDINGS)
+            continue;
+        if (path.extname(relativePath).toLowerCase() === ".mp4" &&
+            !media.recordingPaths.has(relativePath)) {
+            selectedFindings.push(`unregistered continuous media ${relativePath}`);
+            continue;
+        }
+        // RAW_SCREENSHOTS and CONTINUOUS_MEDIA grade the stream media the bundle registers.
+        if (media.recordingPaths.has(relativePath) || media.screenshotPaths.has(relativePath)) {
+            continue;
+        }
+        // The scan reads a file by its bytes, not its name. A file that is not text, or that could
+        // not be read at all, holds bytes the scan never saw.
+        const bytes = await readSafeRunArtifactBytes(runPaths, relativePath).catch(() => null);
+        const decoded = bytes === null ? undefined : readPlainText(bytes);
+        if (decoded === undefined || !decoded.ok) {
+            unscanned.push(relativePath);
+            continue;
+        }
+        // serve renders observer/index.html from run.json and export regenerates it, so the on-disk
+        // copy reaches neither. It embeds the Observer's own base64 fonts and scripts.
+        const scan = scanEncodedTextCached(decoded.text, {
+            allowOpaqueBase64: relativePath === "observer/index.html",
+        });
+        if (scan.sensitive) {
+            selectedFindings.push(`sensitive text ${relativePath}`);
+        }
+        else if (scan.opaque) {
+            unscanned.push(relativePath);
+        }
+    }
+}
+function normalizeLocalEvidenceReference(value) {
+    if (!value || value.includes("://") || path.isAbsolute(value)) {
+        return null;
+    }
+    const normalized = value.replace(/\\/g, "/");
+    if (normalized.startsWith("../")) {
+        return isLocalEvidenceArtifactPath(normalized.slice(3)) ? normalized.slice(3) : null;
+    }
+    return isLocalEvidenceArtifactPath(normalized) ? normalized : null;
+}

package/dist/verify/costs.d.ts

@@ -0,0 +1,30 @@
+import type { RunBundle } from "../run/bundle.js";
+/** Account lanes must never acquire a price through an aggregate or ambiguous model line. */
+export declare function contradictsAccountBilling(streams: readonly {
+    id?: string;
+    laneId?: string;
+    actor?: {
+        executionProfile?: {
+            billing?: unknown;
+        } | undefined;
+    };
+    liveActor?: {
+        executionProfile?: {
+            billing?: unknown;
+        } | undefined;
+    };
+}[], cost: {
+    fullyEstimated?: unknown;
+    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
+ * ratesAsOf), mirroring the terminal no-spend proof's null-discipline. Account-billed participants
+ * also have their execution profile and provider request receipts checked here.
+ */
+export declare function costAndReceiptFindings(bundle: RunBundle): string[];

package/dist/verify/costs.js

@@ -0,0 +1,129 @@
+// Cost and account-billing checks for verify: every claimed dollar figure carries its provenance,
+// 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. */
+export function contradictsAccountBilling(streams, cost) {
+    const account = (stream) => (stream.liveActor?.executionProfile ?? stream.actor?.executionProfile)?.billing ===
+        "account-unknown";
+    if (!cost || !streams.some(account))
+        return false;
+    if (cost.fullyEstimated === true)
+        return true;
+    if (!Array.isArray(cost.breakdown))
+        return true;
+    return cost.breakdown.some((line) => {
+        if (line?.kind !== "model-tokens" || typeof line.estimatedCostUsd !== "number")
+            return false;
+        const owners = typeof line.laneId === "string"
+            ? streams.filter((s) => s.id === line.laneId || s.laneId === line.laneId)
+            : streams;
+        return owners.length !== 1 || account(owners[0]);
+    });
+}
+/**
+ * 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. Account-billed participants
+ * also have their execution profile and provider request receipts checked here.
+ */
+export function costAndReceiptFindings(bundle) {
+    const findings = [];
+    if (contradictsAccountBilling(bundle.streams, bundle.cost))
+        findings.push("Run cost lines contradict account billing identity");
+    findings.push(...costSummaryFindings(bundle.cost));
+    for (const stream of bundle.streams) {
+        for (const actor of [stream.actor, stream.liveActor]) {
+            findings.push(...executionReceiptFindings(actor));
+        }
+        findings.push(...participantEstimateFindings(stream));
+    }
+    return findings;
+}
+function costSummaryFindings(cost) {
+    const findings = [];
+    if (!cost)
+        return findings;
+    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) {
+        // A spend-free run's explicit zero prices nothing, so only a priced line needs a rates date.
+        if (anyKnown && (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");
+    }
+    return findings;
+}
+/** An account-billed participant's execution profile and provider request receipts. */
+function executionReceiptFindings(actor) {
+    const findings = [];
+    if (actor?.executionProfile === undefined)
+        return findings;
+    if (!validActorExecutionProfile(actor.executionProfile))
+        findings.push("Invalid actor execution profile");
+    if (!validActorProviderRequests(actor.providerRequests))
+        findings.push("Invalid account participant request receipts");
+    if (actor.historyTurnsOmitted !== undefined &&
+        (!Number.isSafeInteger(actor.historyTurnsOmitted) || actor.historyTurnsOmitted < 0))
+        findings.push("Invalid participant history omission count");
+    if (actor.executionProfile?.billing === "account-unknown" &&
+        (typeof actor.estimatedCost?.estimatedCostUsd === "number" ||
+            actor.tokenUsage?.costUsd !== undefined))
+        findings.push("Account participant dollars must remain unknown");
+    return findings;
+}
+function participantEstimateFindings(stream) {
+    const findings = [];
+    const estimate = stream.actor?.estimatedCost;
+    if (!estimate)
+        return findings;
+    const participantLabel = stream.laneId ?? stream.id;
+    if (estimate.schema !== "humanish.actor-estimated-cost.v1") {
+        findings.push(`participant ${participantLabel} 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(`participant ${participantLabel} claims a model-token cost $${estimate.estimatedCostUsd} without a ratesAsOf date`);
+        }
+        if (typeof estimate.source !== "string" || estimate.source.length === 0) {
+            findings.push(`participant ${participantLabel} 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(`participant ${participantLabel} records a null cost estimate without a reason`);
+        }
+        if (estimate.ratesAsOf !== null) {
+            findings.push(`participant ${participantLabel} records a null cost estimate but carries a non-null ratesAsOf`);
+        }
+    }
+    return findings;
+}

package/dist/verify/liveness.d.ts

@@ -0,0 +1,7 @@
+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.
+ */
+export declare function runNotFinishedWarnings(runPaths: PreparedRunArtifactPaths, bundle: RunBundle, nowMs?: number): Promise<string[]>;

package/dist/verify/liveness.js

@@ -0,0 +1,72 @@
+// `humanish verify`'s RUN_NOT_FINISHED warning. Verify checks the integrity of what a run wrote,
+// and a run killed mid-way leaves an in-progress bundle that passes those checks. The warning says
+// what verify saw on disk, so `ok: true` is not read as "the run finished". It never flips `ok`.
+import path from "node:path";
+import { readRunJsonIfExists, readRunTextIfExists } from "../run/locate.js";
+import { isRecord } from "../run/type-guards.js";
+import { RECLAIM_RECEIPT_ARTIFACT } from "../run/reclaim.js";
+import { runLiveness } from "../run/run-index.js";
+import { parseSandboxReceipts, SANDBOX_RECEIPTS_ARTIFACT } from "../run/sandbox-receipts.js";
+import { RUN_STATUS_FILE } from "../run/status.js";
+/** The stable code every RUN_NOT_FINISHED warning starts with. */
+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.
+ */
+export async function runNotFinishedWarnings(runPaths, bundle, nowMs = Date.now()) {
+    const runId = path.basename(runPaths.absoluteRunRoot);
+    const status = await readRunJsonIfExists(runPaths, RUN_STATUS_FILE);
+    const { liveness, record } = runLiveness(runId, status, bundle, nowMs);
+    if (liveness === "finished")
+        return [];
+    const seen = [];
+    if (record === undefined) {
+        const running = bundle.simulations.filter((simulation) => simulation.status === "running");
+        seen.push(`the run has no usable ${RUN_STATUS_FILE} and ${running.length} of ${bundle.simulations.length} simulations are still running`);
+    }
+    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 {
+        seen.push(`${RUN_STATUS_FILE} state is ${record.state} and its owner stopped updating it at ${record.updatedAt}`);
+    }
+    const runningStreams = bundle.streams.filter((stream) => stream.status === "running").length;
+    seen.push(`${runningStreams} of ${bundle.streams.length} streams are still running`);
+    const reclaim = await reclaimState(runPaths, runId);
+    return [
+        `${RUN_NOT_FINISHED}: ${seen.join("; ")}.${reclaim === "" ? "" : ` ${reclaim}`} Verify ok covers the integrity of what was written; it does not mean the run finished.`,
+    ];
+}
+/** What the reclaim receipt says about the sandboxes this run journaled, or what to run. */
+async function reclaimState(runPaths, runId) {
+    const journal = await readRunTextIfExists(runPaths, SANDBOX_RECEIPTS_ARTIFACT);
+    const journaled = new Set((journal === null ? [] : parseSandboxReceipts(journal)).map((receipt) => receipt.sandboxId));
+    const receipt = await readRunJsonIfExists(runPaths, RECLAIM_RECEIPT_ARTIFACT);
+    const outcomes = reclaimOutcomes(receipt, runId);
+    if (outcomes !== undefined) {
+        const gone = outcomes.filter((outcome) => GONE_STATES.has(outcome.state)).length;
+        const reclaimed = new Set(outcomes.map((outcome) => outcome.sandboxId));
+        const missing = [...journaled].filter((id) => !reclaimed.has(id)).length;
+        return `${RECLAIM_RECEIPT_ARTIFACT} records ${gone} of ${outcomes.length} sandboxes gone${missing === 0 ? "" : `, and ${missing} journaled sandboxes are not in it`}.`;
+    }
+    if (journaled.size === 0)
+        return "";
+    return `It has no ${RECLAIM_RECEIPT_ARTIFACT}; \`humanish reclaim --run ${runId}\` stops the ${journaled.size} sandboxes it journaled.`;
+}
+/** The outcomes of a reclaim receipt written for this run, or undefined when there is none. */
+function reclaimOutcomes(receipt, runId) {
+    if (!isRecord(receipt) || receipt.runId !== runId || !Array.isArray(receipt.outcomes))
+        return undefined;
+    const outcomes = [];
+    for (const outcome of receipt.outcomes) {
+        if (!isRecord(outcome))
+            return undefined;
+        const { sandboxId, state } = outcome;
+        if (typeof sandboxId !== "string" || typeof state !== "string")
+            return undefined;
+        outcomes.push({ sandboxId, state });
+    }
+    return outcomes;
+}

package/dist/verify/rerun.d.ts

@@ -0,0 +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. */
+export declare function rerunLineageFindings(bundle: RunBundle): string[];

package/dist/verify/rerun.js

@@ -0,0 +1,46 @@
+/** A rerun bundle must link each selected lane to its prior status and a fan-out rerun event. */
+export function rerunLineageFindings(bundle) {
+    const rerun = bundle.rerun;
+    if (!rerun) {
+        return [];
+    }
+    const findings = [];
+    const selectedIds = rerun.selectedLaneIds;
+    const selectedSet = new Set(selectedIds);
+    const previousIds = rerun.previous.map((entry) => entry.laneId);
+    const previousSet = new Set(previousIds);
+    const currentIds = bundle.streams.map((stream) => stream.laneId);
+    const currentConcreteIds = currentIds.filter((id) => typeof id === "string" && id.trim().length > 0);
+    const currentSet = new Set(currentConcreteIds);
+    if (selectedSet.size !== selectedIds.length) {
+        findings.push("selectedLaneIds contains duplicate participant ids");
+    }
+    if (previousSet.size !== previousIds.length) {
+        findings.push("previous contains duplicate participant ids");
+    }
+    if (currentConcreteIds.length !== bundle.streams.length) {
+        findings.push("every rerun stream must carry a laneId");
+    }
+    for (const id of selectedIds) {
+        if (!previousSet.has(id)) {
+            findings.push(`selected participant ${id} is missing prior status`);
+        }
+        if (!currentSet.has(id)) {
+            findings.push(`selected participant ${id} is missing from current streams`);
+        }
+    }
+    for (const id of previousIds) {
+        if (!selectedSet.has(id)) {
+            findings.push(`previous participant ${id} was not selected`);
+        }
+    }
+    for (const id of currentConcreteIds) {
+        if (!selectedSet.has(id)) {
+            findings.push(`current participant ${id} was not selected`);
+        }
+    }
+    if (!bundle.events.some((event) => event.type === "cua-lab.fanout.rerun")) {
+        findings.push("missing cua-lab.fanout.rerun event");
+    }
+    return findings;
+}