humanish 0.104.3 → 0.106.0

package/dist/run/status.js

@@ -0,0 +1,176 @@
+// Run identity and liveness on disk: one small record per run, written by every backend, that says
+// which lab the run belongs to and whether it is still alive. A reader can list and classify runs
+// from it without parsing every bundle, and can tell a live run from an abandoned one.
+//
+// run.json remains the evidence of record. This file is a derived index and liveness record:
+// `verify` never gates on it, nothing here is a claim about what a participant did, and when the
+// two disagree run.json wins and this file can be rebuilt from it.
+//
+// Public safety: it holds only the run id, the lab id/path/origin (the strings `humanish lab list`
+// prints), the mode, a local pid and timestamps. It holds no hostname or user/path identity: an
+// operator may share the run directory, so a share-safety gate must have nothing to strip here.
+import { writeContainedOutputFile } from "./contained-output.js";
+import { redactText } from "../evidence/redaction.js";
+export const RUN_STATUS_SCHEMA = "humanish.run-status.v1";
+/** The file, relative to the run directory. */
+export const RUN_STATUS_FILE = "status.json";
+/** How often a live run touches `updatedAt`. */
+export const RUN_STATUS_TOUCH_MS = 5_000;
+/**
+ * A `running` record whose `updatedAt` is older than this is INTERRUPTED, not alive: the process
+ * died without finalizing (a dropped SSH, a killed terminal, a crash). Three touch intervals of
+ * slack so an ordinary scheduling hiccup or a slow disk never mislabels a healthy run.
+ */
+export const RUN_STATUS_STALE_MS = RUN_STATUS_TOUCH_MS * 3;
+/** The outcome a finalized status record carries, read from the bundle that was just written. */
+export function runStatusOutcome(bundle) {
+    return {
+        ...(bundle.review?.verdict === undefined ? {} : { verdict: bundle.review.verdict }),
+        ...(bundle.review?.participants === undefined
+            ? {}
+            : {
+                participants: {
+                    total: bundle.review.participants.total,
+                    reachedGoal: bundle.review.participants.reachedGoal,
+                    ...(bundle.review.participants.reportedFriction === undefined
+                        ? {}
+                        : { reportedFriction: bundle.review.participants.reportedFriction }),
+                },
+            }),
+        ...(bundle.cost?.estimatedTotalUsd === undefined
+            ? {}
+            : { estimatedCostUsd: bundle.cost.estimatedTotalUsd }),
+    };
+}
+/**
+ * Start a run's status record and keep it fresh. Fire-and-forget by design: a status write that
+ * fails must never fail the run it describes, so every write swallows its error. The interval is
+ * `unref`'d — this file can never be the reason a process stays alive.
+ */
+export function beginRunStatus(runPaths, options) {
+    const iso = () => new Date().toISOString();
+    const startedAt = iso();
+    const base = {
+        schema: RUN_STATUS_SCHEMA,
+        runId: options.runId,
+        state: "running",
+        mode: options.mode,
+        ...(options.lab === undefined ? {} : { lab: options.lab }),
+        pid: process.pid,
+        startedAt,
+        updatedAt: startedAt,
+    };
+    let finished = false;
+    let finishedRecord;
+    let writing = Promise.resolve();
+    const write = (record) => {
+        // Serialized: two overlapping atomic writes of the same path would be a coin flip over which
+        // record survives, and a `running` record landing after a `finished` one would resurrect it.
+        writing = writing
+            .then(() => writeContainedOutputFile(runPaths, RUN_STATUS_FILE, `${JSON.stringify(record, null, 2)}\n`, "utf8"))
+            .catch(() => {
+            // Deliberately swallowed: the index is a convenience, the bundle is the evidence.
+        });
+        return writing;
+    };
+    const started = write(base);
+    const timer = setInterval(() => {
+        if (finished)
+            return;
+        void write({ ...base, updatedAt: iso() });
+    }, RUN_STATUS_TOUCH_MS);
+    timer.unref?.();
+    const handle = {
+        started,
+        async finish(outcome) {
+            if (finished)
+                return;
+            finished = true;
+            clearInterval(timer);
+            const completedAt = iso();
+            finishedRecord = {
+                ...base,
+                state: "finished",
+                updatedAt: completedAt,
+                completedAt,
+                ...(outcome === undefined ? {} : { outcome }),
+            };
+            await write(finishedRecord);
+        },
+        async settle(result) {
+            if (finishedRecord === undefined)
+                return;
+            // The record is public-safe by construction, so each message passes the shape redaction
+            // again even though the routes scrubbed it.
+            const execution = {
+                succeeded: result.execution.succeeded,
+                failures: result.execution.failures.map((failure) => ({
+                    kind: failure.kind,
+                    message: redactText(failure.message),
+                })),
+            };
+            finishedRecord = {
+                ...finishedRecord,
+                outcome: { ...finishedRecord.outcome, ok: result.ok, execution },
+            };
+            await write(finishedRecord);
+        },
+    };
+    return handle;
+}
+/**
+ * Classify a status record. Pure, so the TUI, the CLI and tests share one definition of "alive".
+ * `nowMs` is passed in rather than read, so a classification is reproducible.
+ */
+export function classifyRunStatus(record, nowMs, staleMs = RUN_STATUS_STALE_MS) {
+    if (record.state === "finished")
+        return "finished";
+    const updated = Date.parse(record.updatedAt);
+    if (!Number.isFinite(updated))
+        return "interrupted";
+    return nowMs - updated <= staleMs ? "running" : "interrupted";
+}
+/** Shape guard for a record read off disk. Unknown extra fields are tolerated (additive contract). */
+export function isRunStatusRecord(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const record = value;
+    if (record.schema !== RUN_STATUS_SCHEMA)
+        return false;
+    if (typeof record.runId !== "string" || record.runId === "")
+        return false;
+    if (record.state !== "running" && record.state !== "finished")
+        return false;
+    if (record.mode !== "dry-run" && record.mode !== "live")
+        return false;
+    if (typeof record.pid !== "number")
+        return false;
+    if (typeof record.startedAt !== "string" || typeof record.updatedAt !== "string")
+        return false;
+    if (record.lab !== undefined) {
+        if (record.lab === null || typeof record.lab !== "object")
+            return false;
+        if (typeof record.lab.id !== "string")
+            return false;
+    }
+    return true;
+}
+/**
+ * The legacy bridge: infer a lab id for a bundle written BEFORE this contract, where the only
+ * attribution was the `lab:<id>` convention on persona/scenario source strings. Deliberately
+ * conservative — it reads the convention and nothing else, and a `lab:` prefix with an empty
+ * remainder is not an id. Ids may contain colons (the removed meta-lab wrote `oss:meta`), so
+ * only the FIRST segment is stripped. Returns undefined when the bundle carries no such marker.
+ */
+export function inferLegacyLabId(bundle) {
+    for (const source of [bundle.persona?.source, bundle.scenario?.source]) {
+        if (typeof source !== "string")
+            continue;
+        if (!source.startsWith("lab:"))
+            continue;
+        const id = source.slice("lab:".length).trim();
+        if (id !== "")
+            return id;
+    }
+    return undefined;
+}

package/dist/run/stored-runs.d.ts

@@ -0,0 +1,38 @@
+import type { E2BDesktopModule } from "../substrates/e2b/sdk.js";
+import { type ReviewSummary, type RunBundle } from "./bundle.js";
+import { type CleanupAdapterResult, type CleanupResult } from "./results.js";
+import { type VerifyResult } from "../verify/verify.js";
+declare const RUNS_SCHEMA = "humanish.runs-result.v1";
+export interface RunCleanupHooks {
+    /** @deprecated Ignored. Stored provider ids are not authority to load or mutate a provider. */
+    loadDesktopModule?: () => Promise<E2BDesktopModule>;
+    cleanupAdapterResources?: (ctx: {
+        cwd: string;
+        runDir: string;
+        bundle: RunBundle;
+    }) => Promise<CleanupAdapterResult[]>;
+    now?: () => Date;
+}
+export interface RunsResult {
+    schema: typeof RUNS_SCHEMA;
+    ok: boolean;
+    cwd: string;
+    runs: Array<{
+        runId: string;
+        createdAt: string | null;
+        mode: string | null;
+        path: string;
+    }>;
+    latest: string | null;
+    error?: {
+        code: "HUMANISH_RUNS_UNAVAILABLE";
+        message: string;
+    };
+}
+export declare function cleanupRun(cwdInput: string, runInput: string, hooks?: RunCleanupHooks): Promise<CleanupResult>;
+export declare function listRuns(cwdInput: string): Promise<RunsResult>;
+export declare function readReview(cwdInput: string, runInput: string): Promise<VerifyResult | (ReviewSummary & {
+    path: string;
+    runId: string;
+})>;
+export {};

package/dist/run/stored-runs.js

@@ -0,0 +1,273 @@
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+import { redactText } from "../evidence/redaction.js";
+import { bindExistingRunArtifactPaths, RUNS_RELATIVE_ROOT, isSafeRunIdSegment, resolveRunsRoot, validatePreparedRunArtifactPaths, } from "./paths.js";
+import { assertPreparedSelectedOutputDirectory, bindExistingManagedHumanishOutputDirectory, prepareContainedOutputFile, readContainedRegularFile, writeContainedOutputFile, } from "./contained-output.js";
+import { RUN_BUNDLE_FILE, PUBLIC_TARGET_CWD, } from "./bundle.js";
+import { CLEANUP_SCHEMA, } from "./results.js";
+import { isReviewSummary, isRunBundle } from "./bundle-shape.js";
+import { readLatest, readRunJsonIfExists, resolveRunPath } from "./locate.js";
+import { withCuaReviewProvenance } from "./outcomes.js";
+import { isNodeError, isRecord } from "./type-guards.js";
+import { invalidRunStorageVerifyResult, verifyResolvedRun, } from "../verify/verify.js";
+const RUNS_SCHEMA = "humanish.runs-result.v1";
+/** A cleanup result that refused before inspecting any resource. */
+function cleanupRefusal(cwd, runInput, checkedAt, error, bundlePath) {
+    return {
+        schema: CLEANUP_SCHEMA,
+        ok: false,
+        cwd,
+        run: runInput,
+        ...(bundlePath === undefined ? {} : { bundlePath }),
+        checkedAt,
+        summary: { resources: 0, killed: 0, alreadyClean: 0, failed: 0, skipped: 0 },
+        resources: [],
+        adapterResults: [],
+        warnings: [],
+        error,
+    };
+}
+/** What the recorded evidence says about one provider resource; nothing is killed from here. */
+function recordedResourceResult(resource) {
+    const base = { provider: resource.provider, kind: resource.kind, id: resource.id };
+    if (resource.provider !== "e2b-desktop" || resource.kind !== "sandbox") {
+        return {
+            ...base,
+            status: "skipped",
+            message: "cleanup only supports e2b-desktop sandbox resources",
+        };
+    }
+    if (resource.status === "killed" || resource.cleanup?.killed === true) {
+        return {
+            ...base,
+            status: "already_clean",
+            message: "resource was already recorded as killed",
+        };
+    }
+    return {
+        ...base,
+        status: "failed",
+        message: "automatic provider cleanup requires a verified resource lease",
+    };
+}
+export async function cleanupRun(cwdInput, runInput, hooks = {}) {
+    const cwd = path.resolve(cwdInput);
+    const checkedAt = (hooks.now ?? (() => new Date()))().toISOString();
+    let resolved;
+    try {
+        resolved = await resolveRunPath(cwd, runInput);
+    }
+    catch {
+        return cleanupRefusal(cwd, runInput, checkedAt, {
+            code: "HUMANISH_INVALID_RUN_BUNDLE",
+            message: "Run storage failed containment validation.",
+        });
+    }
+    if (!resolved) {
+        return cleanupRefusal(cwd, runInput, checkedAt, {
+            code: "HUMANISH_RUN_NOT_FOUND",
+            message: `Run not found: ${runInput}`,
+        });
+    }
+    const runPaths = resolved;
+    const bundlePath = path.join(runPaths.absoluteRunRoot, RUN_BUNDLE_FILE);
+    const cleanupPath = path.join(runPaths.absoluteRunRoot, "cleanup.json");
+    await prepareContainedOutputFile(runPaths, "cleanup.json");
+    const bundleBytes = await readContainedRegularFile(runPaths, RUN_BUNDLE_FILE);
+    let bundle = null;
+    if (bundleBytes) {
+        try {
+            bundle = JSON.parse(bundleBytes.toString("utf8"));
+        }
+        catch {
+            bundle = null;
+        }
+    }
+    if (!isRunBundle(bundle)) {
+        return cleanupRefusal(cwd, runInput, checkedAt, {
+            code: "HUMANISH_INVALID_RUN_BUNDLE",
+            message: "Run bundle failed cleanup shape validation.",
+        }, path.relative(cwd, bundlePath));
+    }
+    const warnings = [];
+    const providerResources = bundle.providerResources ?? [];
+    const resources = providerResources.map(recordedResourceResult);
+    let adapterResults = [];
+    if (hooks.cleanupAdapterResources) {
+        try {
+            adapterResults = await hooks.cleanupAdapterResources({
+                cwd,
+                runDir: runPaths.physicalRunRoot,
+                bundle,
+            });
+        }
+        catch (error) {
+            adapterResults = [
+                {
+                    id: "adapter-cleanup",
+                    ok: false,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            ];
+        }
+        await validatePreparedRunArtifactPaths(runPaths);
+    }
+    if (providerResources.length === 0 && adapterResults.length === 0) {
+        warnings.push("Run bundle recorded no provider resource evidence; nothing to inspect.");
+    }
+    const summary = {
+        resources: resources.length,
+        killed: 0,
+        alreadyClean: resources.filter((resource) => resource.status === "already_clean").length,
+        failed: resources.filter((resource) => resource.status === "failed").length +
+            adapterResults.filter((result) => !result.ok).length,
+        skipped: resources.filter((resource) => resource.status === "skipped").length,
+    };
+    const ok = summary.failed === 0;
+    const result = {
+        schema: CLEANUP_SCHEMA,
+        ok,
+        cwd: PUBLIC_TARGET_CWD,
+        run: runInput,
+        runId: bundle.runId,
+        bundlePath: path.relative(cwd, bundlePath),
+        cleanupPath: path.relative(cwd, cleanupPath),
+        checkedAt,
+        summary,
+        resources,
+        adapterResults,
+        warnings,
+    };
+    await validatePreparedRunArtifactPaths(runPaths);
+    await writeContainedOutputFile(runPaths, "cleanup.json", `${JSON.stringify(result, null, 2)}\n`, "utf8");
+    return result;
+}
+export async function listRuns(cwdInput) {
+    const cwd = path.resolve(cwdInput);
+    const runsRootPath = resolveRunsRoot(cwd);
+    // ENOENT (no .humanish/runs yet) is a normal empty state: ok:true, no runs. Any
+    // other readdir failure (e.g. permission denied) is a real I/O failure and must
+    // not be swallowed into a false "no runs" report.
+    let entries;
+    let runsRoot = null;
+    try {
+        runsRoot = await bindExistingManagedHumanishOutputDirectory(cwd, "runs");
+        entries = runsRoot ? await readdir(runsRoot.physicalPath) : [];
+        if (runsRoot) {
+            await assertPreparedSelectedOutputDirectory(runsRoot);
+        }
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            entries = [];
+        }
+        else {
+            return runsUnavailableResult(cwd, error);
+        }
+    }
+    let latest;
+    try {
+        latest = runsRoot ? await readLatest(runsRoot) : null;
+    }
+    catch (error) {
+        return runsUnavailableResult(cwd, error);
+    }
+    const runs = [];
+    for (const entryName of entries) {
+        if (entryName === "latest.json" || !isSafeRunIdSegment(entryName)) {
+            continue;
+        }
+        const entryPath = path.join(runsRootPath, entryName);
+        const entryStats = await lstat(entryPath, { bigint: true }).catch(() => null);
+        if (!entryStats) {
+            continue;
+        }
+        if (entryStats.isSymbolicLink() ||
+            (!entryStats.isDirectory() && !entryStats.isFile()) ||
+            (entryStats.isFile() && entryStats.nlink > 1n)) {
+            return runsUnavailableResult(cwd, new Error(`Unsafe humanish runs entry: ${entryName}`));
+        }
+        if (!entryStats.isDirectory()) {
+            continue;
+        }
+        let entryRunPaths;
+        try {
+            entryRunPaths = await bindExistingRunArtifactPaths(cwd, entryName);
+        }
+        catch (error) {
+            return runsUnavailableResult(cwd, error);
+        }
+        if (runsRoot && entryRunPaths.physicalRunsRoot !== runsRoot.physicalPath) {
+            return runsUnavailableResult(cwd, new Error("humanish runs root changed physical destination."));
+        }
+        const bundle = await readRunJsonIfExists(entryRunPaths, RUN_BUNDLE_FILE);
+        runs.push({
+            runId: entryName,
+            createdAt: isRecord(bundle) && typeof bundle.createdAt === "string" ? bundle.createdAt : null,
+            mode: isRecord(bundle) && typeof bundle.mode === "string" ? bundle.mode : null,
+            path: path.join(RUNS_RELATIVE_ROOT, entryName),
+        });
+    }
+    if (runsRoot) {
+        try {
+            await assertPreparedSelectedOutputDirectory(runsRoot);
+        }
+        catch (error) {
+            return runsUnavailableResult(cwd, error);
+        }
+    }
+    return {
+        schema: RUNS_SCHEMA,
+        ok: true,
+        cwd,
+        runs: runs.sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? "")),
+        latest: latest?.runId ?? null,
+    };
+}
+function runsUnavailableResult(cwd, error) {
+    return {
+        schema: RUNS_SCHEMA,
+        ok: false,
+        cwd,
+        runs: [],
+        latest: null,
+        error: {
+            code: "HUMANISH_RUNS_UNAVAILABLE",
+            message: redactText(error instanceof Error ? error.message : String(error)),
+        },
+    };
+}
+export async function readReview(cwdInput, runInput) {
+    const cwd = path.resolve(cwdInput);
+    let runPaths;
+    try {
+        runPaths = await resolveRunPath(cwd, runInput);
+    }
+    catch {
+        return invalidRunStorageVerifyResult(cwd, runInput);
+    }
+    const verified = await verifyResolvedRun(cwd, runInput, runPaths);
+    if (!verified.ok || !verified.bundlePath) {
+        return verified;
+    }
+    const review = runPaths ? await readRunJsonIfExists(runPaths, "review.json") : null;
+    if (!isReviewSummary(review)) {
+        return {
+            ...verified,
+            ok: false,
+            error: {
+                code: "HUMANISH_INVALID_RUN_BUNDLE",
+                message: "review.json is missing or invalid.",
+            },
+        };
+    }
+    const bundle = runPaths ? await readRunJsonIfExists(runPaths, RUN_BUNDLE_FILE) : null;
+    const projected = isRecord(bundle) && Array.isArray(bundle.streams)
+        ? withCuaReviewProvenance(review, bundle.streams.filter(isRecord))
+        : review;
+    return {
+        ...projected,
+        path: path.relative(cwd, path.join(runPaths.absoluteRunRoot, "review.json")),
+        runId: path.basename(runPaths.absoluteRunRoot),
+    };
+}

package/dist/run/stream-shape.d.ts

@@ -0,0 +1,4 @@
+import { type RunSimulationStatus, type RunStream, type RunStreamKind } from "./streams.js";
+export declare function isRunStream(value: unknown): value is RunStream;
+export declare function isRunSimulationStatus(value: unknown): value is RunSimulationStatus;
+export declare function isRunStreamKind(value: unknown): value is RunStreamKind;

package/dist/run/stream-shape.js

@@ -0,0 +1,160 @@
+// Shape guards for the streams[] records of run.json and their geometry, recording and artifacts.
+import { desktopRecordingMetadataSchema, } from "../evidence/desktop-recording-types.js";
+import { isLocalEvidenceArtifactPath } from "./paths.js";
+import {} from "./streams.js";
+import { isFiniteNumber, isPositiveFiniteNumber, isRecord } from "./type-guards.js";
+export function isRunStream(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.simId === "string" &&
+        isRunStreamKind(value.kind) &&
+        typeof value.label === "string" &&
+        isRunSimulationStatus(value.status) &&
+        (value.transport === "snapshot" ||
+            value.transport === "polling" ||
+            value.transport === "sse" ||
+            value.transport === "pty" ||
+            value.transport === "app-server") &&
+        typeof value.updatedAt === "string" &&
+        (value.assignment === undefined || isRunParticipantAssignment(value.assignment)) &&
+        (value.viewport === undefined || isRunViewport(value.viewport)) &&
+        (value.desktopGeometry === undefined || isRunDesktopGeometry(value.desktopGeometry)) &&
+        (value.recording === undefined || isRunDesktopRecording(value.recording)) &&
+        hasConsistentStreamGeometry(value) &&
+        Array.isArray(value.artifacts) &&
+        value.artifacts.every(isRunStreamArtifact) &&
+        hasConsistentRecordingArtifact(value.recording, value.artifacts));
+}
+function hasConsistentRecordingArtifact(recording, artifacts) {
+    const files = artifacts.filter((artifact) => artifact.kind === "recording");
+    return recording ? files.length === 1 && files[0].path === recording.path : files.length === 0;
+}
+function isRunDesktopRecording(value) {
+    if (!isRecord(value) ||
+        value.schema !== "humanish.desktop-recording.v1" ||
+        typeof value.path !== "string" ||
+        !isLocalEvidenceArtifactPath(value.path) ||
+        !/^recordings\/[-A-Za-z0-9_.]+\/desktop\.mp4$/.test(value.path))
+        return false;
+    const { schema: _schema, path: _path, ...metadata } = value;
+    return desktopRecordingMetadataSchema.safeParse(metadata).success;
+}
+function isRunParticipantAssignment(value) {
+    return (isRecord(value) &&
+        Object.keys(value).every((key) => key === "mission" || key === "focus" || key === "tasks") &&
+        typeof value.mission === "string" &&
+        (value.focus === undefined || typeof value.focus === "string") &&
+        (value.tasks === undefined ||
+            (Array.isArray(value.tasks) &&
+                value.tasks.every((task) => isRecord(task) &&
+                    Object.keys(task).every((key) => key === "id" || key === "goal") &&
+                    typeof task.id === "string" &&
+                    typeof task.goal === "string"))));
+}
+function isRunViewport(value) {
+    return (isRecord(value) &&
+        isPositiveFiniteNumber(value.width) &&
+        isPositiveFiniteNumber(value.height) &&
+        (value.deviceScaleFactor === undefined || isPositiveFiniteNumber(value.deviceScaleFactor)) &&
+        (value.isMobile === undefined || typeof value.isMobile === "boolean"));
+}
+function isRunDesktopGeometry(value) {
+    if (!isRecord(value) || !isRecord(value.screen) || !isMeasuredSize(value.screen.requested)) {
+        return false;
+    }
+    const verified = value.screen.verified;
+    if (verified !== undefined) {
+        if (!isRecord(verified))
+            return false;
+        const source = verified.source;
+        if (!isMeasuredSize(verified) || source !== "xdpyinfo")
+            return false;
+    }
+    const declared = value.screen.declared;
+    if (declared !== undefined) {
+        if (!isRecord(declared))
+            return false;
+        // read before isMeasuredSize narrows `declared` to {width, height}
+        const preset = declared.preset;
+        if (!isMeasuredSize(declared) || typeof preset !== "string")
+            return false;
+    }
+    const browserWindow = value.browserWindow;
+    if (browserWindow !== undefined &&
+        (!isRecord(browserWindow) ||
+            !isFiniteNumber(browserWindow.x) ||
+            !isFiniteNumber(browserWindow.y) ||
+            !isPositiveFiniteNumber(browserWindow.width) ||
+            !isPositiveFiniteNumber(browserWindow.height) ||
+            (browserWindow.source !== "cdp" &&
+                browserWindow.source !== "xdotool" &&
+                browserWindow.source !== "xwininfo"))) {
+        return false;
+    }
+    const viewport = value.viewport;
+    if (!(viewport === undefined ||
+        (isRecord(viewport) &&
+            isPositiveFiniteNumber(viewport.width) &&
+            isPositiveFiniteNumber(viewport.height) &&
+            isPositiveFiniteNumber(viewport.deviceScaleFactor) &&
+            viewport.source === "cdp")))
+        return false;
+    return (value.warnings === undefined ||
+        (Array.isArray(value.warnings) &&
+            value.warnings.every((warning) => typeof warning === "string" && warning.length > 0)));
+}
+function hasConsistentStreamGeometry(value) {
+    if (value.desktopGeometry === undefined)
+        return true;
+    if (!isRunDesktopGeometry(value.desktopGeometry))
+        return false;
+    const measured = value.desktopGeometry.viewport;
+    if (measured === undefined)
+        return value.viewport === undefined;
+    if (!isRunViewport(value.viewport))
+        return false;
+    return (value.viewport.width === measured.width &&
+        value.viewport.height === measured.height &&
+        value.viewport.deviceScaleFactor === measured.deviceScaleFactor);
+}
+function isMeasuredSize(value) {
+    return (isRecord(value) && isPositiveFiniteNumber(value.width) && isPositiveFiniteNumber(value.height));
+}
+function isRunStreamArtifact(value) {
+    return (isRecord(value) &&
+        typeof value.label === "string" &&
+        typeof value.path === "string" &&
+        (value.kind === "bundle" ||
+            value.kind === "review" ||
+            value.kind === "observer" ||
+            value.kind === "events" ||
+            value.kind === "screenshot" ||
+            value.kind === "trace" ||
+            value.kind === "log" ||
+            value.kind === "filesystem" ||
+            value.kind === "recording"));
+}
+export function isRunSimulationStatus(value) {
+    return (value === "queued" ||
+        value === "preparing" ||
+        value === "running" ||
+        value === "passed" ||
+        // Participant outcomes (docs/principles/three-roles.md). This runtime allowlist is the actual
+        // gate — the TS union alone does not validate a bundle read back from disk.
+        value === "abandoned" ||
+        value === "incomplete" ||
+        value === "complete" ||
+        value === "blocked" ||
+        value === "timed_out" ||
+        value === "failed" ||
+        value === "contract_proof_only");
+}
+export function isRunStreamKind(value) {
+    return (value === "ui" ||
+        value === "browser" ||
+        value === "terminal" ||
+        value === "tui" ||
+        value === "codex-ui" ||
+        value === "artifact" ||
+        value === "summary");
+}