humanish 0.0.1 → 0.15.1

package/dist/run.js

@@ -0,0 +1,4844 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+// The deterministic browser-persona driver lives in the scripted-browser-actor leaf module
+// (moved there so the actor registry can reuse it without a run.ts import cycle). This file
+// keeps the `run --app-url` orchestration; behavior is byte-identical.
+import { browserSurfaces, builtinBrowserPersonaJourney, captureBrowserSurface, normalizeLocalAppUrl, parseBrowserPersonaJourneyFromScenario, resolveBrowserCommand } from "./scripted-browser-actor.js";
+import { CODEX_APP_SERVER_TRACE_SCHEMA, runCodexAppServerSessionInPreparedRoot } from "./codex-app-server.js";
+import { getActor } from "./actor-registry.js";
+import { artifactReferenceIfWritten, hasWrittenScreenshot } from "./artifact-reference.js";
+import { ACTOR_TRACE_SCHEMA } from "./actor-contract.js";
+import { captureGitState, GIT_STATE_SCHEMA } from "./core/git-state.js";
+import { inspectVerifiedGitWorkspace } from "./core/git-workspace.js";
+import { mapWithConcurrency } from "./concurrency.js";
+import { screenshotEvidenceError } from "./image-evidence.js";
+import { buildObserverData } from "./observer-data.js";
+import { parseResolvedPersona, personaToDirectives, renderPersonaPromptSection } from "./persona.js";
+import { containsSensitive, digestText, redactText, redactToSecretLabel, tailText } from "./redaction.js";
+import { bindExistingRunArtifactPaths, RUNS_RELATIVE_ROOT, isSafeRunIdSegment, prepareRunArtifactPaths, resolveExistingRunDirectory, resolveLatestRunDirectory, resolveRunsRoot, validatePreparedRunArtifactPaths } from "./run-paths.js";
+import { assertPreparedSelectedOutputDirectory, assertSafeOutputPathSegment, bindExistingManagedHumanishOutputDirectory, prepareContainedOutputDirectory, prepareContainedOutputDirectoryRoot, prepareContainedOutputFile, prepareSelectedOutputDirectory, readContainedRegularFile, writeContainedOutputFile, writePreparedRunLatestPointer } from "./selected-output-paths.js";
+export const RUN_BUNDLE_SCHEMA = "humanish.run-bundle.v1";
+export const SHARED_WORLD_SCHEMA = "humanish.shared-world.v1";
+export const REVIEW_SCHEMA = "humanish.review.v1";
+export const VERIFY_SCHEMA = "humanish.verify-result.v1";
+export const RUNS_SCHEMA = "humanish.runs-result.v1";
+export const DOCTOR_SCHEMA = "humanish.doctor-result.v1";
+export const CLEANUP_SCHEMA = "humanish.cleanup-result.v1";
+export const PUBLIC_TARGET_CWD = "[target-cwd]";
+const SAFE_GIT_NOTES = new Set([
+    "Git command could not be started.",
+    "Git HEAD capture timed out.",
+    "Git HEAD command could not be started.",
+    "Git metadata could not be inspected safely.",
+    "Git status command could not be captured.",
+    "Git status command could not be started.",
+    "Git status could not be captured.",
+    "Git status capture timed out.",
+    "Git metadata failed containment validation.",
+    "Git ref-state capture timed out.",
+    "Git ref-state command could not be started.",
+    "Git work-tree detection timed out.",
+    "Git work tree had changes; only counts were captured, not branch names, remotes, paths, or file names.",
+    "Git work tree was clean; branch names, remotes, paths, and file names were not captured.",
+    "No git work tree was detected.",
+    "public-safe synthetic fixture",
+    "public-safe synthetic OSS meta-lab fixture"
+]);
+export async function buildRunSource(args) {
+    const gitOptions = args.capturedAt === undefined ? {} : { capturedAt: args.capturedAt };
+    return {
+        packageName: args.packageName,
+        humanishSource: args.humanishSource,
+        git: await captureGitState(args.cwd, gitOptions)
+    };
+}
+const CODEX_APP_SERVER_PROJECTED_TRACE_SCHEMA = "humanish.codex-app-server-trace.projected.v1";
+const LOCAL_CODEX_TUI_DEFAULT_TIMEOUT_MS = 240_000;
+const LOCAL_CODEX_TUI_MAX_TIMEOUT_MS = 600_000;
+const LOCAL_ACTOR_TRANSCRIPT_MAX_CHARS = 80_000;
+const LOCAL_CODEX_EXEC_DEFAULT_MAX_CONCURRENCY = 4;
+const BROWSER_APP_DEFAULT_TIMEOUT_MS = 60_000;
+const builtinPersona = {
+    id: "builtin-synthetic-new-user",
+    name: "Built-in Synthetic New User",
+    source: "builtin:synthetic-new-user",
+    sourceDigest: "builtin"
+};
+const builtinScenario = {
+    id: "builtin-first-run-smoke",
+    title: "Built-in First-Run Smoke",
+    goal: "Create a public-safe dry-run contract bundle from built-in defaults.",
+    source: "builtin:first-run-smoke",
+    sourceDigest: "builtin"
+};
+export async function runDryRun(options) {
+    const cwd = path.resolve(options.cwd);
+    const cwdError = await validateCwd(cwd);
+    const warnings = [];
+    if (cwdError) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd,
+            warnings,
+            error: cwdError
+        };
+    }
+    if (options.actor !== undefined && !isLocalCodexActor(options.actor)) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_UNSUPPORTED_ACTOR",
+                message: `Unsupported actor: ${options.actor}`
+            }
+        };
+    }
+    const simCount = normalizeSimCount(options.appUrl ? options.simCount ?? 2 : options.simCount);
+    if (simCount === null) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_INVALID_SIM_COUNT",
+                message: "--sims must be a positive integer."
+            }
+        };
+    }
+    const projectRoot = await prepareSelectedOutputDirectory(path.dirname(cwd), cwd);
+    if (options.appUrl !== undefined) {
+        if (options.dryRun) {
+            return {
+                schema: "humanish.run-result.v1",
+                ok: false,
+                cwd,
+                warnings,
+                error: {
+                    code: "HUMANISH_APP_URL_OPTION_CONFLICT",
+                    message: "Use --app-url for a live browser app proof; remove --dry-run."
+                }
+            };
+        }
+        if (simCount > 2) {
+            return {
+                schema: "humanish.run-result.v1",
+                ok: false,
+                cwd,
+                warnings,
+                error: {
+                    code: "HUMANISH_INVALID_SIM_COUNT",
+                    message: "--sims must be 1 or 2 when --app-url is used."
+                }
+            };
+        }
+        return runBrowserAppProof({ ...options, appUrl: options.appUrl, cwd, projectRoot, simCount });
+    }
+    if (!options.dryRun) {
+        const actor = resolveRequestedLocalCodexActor(options.actor);
+        if (actor === "codex-tui") {
+            return runLocalCodexTui({ ...options, actor, cwd, projectRoot, simCount });
+        }
+        if (actor === "codex-exec") {
+            return runLocalCodexExec({ ...options, actor, cwd, projectRoot, simCount });
+        }
+        if (actor === "codex-app-server") {
+            return runLocalCodexAppServer({ ...options, actor, cwd, projectRoot, simCount });
+        }
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_LIVE_RUN_UNIMPLEMENTED",
+                message: "Only run --dry-run is implemented unless --actor codex-tui, --actor codex-exec, --actor codex-app-server, or the matching HUMANISH_ENABLE_LOCAL_CODEX_* env var is set."
+            }
+        };
+    }
+    const now = new Date();
+    const createdAt = now.toISOString();
+    const runId = options.runId ?? `dryrun-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+    const packageName = await readPackageName(projectRoot);
+    const humanishSource = await implicitProjectDirectoryExists(projectRoot, "humanish") ? "present" : "missing";
+    const source = await buildRunSource({ cwd, capturedAt: createdAt, humanishSource, packageName });
+    const selection = await loadDryRunSelection(projectRoot, humanishSource);
+    await assertPreparedSelectedOutputDirectory(projectRoot);
+    const runPaths = await prepareRunArtifactPaths(cwd, runId);
+    const artifactRoot = runPaths.relativeRunRoot;
+    if (humanishSource === "missing") {
+        warnings.push("Committed humanish/ source was not found; using built-in synthetic dry-run defaults.");
+    }
+    warnings.push(...selection.warnings);
+    const observerFixtures = buildSyntheticObserverFixtures({
+        createdAt,
+        personaId: selection.persona.id,
+        scenarioId: selection.scenario.id,
+        simCount
+    });
+    const bundle = {
+        schema: RUN_BUNDLE_SCHEMA,
+        runId,
+        mode: "dry-run",
+        simCount,
+        createdAt,
+        cwd,
+        artifactRoot,
+        source,
+        persona: selection.persona,
+        scenario: selection.scenario,
+        lifecycle: [
+            {
+                at: createdAt,
+                event: "run.created",
+                message: `Synthetic dry-run contract bundle created with ${simCount} sim${simCount === 1 ? "" : "s"}.`
+            },
+            {
+                at: createdAt,
+                event: "persona.selected",
+                message: "Selected public-safe synthetic persona."
+            },
+            {
+                at: createdAt,
+                event: "scenario.selected",
+                message: "Selected public-safe first-run scenario."
+            },
+            {
+                at: createdAt,
+                event: "review.skeleton.created",
+                message: "Created review skeleton without claiming product proof."
+            }
+        ],
+        simulations: observerFixtures.simulations,
+        streams: observerFixtures.streams,
+        events: observerFixtures.events,
+        redaction: {
+            status: "passed",
+            notes: "Dry-run bundle contains synthetic contract proof only."
+        },
+        artifacts: {
+            run: "run.json",
+            reviewJson: "review.json",
+            reviewMarkdown: "review.md",
+            observerData: "observer/observer-data.json",
+            events: "events.ndjson"
+        },
+        review: createReviewSummary(),
+        feedbackCandidates: []
+    };
+    await writeRunBundleArtifacts(runPaths, bundle);
+    await writePreparedRunLatestPointer(runPaths, `${JSON.stringify({
+        schema: "humanish.latest-run.v1",
+        runId,
+        path: artifactRoot,
+        updatedAt: createdAt
+    }, null, 2)}\n`, "utf8");
+    return {
+        schema: "humanish.run-result.v1",
+        ok: true,
+        runId,
+        mode: "dry-run",
+        simCount,
+        cwd,
+        artifactRoot,
+        bundlePath: path.join(artifactRoot, "run.json"),
+        reviewPath: path.join(artifactRoot, "review.md"),
+        latestPath: runPaths.relativeLatestPointer,
+        warnings
+    };
+}
+async function runBrowserAppProof(options) {
+    const warnings = [];
+    const appUrl = normalizeLocalAppUrl(options.appUrl);
+    if (!appUrl) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: options.cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_INVALID_APP_URL",
+                message: "--app-url must be an http(s) loopback URL such as http://127.0.0.1:5173."
+            }
+        };
+    }
+    const browserCommand = await resolveBrowserCommand();
+    if (!browserCommand) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: options.cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_BROWSER_APP_CAPTURE_FAILED",
+                message: "No Chrome/Chromium browser command was found. Set HUMANISH_BROWSER_COMMAND to a browser binary that supports --headless and --screenshot."
+            }
+        };
+    }
+    const now = new Date();
+    const createdAt = now.toISOString();
+    const runId = options.runId ?? `browser-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+    const packageName = await readPackageName(options.projectRoot);
+    const humanishSource = await implicitProjectDirectoryExists(options.projectRoot, "humanish") ? "present" : "missing";
+    const source = await buildRunSource({ cwd: options.cwd, capturedAt: createdAt, humanishSource, packageName });
+    const selection = await loadDryRunSelection(options.projectRoot, humanishSource);
+    await assertPreparedSelectedOutputDirectory(options.projectRoot);
+    const runPaths = await prepareRunArtifactPaths(options.cwd, runId);
+    const artifactRoot = runPaths.relativeRunRoot;
+    if (selection.browserJourneyFailure) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: options.cwd,
+            warnings: [...warnings, ...selection.warnings],
+            error: {
+                code: "HUMANISH_BROWSER_APP_CAPTURE_FAILED",
+                message: selection.browserJourneyFailure
+            }
+        };
+    }
+    const browserJourney = selection.browserJourney ?? builtinBrowserPersonaJourney();
+    if (humanishSource === "missing") {
+        warnings.push("Committed humanish/ source was not found; using built-in synthetic browser-app defaults.");
+    }
+    if (!selection.browserJourney) {
+        warnings.push("No executable browser scenario manifest was found; using built-in browser persona two-step journey.");
+    }
+    warnings.push(...selection.warnings);
+    await prepareContainedOutputDirectory(runPaths, "screenshots");
+    await prepareContainedOutputDirectory(runPaths, "traces");
+    const surfaces = browserSurfaces.slice(0, options.simCount);
+    const captures = await Promise.all(surfaces.map((surface) => captureBrowserSurface({
+        absoluteArtifactRoot: runPaths,
+        appUrl,
+        browserCommand,
+        browserJourney,
+        surface,
+        timeoutMs: options.timeoutMs ?? BROWSER_APP_DEFAULT_TIMEOUT_MS
+    })));
+    await validatePreparedRunArtifactPaths(runPaths);
+    const completedAt = new Date().toISOString();
+    const events = buildBrowserAppEvents({ appUrl, captures, createdAt });
+    const allPassed = captures.every((capture) => capture.ok);
+    const review = createBrowserAppReviewSummary({ appUrl, browserJourney, captures });
+    const bundle = {
+        schema: RUN_BUNDLE_SCHEMA,
+        runId,
+        mode: "live",
+        simCount: captures.length,
+        createdAt,
+        cwd: options.cwd,
+        artifactRoot,
+        source,
+        persona: {
+            id: selection.persona.id,
+            name: selection.persona.name,
+            source: selection.persona.source,
+            sourceDigest: selection.persona.sourceDigest
+        },
+        scenario: {
+            id: browserJourney.scenarioId,
+            title: browserJourney.scenarioTitle,
+            goal: browserJourney.goal,
+            source: browserJourney.source,
+            sourceDigest: browserJourney.sourceDigest
+        },
+        lifecycle: [
+            {
+                at: createdAt,
+                event: "run.created",
+                message: `Live browser persona proof created for ${appUrl}.`
+            },
+            {
+                at: createdAt,
+                event: "app.url.accepted",
+                message: "Accepted public-safe loopback app URL for browser persona journey."
+            },
+            {
+                at: completedAt,
+                event: "review.created",
+                message: allPassed
+                    ? "Created review from desktop/mobile browser persona step evidence."
+                    : "Created review with missing or blocked browser persona step evidence."
+            }
+        ],
+        simulations: captures.map((capture, index) => {
+            const simId = `browser-${capture.surface.id}`;
+            const streamId = `${simId}-stream`;
+            return {
+                id: simId,
+                index: index + 1,
+                personaId: selection.persona.id,
+                scenarioId: browserJourney.scenarioId,
+                status: capture.ok ? "passed" : "blocked",
+                streamKind: "browser",
+                mode: "browser-sim",
+                progress: 100,
+                currentStep: capture.ok
+                    ? `${capture.surface.label} completed ${capture.steps.length} persona steps`
+                    : `${capture.surface.label} journey blocked`,
+                summary: capture.reason,
+                streamIds: [streamId],
+                startedAt: createdAt,
+                updatedAt: capture.capturedAt
+            };
+        }),
+        streams: captures.map((capture) => {
+            const simId = `browser-${capture.surface.id}`;
+            const streamId = `${simId}-stream`;
+            // Never reference a screenshot the producer did not write (artifact-reference.ts).
+            // A blocked capture whose evidence IS the failure carries no surface screenshot, so
+            // we omit the embed URL + ui.screenshotUrl and keep the stream present with its
+            // blocked status — instead of claiming an artifact that verify would fail closed on.
+            // A capture that claims success but is missing its screenshot still keeps the
+            // reference so missingLocalEvidenceArtifacts can catch the broken producer.
+            const surfaceScreenshot = hasWrittenScreenshot(capture) ? capture.screenshotPath : undefined;
+            const screenshotUrl = surfaceScreenshot ? `../${surfaceScreenshot}` : undefined;
+            return {
+                id: streamId,
+                simId,
+                kind: "browser",
+                label: capture.surface.label,
+                status: capture.ok ? "passed" : "blocked",
+                transport: "snapshot",
+                updatedAt: capture.capturedAt,
+                embed: screenshotUrl
+                    ? { kind: "screenshot", url: screenshotUrl, title: capture.surface.label }
+                    : { kind: "placeholder", title: `${capture.surface.label} (blocked — no screenshot captured)` },
+                viewport: capture.surface.viewport,
+                ui: {
+                    appStatus: capture.ok ? "running" : "blocked",
+                    appUrl,
+                    route: appUrl,
+                    intent: browserJourney.goal,
+                    ...(screenshotUrl ? { screenshotUrl } : {}),
+                    state: capture.reason,
+                    visualStatus: capture.ok ? "visible" : "blocked"
+                },
+                completion: {
+                    checkedAt: capture.capturedAt,
+                    exitCode: capture.ok ? 0 : 1,
+                    reason: capture.reason,
+                    status: capture.ok ? "passed" : "blocked"
+                },
+                artifacts: [
+                    { label: "run bundle", path: "run.json", kind: "bundle" },
+                    { label: "review", path: "review.md", kind: "review" },
+                    { label: "event log", path: "events.ndjson", kind: "events" },
+                    { label: `${capture.surface.id} browser trace`, path: capture.tracePath, kind: "trace" },
+                    // Per-step screenshot artifacts only for steps whose screenshot was actually
+                    // written; blocked-not-executed steps recorded no path and claim nothing.
+                    ...capture.steps.flatMap((step) => {
+                        const stepScreenshot = artifactReferenceIfWritten(step.screenshotPath, hasWrittenScreenshot(step));
+                        return stepScreenshot
+                            ? [{ label: `${capture.surface.id} ${step.id} screenshot`, path: stepScreenshot, kind: "screenshot" }]
+                            : [];
+                    })
+                ]
+            };
+        }),
+        events,
+        redaction: {
+            status: "passed",
+            notes: "Browser persona proof stores loopback app URLs, screenshots, and generated traces only; secret-like text is rejected by verify."
+        },
+        artifacts: {
+            run: "run.json",
+            reviewJson: "review.json",
+            reviewMarkdown: "review.md",
+            observerData: "observer/observer-data.json",
+            events: "events.ndjson"
+        },
+        review,
+        feedbackCandidates: []
+    };
+    await writeRunBundleArtifacts(runPaths, bundle);
+    await writePreparedRunLatestPointer(runPaths, `${JSON.stringify({
+        schema: "humanish.latest-run.v1",
+        runId,
+        path: artifactRoot,
+        updatedAt: completedAt
+    }, null, 2)}\n`, "utf8");
+    return {
+        schema: "humanish.run-result.v1",
+        ok: allPassed,
+        runId,
+        mode: "live",
+        simCount: captures.length,
+        cwd: options.cwd,
+        artifactRoot,
+        bundlePath: path.join(artifactRoot, "run.json"),
+        reviewPath: path.join(artifactRoot, "review.md"),
+        latestPath: runPaths.relativeLatestPointer,
+        warnings,
+        ...(allPassed
+            ? {}
+            : {
+                error: {
+                    code: "HUMANISH_BROWSER_APP_CAPTURE_FAILED",
+                    message: review.summary
+                }
+            })
+    };
+}
+function buildBrowserAppEvents(args) {
+    const events = [
+        {
+            id: "event-001",
+            at: args.createdAt,
+            level: "info",
+            type: "browser-persona.run.created",
+            message: "Created live browser persona proof run against a loopback URL."
+        }
+    ];
+    args.captures.forEach((capture) => {
+        events.push({
+            id: `event-${String(events.length + 1).padStart(3, "0")}`,
+            at: capture.capturedAt,
+            level: capture.ok ? "info" : "warn",
+            type: capture.ok ? "browser-persona.journey.passed" : "browser-persona.journey.blocked",
+            message: `${capture.surface.id}: ${capture.reason}`,
+            simId: `browser-${capture.surface.id}`,
+            streamId: `browser-${capture.surface.id}-stream`
+        });
+        for (const step of capture.steps) {
+            events.push({
+                id: `event-${String(events.length + 1).padStart(3, "0")}`,
+                at: step.completedAt,
+                level: step.status === "passed" ? "info" : "warn",
+                type: step.status === "passed" ? "browser-persona.step.passed" : "browser-persona.step.blocked",
+                message: `${capture.surface.id} ${step.id}: ${step.reason}`,
+                simId: `browser-${capture.surface.id}`,
+                streamId: `browser-${capture.surface.id}-stream`
+            });
+        }
+    });
+    return events;
+}
+function createBrowserAppReviewSummary(args) {
+    const passed = args.captures.filter((capture) => capture.ok).length;
+    const allPassed = passed === args.captures.length;
+    const usedBuiltinFallback = args.browserJourney.source.startsWith("builtin:");
+    return {
+        schema: REVIEW_SCHEMA,
+        verdict: allPassed ? "pass" : "blocked",
+        summary: allPassed
+            ? `Completed ${passed}/${args.captures.length} live browser persona journey${args.captures.length === 1 ? "" : "s"} from ${args.appUrl} using ${args.browserJourney.scenarioId}.`
+            : `Completed ${passed}/${args.captures.length} live browser persona journeys from ${args.appUrl} using ${args.browserJourney.scenarioId}; at least one required journey was blocked.`,
+        gaps: [
+            usedBuiltinFallback
+                ? "This proof used the built-in two-step fallback because no executable browser scenario manifest was found."
+                : `This proof used executable browser steps from ${args.browserJourney.source}.`,
+            "Only loopback app URLs are accepted so generated bundles do not preserve private external targets.",
+            ...args.captures
+                .filter((capture) => !capture.ok)
+                .map((capture) => `${capture.surface.id}: ${capture.reason}`)
+        ]
+    };
+}
+function isLocalCodexActor(value) {
+    return value === "codex-tui" || value === "codex-exec" || value === "codex-app-server";
+}
+function resolveRequestedLocalCodexActor(actor) {
+    if (actor && isLocalCodexActor(actor)) {
+        return actor;
+    }
+    if (process.env.HUMANISH_ENABLE_LOCAL_CODEX_TUI === "1") {
+        return "codex-tui";
+    }
+    if (process.env.HUMANISH_ENABLE_LOCAL_CODEX_EXEC === "1") {
+        return "codex-exec";
+    }
+    if (process.env.HUMANISH_ENABLE_LOCAL_CODEX_APP_SERVER === "1") {
+        return "codex-app-server";
+    }
+    return undefined;
+}
+async function runLocalCodexTui(options) {
+    const warnings = [];
+    if (options.simCount !== 1) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: options.cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_ACTOR_FANOUT_UNIMPLEMENTED",
+                message: "Local Codex TUI actor support is currently single-lane because it owns one PTY/UI session. Use codex-exec for bounded-concurrency fanout."
+            }
+        };
+    }
+    const timeoutMs = normalizeActorTimeout(options.timeoutMs ?? readEnvInteger("HUMANISH_CODEX_ACTOR_TIMEOUT_MS") ?? LOCAL_CODEX_TUI_DEFAULT_TIMEOUT_MS);
+    if (timeoutMs === null) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: options.cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_INVALID_TIMEOUT",
+                message: `--timeout-ms must be an integer between 1 and ${LOCAL_CODEX_TUI_MAX_TIMEOUT_MS}.`
+            }
+        };
+    }
+    const now = new Date();
+    const createdAt = now.toISOString();
+    const runId = options.runId ?? `codex-tui-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+    const usesDefaultCodexCommand = options.actorCommand === undefined && process.env.HUMANISH_CODEX_ACTOR_COMMAND === undefined;
+    const trustPreflight = usesDefaultCodexCommand ? await checkCodexWorkspaceTrust(options.cwd) : { ok: true };
+    const packageName = await readPackageName(options.projectRoot);
+    const humanishSource = await implicitProjectDirectoryExists(options.projectRoot, "humanish") ? "present" : "missing";
+    const source = !trustPreflight.ok && trustPreflight.unsafeMetadata
+        ? {
+            packageName,
+            humanishSource,
+            git: {
+                schema: GIT_STATE_SCHEMA,
+                status: "unavailable",
+                capturedAt: createdAt,
+                head: { shortSha: null, refState: "unknown" },
+                changes: { staged: 0, unstaged: 0, untracked: 0, total: 0 },
+                note: "Git metadata failed containment validation."
+            }
+        }
+        : await buildRunSource({ cwd: options.cwd, capturedAt: createdAt, humanishSource, packageName });
+    const selection = await loadDryRunSelection(options.projectRoot, humanishSource);
+    await assertPreparedSelectedOutputDirectory(options.projectRoot);
+    const runPaths = await prepareRunArtifactPaths(options.cwd, runId);
+    const artifactRoot = runPaths.relativeRunRoot;
+    if (humanishSource === "missing") {
+        warnings.push("Committed humanish/ source was not found; using built-in synthetic local actor defaults.");
+    }
+    warnings.push(...selection.warnings);
+    const verdictNonce = randomUUID().slice(0, 12);
+    const prompt = buildLocalCodexTuiPrompt(selection, verdictNonce);
+    const promptDigest = digestText(prompt);
+    const command = resolveLocalCodexTuiCommand(options.cwd, prompt, options.actorCommand);
+    const simId = "sim-01";
+    const streamId = "sim-01-codex-tui";
+    const events = [];
+    const appendEvent = async (type, message, level = "info") => {
+        events.push({
+            id: `event-${String(events.length + 1).padStart(3, "0")}`,
+            at: new Date().toISOString(),
+            level,
+            type,
+            message,
+            simId,
+            streamId
+        });
+        await writeContainedOutputFile(runPaths, "events.ndjson", `${events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf8");
+    };
+    let actor;
+    if (!trustPreflight.ok) {
+        actor = {
+            durationMs: 0,
+            reason: trustPreflight.message,
+            status: "blocked",
+            transcript: `${trustPreflight.message}\nRecovery: ${trustPreflight.recoveryCommand}\n`,
+            transcriptBytes: Buffer.byteLength(trustPreflight.message)
+        };
+        await appendEvent("actor.preflight.blocked", redactSensitiveText(trustPreflight.message), "warn");
+    }
+    else {
+        await appendEvent("actor.spawned", `Spawned local Codex TUI actor command ${command.name} in explicit opt-in mode.`);
+        await appendEvent("actor.prompt.submitted", `Submitted bounded public-safe dogfood prompt digest ${promptDigest}; raw prompt omitted from event log.`);
+        await appendEvent("actor.running", "Published local Codex TUI running snapshot for Observer polling.");
+        const runningAt = new Date().toISOString();
+        const runningBundle = {
+            schema: RUN_BUNDLE_SCHEMA,
+            runId,
+            mode: "live",
+            simCount: 1,
+            createdAt,
+            cwd: options.cwd,
+            artifactRoot,
+            source,
+            persona: selection.persona,
+            scenario: selection.scenario,
+            lifecycle: [
+                {
+                    at: createdAt,
+                    event: "run.created",
+                    message: "Live local Codex TUI run created with one explicit opt-in actor."
+                },
+                {
+                    at: createdAt,
+                    event: "actor.selected",
+                    message: "Selected local codex-tui actor."
+                },
+                {
+                    at: runningAt,
+                    event: "actor.running",
+                    message: "Local Codex TUI actor is running; Observer data will refresh with sanitized evidence after completion."
+                }
+            ],
+            simulations: [
+                {
+                    id: simId,
+                    index: 1,
+                    personaId: selection.persona.id,
+                    scenarioId: selection.scenario.id,
+                    status: "running",
+                    streamKind: "tui",
+                    mode: "tui-sim",
+                    progress: 35,
+                    currentStep: "Local Codex TUI actor running",
+                    summary: "Local Codex TUI actor is running.",
+                    streamIds: [streamId],
+                    startedAt: createdAt,
+                    updatedAt: runningAt
+                }
+            ],
+            streams: [
+                {
+                    id: streamId,
+                    simId,
+                    kind: "tui",
+                    label: "Local Codex TUI actor",
+                    status: "running",
+                    transport: "pty",
+                    updatedAt: runningAt,
+                    embed: {
+                        kind: "terminal",
+                        title: "Local Codex TUI actor"
+                    },
+                    terminal: {
+                        title: "Local Codex TUI actor",
+                        format: "ansi",
+                        stdin: "sent",
+                        tail: "Codex TUI actor is running; sanitized transcript evidence will be linked after completion."
+                    },
+                    completion: {
+                        checkedAt: runningAt,
+                        reason: "actor process is still running",
+                        status: "running"
+                    },
+                    artifacts: [
+                        { label: "run bundle", path: "run.json", kind: "bundle" },
+                        { label: "review", path: "review.md", kind: "review" },
+                        { label: "event log", path: "events.ndjson", kind: "events" }
+                    ]
+                }
+            ],
+            events,
+            redaction: {
+                status: "passed",
+                notes: "Running TUI bundle contains no raw transcript yet; final actor output will be redacted before persistence."
+            },
+            artifacts: {
+                run: "run.json",
+                reviewJson: "review.json",
+                reviewMarkdown: "review.md",
+                observerData: "observer/observer-data.json",
+                events: "events.ndjson"
+            },
+            review: createLocalActorRunningReviewSummary("Codex TUI"),
+            feedbackCandidates: []
+        };
+        await writeRunBundleArtifacts(runPaths, runningBundle);
+        await writePreparedRunLatestPointer(runPaths, `${JSON.stringify({
+            schema: "humanish.latest-run.v1",
+            runId,
+            path: artifactRoot,
+            updatedAt: runningAt
+        }, null, 2)}\n`, "utf8");
+        actor = await executeLocalActorCommand(command, {
+            cwd: options.cwd,
+            timeoutMs,
+            verdictNonce
+        });
+    }
+    await validatePreparedRunArtifactPaths(runPaths);
+    const completedAt = new Date().toISOString();
+    const redactedTranscript = redactSensitiveText(actor.transcript);
+    const tail = tailText(redactedTranscript, 6_000);
+    const status = actor.status;
+    // Redact the reason before it flows into the persisted event, simulation
+    // summary, completion reason, review, and lifecycle. For a trust-preflight
+    // block the reason embeds the absolute workspace path; the live CLI reason can
+    // still show the real path, but the public-safe bundle must not.
+    const verdictReason = redactSensitiveText(actor.reason);
+    await writeContainedOutputFile(runPaths, "transcripts/codex-tui-sanitized.txt", redactedTranscript.length > 0 ? redactedTranscript : "No transcript output captured.\n", "utf8");
+    await writeContainedOutputFile(runPaths, "actor.json", `${JSON.stringify({
+        schema: "humanish.local-codex-tui-actor.v1",
+        actor: "codex-tui",
+        commandName: command.name,
+        promptDigest,
+        verdictNonce,
+        startedAt: createdAt,
+        completedAt,
+        durationMs: actor.durationMs,
+        exitCode: actor.exitCode,
+        signal: actor.signal,
+        status,
+        timeoutMs,
+        transcriptBytes: actor.transcriptBytes,
+        transcriptPath: "transcripts/codex-tui-sanitized.txt",
+        redaction: "passed"
+    }, null, 2)}\n`, "utf8");
+    await appendEvent("actor.observation", `Captured ${actor.transcriptBytes} output byte${actor.transcriptBytes === 1 ? "" : "s"}; sanitized transcript tail recorded with redaction=passed.`);
+    await appendEvent("actor.artifact", "Wrote sanitized Codex TUI transcript and actor trace artifacts under the ignored run directory.");
+    await appendEvent("actor.verdict", `Local Codex TUI actor verdict ${status}: ${verdictReason}`, status === "passed" ? "info" : status === "timed_out" ? "warn" : "error");
+    await appendEvent(status === "timed_out" ? "actor.timeout" : status === "blocked" && !trustPreflight.ok ? "actor.blocked" : "actor.exited", status === "timed_out"
+        ? `Actor timed out after ${timeoutMs}ms; last safe observation retained.`
+        : status === "blocked" && !trustPreflight.ok
+            ? "Actor launch was blocked by preflight before spawn."
+            : `Actor exited with code ${actor.exitCode ?? "null"}${actor.signal ? ` and signal ${actor.signal}` : ""}.`, status === "passed" ? "info" : "warn");
+    const bundle = {
+        schema: RUN_BUNDLE_SCHEMA,
+        runId,
+        mode: "live",
+        simCount: 1,
+        createdAt,
+        cwd: options.cwd,
+        artifactRoot,
+        source,
+        persona: selection.persona,
+        scenario: selection.scenario,
+        lifecycle: [
+            {
+                at: createdAt,
+                event: "run.created",
+                message: "Live local Codex TUI run created with one explicit opt-in actor."
+            },
+            {
+                at: createdAt,
+                event: "actor.selected",
+                message: "Selected local codex-tui actor."
+            },
+            {
+                at: completedAt,
+                event: "review.skeleton.created",
+                message: "Created review skeleton from sanitized actor lifecycle evidence."
+            }
+        ],
+        simulations: [
+            {
+                id: simId,
+                index: 1,
+                personaId: selection.persona.id,
+                scenarioId: selection.scenario.id,
+                status,
+                streamKind: "tui",
+                mode: "tui-sim",
+                progress: 100,
+                currentStep: status === "passed" ? "Local Codex TUI actor completed" : "Local Codex TUI actor needs review",
+                summary: `Local Codex TUI actor ${status}: ${verdictReason}`,
+                streamIds: [streamId],
+                startedAt: createdAt,
+                updatedAt: completedAt
+            }
+        ],
+        streams: [
+            {
+                id: streamId,
+                simId,
+                kind: "tui",
+                label: "Local Codex TUI actor",
+                status,
+                transport: "pty",
+                updatedAt: completedAt,
+                embed: {
+                    kind: "terminal",
+                    title: "Local Codex TUI actor"
+                },
+                terminal: {
+                    title: "Local Codex TUI actor",
+                    format: "ansi",
+                    stdin: "sent",
+                    tail
+                },
+                completion: {
+                    checkedAt: completedAt,
+                    ...(actor.exitCode === undefined ? {} : { exitCode: actor.exitCode }),
+                    logTail: tail,
+                    reason: verdictReason,
+                    status
+                },
+                artifacts: [
+                    { label: "run bundle", path: "run.json", kind: "bundle" },
+                    { label: "review", path: "review.md", kind: "review" },
+                    { label: "event log", path: "events.ndjson", kind: "events" },
+                    { label: "sanitized transcript", path: "transcripts/codex-tui-sanitized.txt", kind: "log" },
+                    { label: "actor trace", path: "actor.json", kind: "trace" }
+                ]
+            }
+        ],
+        events,
+        redaction: {
+            status: "passed",
+            notes: "Actor output was redacted before transcript and bundle persistence; raw prompt is omitted from event log."
+        },
+        artifacts: {
+            run: "run.json",
+            reviewJson: "review.json",
+            reviewMarkdown: "review.md",
+            observerData: "observer/observer-data.json",
+            events: "events.ndjson"
+        },
+        review: createLocalActorReviewSummary("Codex TUI", status, verdictReason),
+        feedbackCandidates: []
+    };
+    await writeRunBundleArtifacts(runPaths, bundle);
+    await writePreparedRunLatestPointer(runPaths, `${JSON.stringify({
+        schema: "humanish.latest-run.v1",
+        runId,
+        path: artifactRoot,
+        updatedAt: completedAt
+    }, null, 2)}\n`, "utf8");
+    return {
+        schema: "humanish.run-result.v1",
+        ok: status === "passed",
+        runId,
+        mode: "live",
+        simCount: 1,
+        cwd: options.cwd,
+        artifactRoot,
+        bundlePath: path.join(artifactRoot, "run.json"),
+        reviewPath: path.join(artifactRoot, "review.md"),
+        latestPath: runPaths.relativeLatestPointer,
+        warnings,
+        ...(status === "passed"
+            ? {}
+            : {
+                error: {
+                    code: "HUMANISH_LOCAL_CODEX_TUI_FAILED",
+                    message: `Local Codex TUI actor ${status}: ${verdictReason}`
+                }
+            })
+    };
+}
+function buildLocalCodexExecBundle(args) {
+    return {
+        schema: RUN_BUNDLE_SCHEMA,
+        runId: args.runId,
+        mode: "live",
+        simCount: args.simCount,
+        createdAt: args.createdAt,
+        cwd: args.cwd,
+        artifactRoot: args.artifactRoot,
+        source: args.source,
+        persona: args.persona,
+        scenario: args.scenario,
+        lifecycle: args.lifecycle,
+        simulations: args.lanes.map((lane, index) => ({
+            id: lane.simId,
+            index: index + 1,
+            personaId: `codex-exec-${lane.focus.id}`,
+            scenarioId: args.scenario.id,
+            status: lane.status,
+            streamKind: "terminal",
+            mode: "cli-sim",
+            progress: lane.progress,
+            currentStep: lane.currentStep,
+            summary: lane.summary,
+            streamIds: [lane.streamId],
+            startedAt: args.createdAt,
+            updatedAt: lane.updatedAt
+        })),
+        streams: args.lanes.map((lane) => {
+            const artifacts = [
+                { label: "run bundle", path: "run.json", kind: "bundle" },
+                { label: "review", path: "review.md", kind: "review" },
+                { label: "event log", path: "events.ndjson", kind: "events" },
+                ...(lane.transcriptPath ? [{ label: "sanitized transcript", path: lane.transcriptPath, kind: "log" }] : []),
+                ...(lane.tracePath ? [{ label: "actor trace", path: lane.tracePath, kind: "trace" }] : [])
+            ];
+            return {
+                id: lane.streamId,
+                simId: lane.simId,
+                kind: "terminal",
+                label: `Local Codex exec - ${lane.focus.label}`,
+                status: lane.status,
+                transport: "snapshot",
+                updatedAt: lane.updatedAt,
+                embed: {
+                    kind: "terminal",
+                    title: `Local Codex exec - ${lane.focus.label}`
+                },
+                terminal: {
+                    title: `Local Codex exec - ${lane.focus.label}`,
+                    format: "plain",
+                    stdin: "sent",
+                    tail: lane.terminalTail
+                },
+                ...(lane.completion ? { completion: lane.completion } : {}),
+                artifacts
+            };
+        }),
+        events: args.events,
+        redaction: {
+            status: "passed",
+            notes: "Actor output was redacted before transcript and bundle persistence; raw prompt is omitted from event log."
+        },
+        artifacts: {
+            run: "run.json",
+            reviewJson: "review.json",
+            reviewMarkdown: "review.md",
+            observerData: "observer/observer-data.json",
+            events: "events.ndjson"
+        },
+        review: args.review,
+        feedbackCandidates: []
+    };
+}
+async function runLocalCodexExec(options) {
+    const warnings = [];
+    const timeoutMs = normalizeActorTimeout(options.timeoutMs ?? readEnvInteger("HUMANISH_CODEX_ACTOR_TIMEOUT_MS") ?? LOCAL_CODEX_TUI_DEFAULT_TIMEOUT_MS);
+    if (timeoutMs === null) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: options.cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_INVALID_TIMEOUT",
+                message: `--timeout-ms must be an integer between 1 and ${LOCAL_CODEX_TUI_MAX_TIMEOUT_MS}.`
+            }
+        };
+    }
+    const maxConcurrency = normalizePositiveInteger(readEnvInteger("HUMANISH_LOCAL_CODEX_EXEC_MAX_CONCURRENCY") ?? LOCAL_CODEX_EXEC_DEFAULT_MAX_CONCURRENCY);
+    if (maxConcurrency === null) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: options.cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_INVALID_ACTOR_CONCURRENCY",
+                message: "HUMANISH_LOCAL_CODEX_EXEC_MAX_CONCURRENCY must be a positive integer."
+            }
+        };
+    }
+    const now = new Date();
+    const createdAt = now.toISOString();
+    const runId = options.runId ?? `codex-exec-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+    const packageName = await readPackageName(options.projectRoot);
+    const humanishSource = await implicitProjectDirectoryExists(options.projectRoot, "humanish") ? "present" : "missing";
+    const source = await buildRunSource({ cwd: options.cwd, capturedAt: createdAt, humanishSource, packageName });
+    const selection = await loadDryRunSelection(options.projectRoot, humanishSource);
+    await assertPreparedSelectedOutputDirectory(options.projectRoot);
+    const runPaths = await prepareRunArtifactPaths(options.cwd, runId);
+    const artifactRoot = runPaths.relativeRunRoot;
+    if (humanishSource === "missing") {
+        warnings.push("Committed humanish/ source was not found; using built-in synthetic local actor defaults.");
+    }
+    warnings.push(...selection.warnings);
+    const verdictNonce = randomUUID().slice(0, 12);
+    const events = [];
+    const pushEvent = (type, message, level = "info", simId, streamId) => {
+        events.push({
+            id: `event-${String(events.length + 1).padStart(3, "0")}`,
+            at: new Date().toISOString(),
+            level,
+            type,
+            message,
+            ...(simId === undefined ? {} : { simId }),
+            ...(streamId === undefined ? {} : { streamId })
+        });
+    };
+    await writePreparedRunLatestPointer(runPaths, `${JSON.stringify({
+        schema: "humanish.latest-run.v1",
+        runId,
+        path: artifactRoot,
+        updatedAt: createdAt
+    }, null, 2)}\n`, "utf8");
+    const lanes = Array.from({ length: options.simCount }, (_, index) => {
+        const focus = localCodexExecFocus(index);
+        const simId = `sim-${String(index + 1).padStart(2, "0")}`;
+        const streamId = `${simId}-codex-exec`;
+        const prompt = buildLocalCodexExecPrompt(selection, verdictNonce, {
+            focus,
+            index: index + 1,
+            total: options.simCount
+        });
+        const promptDigest = digestText(prompt);
+        const command = resolveLocalCodexExecCommand(options.cwd, prompt, options.actorCommand);
+        pushEvent("actor.spawned", `Spawned local Codex exec actor lane ${index + 1}/${options.simCount} (${focus.label}) command ${command.name} in explicit opt-in mode.`, "info", simId, streamId);
+        pushEvent("actor.prompt.submitted", `Submitted bounded public-safe dogfood prompt digest ${promptDigest}; raw prompt omitted from event log.`, "info", simId, streamId);
+        return { command, focus, promptDigest, simId, streamId };
+    });
+    for (const lane of lanes) {
+        pushEvent("actor.running", "Published local Codex exec running snapshot for Observer polling.", "info", lane.simId, lane.streamId);
+    }
+    await writeContainedOutputFile(runPaths, "events.ndjson", `${events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf8");
+    const baseLifecycle = [
+        {
+            at: createdAt,
+            event: "run.created",
+            message: `Live local Codex exec run created with ${options.simCount} explicit opt-in actor${options.simCount === 1 ? "" : "s"} and max concurrency ${maxConcurrency}.`
+        },
+        {
+            at: createdAt,
+            event: "actor.selected",
+            message: "Selected local codex-exec actor."
+        }
+    ];
+    const runningAt = new Date().toISOString();
+    const runningBundle = buildLocalCodexExecBundle({
+        runId,
+        simCount: options.simCount,
+        createdAt,
+        cwd: options.cwd,
+        artifactRoot,
+        packageName,
+        humanishSource,
+        source,
+        persona: selection.persona,
+        scenario: selection.scenario,
+        lifecycle: [
+            ...baseLifecycle,
+            {
+                at: runningAt,
+                event: "actor.running",
+                message: `Local Codex exec actor lanes are running with max concurrency ${maxConcurrency}; Observer data will refresh as sanitized evidence arrives.`
+            }
+        ],
+        lanes: lanes.map((lane) => ({
+            focus: lane.focus,
+            simId: lane.simId,
+            streamId: lane.streamId,
+            status: "running",
+            progress: 35,
+            currentStep: "Local Codex exec actor running",
+            summary: `Local Codex exec actor ${lane.focus.label} is running.`,
+            terminalTail: "Codex exec actor is running; sanitized transcript evidence will be linked after completion.",
+            updatedAt: runningAt,
+            completion: {
+                checkedAt: runningAt,
+                reason: "actor process is still running",
+                status: "running"
+            }
+        })),
+        events,
+        review: createLocalActorRunningReviewSummary(options.simCount === 1 ? "Codex exec" : "Codex exec fanout")
+    });
+    await writeRunBundleArtifacts(runPaths, runningBundle);
+    const laneResults = await mapWithConcurrency(lanes, maxConcurrency, async (lane) => {
+        const actor = await executeLocalActorCommand(lane.command, {
+            cwd: options.cwd,
+            timeoutMs,
+            verdictNonce
+        });
+        const redactedTranscript = redactSensitiveText(actor.transcript);
+        const tail = tailText(redactedTranscript, 6_000);
+        const transcriptPath = options.simCount === 1
+            ? "transcripts/codex-exec-sanitized.jsonl"
+            : `transcripts/${lane.streamId}-sanitized.jsonl`;
+        const tracePath = options.simCount === 1 ? "actor.json" : `actors/${lane.streamId}.json`;
+        return {
+            actor,
+            command: lane.command,
+            focus: lane.focus,
+            promptDigest: lane.promptDigest,
+            redactedTranscript,
+            simId: lane.simId,
+            streamId: lane.streamId,
+            tail,
+            tracePath,
+            transcriptPath
+        };
+    });
+    const completedAt = new Date().toISOString();
+    await validatePreparedRunArtifactPaths(runPaths);
+    for (const result of laneResults) {
+        await writeContainedOutputFile(runPaths, result.transcriptPath, result.redactedTranscript.length > 0 ? result.redactedTranscript : "No transcript output captured.\n", "utf8");
+        await writeContainedOutputFile(runPaths, result.tracePath, `${JSON.stringify({
+            schema: "humanish.local-codex-exec-actor.v1",
+            actor: "codex-exec",
+            commandName: result.command.name,
+            focusId: result.focus.id,
+            promptDigest: result.promptDigest,
+            verdictNonce,
+            startedAt: createdAt,
+            completedAt,
+            durationMs: result.actor.durationMs,
+            exitCode: result.actor.exitCode,
+            signal: result.actor.signal,
+            status: result.actor.status,
+            timeoutMs,
+            transcriptBytes: result.actor.transcriptBytes,
+            transcriptPath: result.transcriptPath,
+            redaction: "passed"
+        }, null, 2)}\n`, "utf8");
+    }
+    const laneStatuses = laneResults.map((result) => result.actor.status);
+    const status = aggregateActorStatus(laneStatuses);
+    const verdictReason = options.simCount === 1
+        ? laneResults[0]?.actor.reason ?? "actor did not return a result"
+        : summarizeExecFanout(laneStatuses);
+    for (const result of laneResults) {
+        pushEvent("actor.observation", `Captured ${result.actor.transcriptBytes} output byte${result.actor.transcriptBytes === 1 ? "" : "s"}; sanitized transcript tail recorded with redaction=passed.`, "info", result.simId, result.streamId);
+        pushEvent("actor.artifact", "Wrote sanitized Codex exec transcript and actor trace artifacts under the ignored run directory.", "info", result.simId, result.streamId);
+        pushEvent("actor.verdict", `Local Codex exec actor lane ${result.focus.label} verdict ${result.actor.status}: ${result.actor.reason}`, result.actor.status === "passed" ? "info" : result.actor.status === "timed_out" ? "warn" : "error", result.simId, result.streamId);
+        pushEvent(result.actor.status === "timed_out" ? "actor.timeout" : "actor.exited", result.actor.status === "timed_out"
+            ? `Actor timed out after ${timeoutMs}ms; last safe observation retained.`
+            : `Actor exited with code ${result.actor.exitCode ?? "null"}${result.actor.signal ? ` and signal ${result.actor.signal}` : ""}.`, result.actor.status === "passed" ? "info" : "warn", result.simId, result.streamId);
+    }
+    await writeContainedOutputFile(runPaths, "events.ndjson", `${events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf8");
+    const bundle = buildLocalCodexExecBundle({
+        runId,
+        simCount: options.simCount,
+        createdAt,
+        cwd: options.cwd,
+        artifactRoot,
+        packageName,
+        humanishSource,
+        source,
+        persona: selection.persona,
+        scenario: selection.scenario,
+        lifecycle: [
+            ...baseLifecycle,
+            {
+                at: completedAt,
+                event: "review.skeleton.created",
+                message: "Created review skeleton from sanitized actor lifecycle evidence."
+            }
+        ],
+        lanes: laneResults.map((result) => ({
+            focus: result.focus,
+            simId: result.simId,
+            streamId: result.streamId,
+            status: result.actor.status,
+            progress: 100,
+            currentStep: result.actor.status === "passed" ? "Local Codex exec actor completed" : "Local Codex exec actor needs review",
+            summary: `Local Codex exec actor ${result.focus.label} ${result.actor.status}: ${result.actor.reason}`,
+            terminalTail: result.tail,
+            updatedAt: completedAt,
+            transcriptPath: result.transcriptPath,
+            tracePath: result.tracePath,
+            completion: {
+                checkedAt: completedAt,
+                ...(result.actor.exitCode === undefined ? {} : { exitCode: result.actor.exitCode }),
+                logTail: result.tail,
+                reason: result.actor.reason,
+                status: result.actor.status
+            }
+        })),
+        events,
+        review: createLocalActorReviewSummary(options.simCount === 1 ? "Codex exec" : "Codex exec fanout", status, verdictReason)
+    });
+    await writeRunBundleArtifacts(runPaths, bundle);
+    await writePreparedRunLatestPointer(runPaths, `${JSON.stringify({
+        schema: "humanish.latest-run.v1",
+        runId,
+        path: artifactRoot,
+        updatedAt: completedAt
+    }, null, 2)}\n`, "utf8");
+    return {
+        schema: "humanish.run-result.v1",
+        ok: status === "passed",
+        runId,
+        mode: "live",
+        simCount: options.simCount,
+        cwd: options.cwd,
+        artifactRoot,
+        bundlePath: path.join(artifactRoot, "run.json"),
+        reviewPath: path.join(artifactRoot, "review.md"),
+        latestPath: runPaths.relativeLatestPointer,
+        warnings,
+        ...(status === "passed"
+            ? {}
+            : {
+                error: {
+                    code: "HUMANISH_LOCAL_CODEX_EXEC_FAILED",
+                    message: `Local Codex exec actor ${status}: ${verdictReason}`
+                }
+            })
+    };
+}
+function buildLocalCodexAppServerBundle(args) {
+    return {
+        schema: RUN_BUNDLE_SCHEMA,
+        runId: args.runId,
+        mode: "live",
+        simCount: args.simCount,
+        createdAt: args.createdAt,
+        cwd: args.cwd,
+        artifactRoot: args.artifactRoot,
+        source: args.source,
+        persona: args.persona,
+        scenario: args.scenario,
+        lifecycle: args.lifecycle,
+        simulations: args.lanes.map((lane, index) => ({
+            id: lane.simId,
+            index: index + 1,
+            personaId: `codex-app-server-${lane.focus.id}`,
+            scenarioId: args.scenario.id,
+            status: lane.status,
+            streamKind: "codex-ui",
+            mode: "codex-app-sim",
+            progress: lane.progress,
+            currentStep: lane.currentStep,
+            summary: lane.summary,
+            streamIds: [lane.streamId],
+            startedAt: args.createdAt,
+            updatedAt: lane.updatedAt
+        })),
+        streams: args.lanes.map((lane) => {
+            const result = lane.result;
+            // Provider-neutral projection of the actor evidence, with the persona's
+            // applied traits threaded in. Only present once the lane has a result.
+            const actor = result
+                ? getActor("codex-app-server").toActorTrace(result, {
+                    id: args.persona.id,
+                    traitsApplied: personaToDirectives(args.resolvedPersona).traitsApplied,
+                    promptDigest: result.trace.promptDigest
+                })
+                : undefined;
+            const artifacts = [
+                { label: "run bundle", path: "run.json", kind: "bundle" },
+                { label: "review", path: "review.md", kind: "review" },
+                { label: "event log", path: "events.ndjson", kind: "events" },
+                ...(result ? [
+                    { label: "codex app-server trace", path: result.tracePath, kind: "trace" },
+                    { label: "codex app-server events", path: result.eventsPath, kind: "events" },
+                    { label: "codex app-server transcript", path: result.transcriptPath, kind: "log" }
+                ] : [])
+            ];
+            return {
+                id: lane.streamId,
+                simId: lane.simId,
+                kind: "codex-ui",
+                label: `Codex app-server - ${lane.focus.label}`,
+                status: lane.status,
+                transport: "app-server",
+                updatedAt: lane.updatedAt,
+                embed: {
+                    kind: "placeholder",
+                    title: `Codex app-server - ${lane.focus.label}`
+                },
+                terminal: {
+                    title: `Codex app-server - ${lane.focus.label}`,
+                    format: "plain",
+                    stdin: "sent",
+                    tail: lane.terminalTail
+                },
+                codex: {
+                    provider: "codex-app-server",
+                    contract: "Humanish captures Codex app-server Thread, Turn, Item, approval, command, file, tool, message, and reasoning evidence as redacted local artifacts.",
+                    state: codexStateForStream(lane.status),
+                    ...(result?.experimentalApi === undefined ? {} : { experimentalApi: result.experimentalApi }),
+                    ...(result?.counts === undefined ? {} : { eventCount: result.counts.envelopes }),
+                    ...(result?.model === undefined ? {} : { model: result.model }),
+                    ...(result?.sessionId === undefined ? {} : { sessionId: result.sessionId }),
+                    ...(result?.threadId === undefined ? {} : { threadId: result.threadId }),
+                    ...(result?.trace === undefined ? {} : { trace: result.trace }),
+                    ...(result?.tracePath === undefined ? {} : { tracePath: result.tracePath }),
+                    ...(result?.turnId === undefined ? {} : { turnId: result.turnId })
+                },
+                ...(actor === undefined ? {} : { actor }),
+                ...(lane.completion ? { completion: lane.completion } : {}),
+                artifacts
+            };
+        }),
+        events: args.events,
+        redaction: {
+            status: "passed",
+            notes: "Codex app-server envelopes and transcript summaries were redacted before persistence; raw prompts and secret-bearing fields are not stored in run events."
+        },
+        artifacts: {
+            run: "run.json",
+            reviewJson: "review.json",
+            reviewMarkdown: "review.md",
+            observerData: "observer/observer-data.json",
+            events: "events.ndjson"
+        },
+        review: args.review,
+        feedbackCandidates: []
+    };
+}
+async function runLocalCodexAppServer(options) {
+    const warnings = [];
+    const timeoutMs = normalizeActorTimeout(options.timeoutMs ?? readEnvInteger("HUMANISH_CODEX_ACTOR_TIMEOUT_MS") ?? LOCAL_CODEX_TUI_DEFAULT_TIMEOUT_MS);
+    if (timeoutMs === null) {
+        return {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: options.cwd,
+            warnings,
+            error: {
+                code: "HUMANISH_INVALID_TIMEOUT",
+                message: `--timeout-ms must be an integer between 1 and ${LOCAL_CODEX_TUI_MAX_TIMEOUT_MS}.`
+            }
+        };
+    }
+    const now = new Date();
+    const createdAt = now.toISOString();
+    const runId = options.runId ?? `codex-app-server-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+    const packageName = await readPackageName(options.projectRoot);
+    const humanishSource = await implicitProjectDirectoryExists(options.projectRoot, "humanish") ? "present" : "missing";
+    const source = await buildRunSource({ cwd: options.cwd, capturedAt: createdAt, humanishSource, packageName });
+    const selection = await loadDryRunSelection(options.projectRoot, humanishSource);
+    await assertPreparedSelectedOutputDirectory(options.projectRoot);
+    const runPaths = await prepareRunArtifactPaths(options.cwd, runId);
+    const artifactRoot = runPaths.relativeRunRoot;
+    if (humanishSource === "missing") {
+        warnings.push("Committed humanish/ source was not found; using built-in synthetic Codex app-server actor defaults.");
+    }
+    warnings.push(...selection.warnings);
+    const events = [];
+    const pushEvent = (type, message, level = "info", simId, streamId) => {
+        events.push({
+            id: `event-${String(events.length + 1).padStart(3, "0")}`,
+            at: new Date().toISOString(),
+            level,
+            type,
+            message,
+            ...(simId === undefined ? {} : { simId }),
+            ...(streamId === undefined ? {} : { streamId })
+        });
+    };
+    await writePreparedRunLatestPointer(runPaths, `${JSON.stringify({
+        schema: "humanish.latest-run.v1",
+        runId,
+        path: artifactRoot,
+        updatedAt: createdAt
+    }, null, 2)}\n`, "utf8");
+    const lanes = Array.from({ length: options.simCount }, (_, index) => {
+        const focus = localCodexExecFocus(index);
+        const simId = `sim-${String(index + 1).padStart(2, "0")}`;
+        const streamId = `${simId}-codex-app-server`;
+        const prompt = buildLocalCodexAppServerPrompt(selection, {
+            focus,
+            index: index + 1,
+            total: options.simCount
+        });
+        const promptDigest = digestText(prompt);
+        pushEvent("codex-app-server.spawned", `Spawned Codex app-server lane ${index + 1}/${options.simCount} (${focus.label}) in explicit opt-in mode.`, "info", simId, streamId);
+        pushEvent("codex-app-server.prompt.submitted", `Submitted bounded public-safe app-server prompt digest ${promptDigest}; raw prompt omitted from event log.`, "info", simId, streamId);
+        return {
+            focus,
+            prefix: options.simCount === 1 ? "" : `actors/${streamId}/`,
+            prompt,
+            promptDigest,
+            simId,
+            streamId
+        };
+    });
+    for (const lane of lanes) {
+        pushEvent("codex-app-server.running", "Published Codex app-server running snapshot for Observer polling.", "info", lane.simId, lane.streamId);
+    }
+    await writeContainedOutputFile(runPaths, "events.ndjson", `${events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf8");
+    const baseLifecycle = [
+        {
+            at: createdAt,
+            event: "run.created",
+            message: `Live Codex app-server run created with ${options.simCount} explicit opt-in lane${options.simCount === 1 ? "" : "s"}.`
+        },
+        {
+            at: createdAt,
+            event: "actor.selected",
+            message: "Selected local codex-app-server actor."
+        }
+    ];
+    const runningAt = new Date().toISOString();
+    const runningBundle = buildLocalCodexAppServerBundle({
+        runId,
+        simCount: options.simCount,
+        createdAt,
+        cwd: options.cwd,
+        artifactRoot,
+        packageName,
+        humanishSource,
+        source,
+        persona: selection.persona,
+        resolvedPersona: selection.resolvedPersona,
+        scenario: selection.scenario,
+        lifecycle: [
+            ...baseLifecycle,
+            {
+                at: runningAt,
+                event: "codex-app-server.running",
+                message: "Codex app-server lanes are running; Observer data will refresh as redacted app-server evidence arrives."
+            }
+        ],
+        lanes: lanes.map((lane) => ({
+            focus: lane.focus,
+            simId: lane.simId,
+            streamId: lane.streamId,
+            status: "running",
+            progress: 35,
+            currentStep: "Codex app-server actor running",
+            summary: `Codex app-server actor ${lane.focus.label} is running.`,
+            terminalTail: "Codex app-server actor is running; redacted Thread/Turn/Item trace evidence will be linked after completion.",
+            updatedAt: runningAt,
+            completion: {
+                checkedAt: runningAt,
+                reason: "Codex app-server turn is still running",
+                status: "running"
+            }
+        })),
+        events,
+        review: createLocalActorRunningReviewSummary("Codex app-server")
+    });
+    await writeRunBundleArtifacts(runPaths, runningBundle);
+    const laneResults = await mapWithConcurrency(lanes, options.simCount, async (lane) => {
+        const laneRunRoot = lane.prefix
+            ? await prepareContainedOutputDirectoryRoot(runPaths, lane.prefix)
+            : runPaths;
+        const sessionOptions = {
+            cwd: options.cwd,
+            prompt: lane.prompt,
+            runRoot: "physicalRunRoot" in laneRunRoot ? laneRunRoot.physicalRunRoot : laneRunRoot.physicalPath,
+            timeoutMs,
+            ...(options.actorCommand === undefined ? {} : { actorCommand: options.actorCommand }),
+            approvalPolicy: "never",
+            experimentalApi: process.env.HUMANISH_CODEX_APP_SERVER_EXPERIMENTAL === "1",
+            ...(process.env.HUMANISH_CODEX_APP_SERVER_MODEL ? { model: process.env.HUMANISH_CODEX_APP_SERVER_MODEL } : {}),
+            sandbox: readCodexAppServerSandboxFromEnv(),
+            serviceName: "humanish"
+        };
+        const result = await runCodexAppServerSessionInPreparedRoot(sessionOptions, laneRunRoot);
+        return {
+            lane,
+            result: prefixCodexAppServerResultPaths(result, lane.prefix)
+        };
+    });
+    await validatePreparedRunArtifactPaths(runPaths);
+    const completedAt = new Date().toISOString();
+    const statuses = laneResults.map((entry) => entry.result.status);
+    const status = aggregateActorStatus(statuses);
+    const verdictReason = options.simCount === 1
+        ? laneResults[0]?.result.reason ?? "Codex app-server actor did not return a result"
+        : summarizeExecFanout(statuses);
+    for (const entry of laneResults) {
+        pushEvent("codex-app-server.artifact", `Captured ${entry.result.counts.envelopes} app-server envelope${entry.result.counts.envelopes === 1 ? "" : "s"}; trace summary and transcript were redacted before persistence.`, "info", entry.lane.simId, entry.lane.streamId);
+        pushEvent("codex-app-server.verdict", `Codex app-server actor lane ${entry.lane.focus.label} verdict ${entry.result.status}: ${entry.result.reason}`, entry.result.status === "passed" ? "info" : entry.result.status === "timed_out" ? "warn" : "error", entry.lane.simId, entry.lane.streamId);
+    }
+    await writeContainedOutputFile(runPaths, "events.ndjson", `${events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf8");
+    const bundle = buildLocalCodexAppServerBundle({
+        runId,
+        simCount: options.simCount,
+        createdAt,
+        cwd: options.cwd,
+        artifactRoot,
+        packageName,
+        humanishSource,
+        source,
+        persona: selection.persona,
+        resolvedPersona: selection.resolvedPersona,
+        scenario: selection.scenario,
+        lifecycle: [
+            ...baseLifecycle,
+            {
+                at: completedAt,
+                event: "review.skeleton.created",
+                message: "Created review skeleton from redacted Codex app-server lifecycle evidence."
+            }
+        ],
+        lanes: laneResults.map((entry) => ({
+            focus: entry.lane.focus,
+            simId: entry.lane.simId,
+            streamId: entry.lane.streamId,
+            status: entry.result.status,
+            progress: 100,
+            currentStep: entry.result.status === "passed" ? "Codex app-server actor completed" : "Codex app-server actor needs review",
+            summary: `Codex app-server actor ${entry.lane.focus.label} ${entry.result.status}: ${entry.result.reason}`,
+            terminalTail: entry.result.tail,
+            updatedAt: completedAt,
+            result: entry.result,
+            completion: {
+                checkedAt: completedAt,
+                ...(entry.result.exitCode === undefined ? {} : { exitCode: entry.result.exitCode }),
+                logTail: entry.result.tail,
+                reason: entry.result.reason,
+                status: entry.result.status
+            }
+        })),
+        events,
+        review: createLocalActorReviewSummary(options.simCount === 1 ? "Codex app-server" : "Codex app-server fanout", status, verdictReason)
+    });
+    await writeRunBundleArtifacts(runPaths, bundle);
+    await writePreparedRunLatestPointer(runPaths, `${JSON.stringify({
+        schema: "humanish.latest-run.v1",
+        runId,
+        path: artifactRoot,
+        updatedAt: completedAt
+    }, null, 2)}\n`, "utf8");
+    return {
+        schema: "humanish.run-result.v1",
+        ok: status === "passed",
+        runId,
+        mode: "live",
+        simCount: options.simCount,
+        cwd: options.cwd,
+        artifactRoot,
+        bundlePath: path.join(artifactRoot, "run.json"),
+        reviewPath: path.join(artifactRoot, "review.md"),
+        latestPath: runPaths.relativeLatestPointer,
+        warnings,
+        ...(status === "passed"
+            ? {}
+            : {
+                error: {
+                    code: "HUMANISH_CODEX_APP_SERVER_FAILED",
+                    message: `Codex app-server actor ${status}: ${verdictReason}`
+                }
+            })
+    };
+}
+function buildSyntheticObserverFixtures(args) {
+    const templates = [
+        {
+            kind: "ui",
+            mode: "browser-sim",
+            label: "UI journey",
+            currentStep: "Route and viewport contract captured",
+            summary: "Browser lane reserved for VNC playback, screenshots, route state, and interaction trace.",
+            tail: "open target app\nresolve first-run route\ncapture viewport state\nrecord interaction trace",
+            viewport: { width: 1440, height: 960, deviceScaleFactor: 1 }
+        },
+        {
+            kind: "terminal",
+            mode: "cli-sim",
+            label: "CLI actor",
+            currentStep: "Command transcript contract captured",
+            summary: "CLI lane reserved for command-by-command persona runs with stdout/stderr and artifact links.",
+            tail: "$ humanish doctor\nok target cwd\nok humanish source\n$ humanish run --scenario first-run-smoke\ncontract proof emitted",
+            viewport: undefined
+        },
+        {
+            kind: "tui",
+            mode: "tui-sim",
+            label: "TUI actor",
+            currentStep: "Terminal UI frame contract captured",
+            summary: "TUI lane reserved for PTY bytes, ANSI rendering, focus replay, and optional assisted attach.",
+            tail: "\u001b[2mHumanish TUI frame\u001b[0m\n> persona: skeptical-power-user\n> scenario: onboarding-regression\nstatus: awaiting live PTY transport",
+            viewport: undefined
+        },
+        {
+            kind: "codex-ui",
+            mode: "codex-app-sim",
+            label: "Codex UI",
+            currentStep: "App-server embed contract captured",
+            summary: "Codex UI lane reserved for app-server sessions that can be watched beside terminal evidence.",
+            tail: "codex-app-server session contract\nstate: not_connected\nembed: pending provider URL\nreceipts: planned",
+            viewport: { width: 1280, height: 900, deviceScaleFactor: 1 }
+        }
+    ];
+    const simulations = [];
+    const streams = [];
+    const events = [
+        {
+            id: "event-000",
+            at: args.createdAt,
+            level: "info",
+            type: "observer.contract.created",
+            message: "Created public-safe observer stream contract."
+        }
+    ];
+    for (let index = 0; index < args.simCount; index += 1) {
+        const template = templates[index % templates.length];
+        if (!template) {
+            throw new Error("Synthetic observer template missing.");
+        }
+        const simId = `sim-${String(index + 1).padStart(2, "0")}`;
+        const streamId = `${simId}-${template.kind}`;
+        const status = "contract_proof_only";
+        simulations.push({
+            id: simId,
+            index: index + 1,
+            personaId: args.personaId,
+            scenarioId: args.scenarioId,
+            status,
+            streamKind: template.kind,
+            mode: template.mode,
+            progress: 100,
+            currentStep: template.currentStep,
+            summary: template.summary,
+            streamIds: [streamId],
+            startedAt: args.createdAt,
+            updatedAt: args.createdAt
+        });
+        streams.push({
+            id: streamId,
+            simId,
+            kind: template.kind,
+            label: template.label,
+            status,
+            transport: streamTransport(template.kind),
+            updatedAt: args.createdAt,
+            embed: {
+                kind: template.kind === "terminal" || template.kind === "tui" ? "terminal" : "placeholder",
+                title: template.label
+            },
+            ...(template.viewport ? { viewport: template.viewport } : {}),
+            terminal: {
+                title: template.label,
+                format: template.kind === "tui" ? "ansi" : "plain",
+                stdin: "disabled",
+                tail: template.tail
+            },
+            ...(template.kind === "ui" || template.kind === "codex-ui"
+                ? {
+                    ui: {
+                        route: template.kind === "ui" ? "/first-run" : "/codex/session",
+                        intent: template.summary,
+                        state: "contract-only"
+                    }
+                }
+                : {}),
+            ...(template.kind === "codex-ui"
+                ? {
+                    codex: {
+                        provider: "codex-app-server",
+                        state: "not_connected",
+                        contract: "Observer accepts an app-server embed URL, session id, status feed, terminal receipt feed, and artifact links."
+                    }
+                }
+                : {}),
+            artifacts: [
+                { label: "run bundle", path: "run.json", kind: "bundle" },
+                { label: "review", path: "review.md", kind: "review" },
+                { label: "event log", path: "events.ndjson", kind: "events" }
+            ]
+        });
+        events.push({
+            id: `event-${String(index + 1).padStart(3, "0")}-a`,
+            at: args.createdAt,
+            level: "info",
+            type: "sim.contract.ready",
+            message: `${template.label} stream contract ready.`,
+            simId,
+            streamId
+        }, {
+            id: `event-${String(index + 1).padStart(3, "0")}-b`,
+            at: args.createdAt,
+            level: "warn",
+            type: "sim.live-substrate.missing",
+            message: "No live actor launched in dry-run mode; observer lane is ready for real substrate evidence.",
+            simId,
+            streamId
+        });
+    }
+    return { events, simulations, streams };
+}
+function streamTransport(kind) {
+    if (kind === "tui")
+        return "pty";
+    if (kind === "codex-ui")
+        return "app-server";
+    if (kind === "ui" || kind === "browser")
+        return "polling";
+    return "snapshot";
+}
+function resolveLocalCodexTuiCommand(cwd, prompt, overrideCommand) {
+    const envCommand = process.env.HUMANISH_CODEX_ACTOR_COMMAND;
+    const commandParts = overrideCommand && overrideCommand.length > 0
+        ? overrideCommand
+        : envCommand
+            ? parseCommandLine(envCommand)
+            : defaultLocalCodexTuiCommand(cwd, prompt);
+    const [command, ...args] = commandParts;
+    if (!command) {
+        const [fallbackCommand, ...fallbackArgs] = defaultLocalCodexTuiCommand(cwd, prompt);
+        return {
+            command: fallbackCommand ?? "codex",
+            args: fallbackArgs,
+            name: fallbackCommand ? path.basename(fallbackCommand) : "codex"
+        };
+    }
+    return {
+        command,
+        args,
+        name: path.basename(command)
+    };
+}
+function defaultLocalCodexTuiCommand(cwd, prompt) {
+    const codexParts = [
+        "codex",
+        "--no-alt-screen",
+        "-C",
+        cwd,
+        "--sandbox",
+        "read-only",
+        "--ask-for-approval",
+        "never",
+        prompt
+    ];
+    if (process.platform === "linux") {
+        return ["script", "-qfec", shellJoin(codexParts), "/dev/null"];
+    }
+    return codexParts;
+}
+function resolveLocalCodexExecCommand(cwd, prompt, overrideCommand) {
+    const envCommand = process.env.HUMANISH_CODEX_ACTOR_COMMAND;
+    const commandParts = overrideCommand && overrideCommand.length > 0
+        ? overrideCommand
+        : envCommand
+            ? parseCommandLine(envCommand)
+            : defaultLocalCodexExecCommand(cwd, prompt);
+    const [command, ...args] = commandParts;
+    if (!command) {
+        const [fallbackCommand, ...fallbackArgs] = defaultLocalCodexExecCommand(cwd, prompt);
+        return {
+            command: fallbackCommand ?? "codex",
+            args: fallbackArgs,
+            name: fallbackCommand ? path.basename(fallbackCommand) : "codex"
+        };
+    }
+    return {
+        command,
+        args,
+        name: path.basename(command)
+    };
+}
+function defaultLocalCodexExecCommand(cwd, prompt) {
+    return [
+        "codex",
+        "exec",
+        "--skip-git-repo-check",
+        "--ignore-rules",
+        "--ephemeral",
+        "-C",
+        cwd,
+        "--sandbox",
+        "read-only",
+        "--json",
+        prompt
+    ];
+}
+function executeLocalActorCommand(command, options) {
+    const startedAt = Date.now();
+    let transcript = "";
+    let transcriptBytes = 0;
+    let terminalQueryBuffer = "";
+    let observedMarkerStatus = null;
+    let stoppingAfterMarker = false;
+    let timedOut = false;
+    let settled = false;
+    let timer;
+    let markerKillTimer;
+    return new Promise((resolve) => {
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(markerKillTimer);
+            const normalizedTranscript = normalizeLocalActorTranscript(transcript);
+            resolve({
+                ...result,
+                durationMs: Date.now() - startedAt,
+                transcript: redactSensitiveText(normalizedTranscript),
+                transcriptBytes
+            });
+        };
+        const child = spawn(command.command, command.args, {
+            cwd: options.cwd,
+            env: {
+                ...process.env,
+                TERM: process.env.TERM ?? "xterm-256color",
+                COLUMNS: process.env.COLUMNS ?? "120",
+                LINES: process.env.LINES ?? "40",
+                HUMANISH_ACTOR_VERDICT_NONCE: options.verdictNonce
+            },
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            setTimeout(() => {
+                if (timedOut) {
+                    child.kill("SIGKILL");
+                }
+            }, 2_000).unref();
+        }, options.timeoutMs);
+        timer.unref();
+        const capture = (chunk) => {
+            transcriptBytes += chunk.byteLength;
+            transcript = limitTranscript(transcript + chunk.toString("utf8"));
+            terminalQueryBuffer = respondToTerminalQueries(terminalQueryBuffer, chunk, child.stdin);
+            const markerStatus = observedMarkerStatus ?? extractLocalActorVerdict(normalizeLocalActorTranscript(transcript), options.verdictNonce);
+            if (markerStatus && !observedMarkerStatus) {
+                observedMarkerStatus = markerStatus;
+                stoppingAfterMarker = true;
+                child.kill("SIGTERM");
+                markerKillTimer = setTimeout(() => {
+                    child.kill("SIGKILL");
+                }, 2_000);
+                markerKillTimer.unref();
+            }
+        };
+        child.stdout?.on("data", capture);
+        child.stderr?.on("data", capture);
+        child.once("error", (error) => {
+            finish({
+                status: "blocked",
+                reason: `actor command could not start: ${error.message}`
+            });
+        });
+        child.once("close", (code, signal) => {
+            if (timedOut || (Date.now() - startedAt >= options.timeoutMs && code === null)) {
+                timedOut = false;
+                finish({
+                    status: "timed_out",
+                    reason: `actor exceeded ${options.timeoutMs}ms timeout`,
+                    ...(signal === null ? {} : { signal })
+                });
+                return;
+            }
+            const markerStatus = observedMarkerStatus ?? extractLocalActorVerdict(normalizeLocalActorTranscript(transcript), options.verdictNonce);
+            const processFailed = code !== 0 && !(stoppingAfterMarker && markerStatus);
+            const status = processFailed
+                ? markerStatus === "blocked" ? "blocked" : "failed"
+                : markerStatus ?? "passed";
+            finish({
+                status,
+                reason: processFailed
+                    ? markerStatus === "blocked"
+                        ? `actor reported blocked verdict marker and exited with code ${code ?? "null"}`
+                        : `actor process exited with code ${code ?? "null"}`
+                    : markerStatus
+                        ? `actor reported ${markerStatus} verdict marker`
+                        : "actor process exited successfully",
+                ...(code === null ? {} : { exitCode: code }),
+                ...(signal === null ? {} : { signal })
+            });
+        });
+    });
+}
+function respondToTerminalQueries(currentBuffer, chunk, stdin) {
+    if (!stdin || !stdin.writable) {
+        return "";
+    }
+    let buffer = `${currentBuffer}${chunk.toString("latin1")}`;
+    while (true) {
+        const cprIndex = buffer.indexOf("\x1b[6n");
+        const oscMatch = /\x1b\](10|11|12);\?(?:\x07|\x1b\\)/.exec(buffer);
+        const oscIndex = oscMatch?.index ?? -1;
+        if (cprIndex === -1 && oscIndex === -1) {
+            break;
+        }
+        if (cprIndex !== -1 && (oscIndex === -1 || cprIndex < oscIndex)) {
+            stdin.write("\x1b[24;120R");
+            buffer = buffer.slice(cprIndex + "\x1b[6n".length);
+            continue;
+        }
+        const colorSlot = oscMatch?.[1] ?? "10";
+        stdin.write(terminalColorResponse(colorSlot));
+        buffer = buffer.slice((oscIndex === -1 ? 0 : oscIndex) + (oscMatch?.[0].length ?? 0));
+    }
+    return buffer.slice(-128);
+}
+function terminalColorResponse(slot) {
+    if (slot === "11") {
+        return "\x1b]11;rgb:0000/0000/0000\x07";
+    }
+    return `\x1b]${slot};rgb:ffff/ffff/ffff\x07`;
+}
+/**
+ * Strip ANSI/control noise from a captured terminal transcript into stable, scannable text.
+ * Pure (no IO). Exported so the terminal-product lane (src/e2b-terminal-lab.ts) normalizes its
+ * captured exec stream EXACTLY as the local-actor lanes do — the verdict-nonce scorer is only
+ * sound against the same normalization the marker is matched on, so the logic must not diverge.
+ */
+export function normalizeLocalActorTranscript(transcript) {
+    return transcript
+        .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\x1b[78=>]/g, "")
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+}
+/**
+ * Extract the per-run verdict from a normalized transcript: the agent must print exactly
+ * `HUMANISH_ACTOR_VERDICT=<status> HUMANISH_ACTOR_NONCE=<nonce>`, and the nonce is mandatory so a
+ * bare marker (echoed or replayed from untrusted text) can never forge a verdict. Pure (no IO).
+ * Exported so the terminal-product lane scores its in-sandbox `codex exec` run by the SAME marker
+ * — divergent verdict logic would let the two lanes disagree about what "passed" means.
+ */
+export function extractLocalActorVerdict(transcript, verdictNonce) {
+    const compactTranscript = transcript.replace(/\s+/g, "");
+    // The per-run nonce is mandatory: a bare HUMANISH_ACTOR_VERDICT=<status>
+    // marker echoed by an actor (or replayed from untrusted text) must never
+    // satisfy verdict extraction.
+    const match = new RegExp(`HUMANISH_ACTOR_VERDICT=(passed|blocked|failed)HUMANISH_ACTOR_NONCE=${escapeRegExp(verdictNonce)}`, "i").exec(compactTranscript);
+    if (!match) {
+        return null;
+    }
+    return match[1]?.toLowerCase();
+}
+async function checkCodexWorkspaceTrust(cwd) {
+    if (process.env.HUMANISH_SKIP_CODEX_TRUST_PREFLIGHT === "1") {
+        return { ok: true };
+    }
+    const detected = await detectCodexTrustRoot(cwd);
+    if (!detected) {
+        return { ok: true };
+    }
+    if (detected.unsafe) {
+        return {
+            ok: false,
+            trustRoot: detected.worktreeRoot,
+            unsafeMetadata: true,
+            message: `Codex workspace trust preflight blocked local TUI launch; Git worktree metadata failed containment validation: ${detected.worktreeRoot}`,
+            recoveryCommand: `codex --no-alt-screen -C ${shellQuote(detected.worktreeRoot)}`
+        };
+    }
+    const trustRoot = detected.trustRoot;
+    const configPath = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex"), "config.toml");
+    const configText = await readTextIfExists(configPath);
+    if (configText && await codexConfigTrustsProject(configText, trustRoot)) {
+        return { ok: true };
+    }
+    return {
+        ok: false,
+        trustRoot,
+        message: `Codex workspace trust preflight blocked local TUI launch; trust root is not explicitly trusted as an exact Codex project root: ${trustRoot}`,
+        recoveryCommand: `codex --no-alt-screen -C ${shellQuote(trustRoot)}`
+    };
+}
+async function detectCodexTrustRoot(cwd) {
+    const inspection = await inspectVerifiedGitWorkspace(cwd);
+    if (inspection.status === "missing") {
+        return null;
+    }
+    if (inspection.status === "unsafe") {
+        return { unsafe: true, worktreeRoot: inspection.worktreeRoot };
+    }
+    return { unsafe: false, trustRoot: inspection.workspace.trustRoot };
+}
+async function codexConfigTrustsProject(configText, trustRoot) {
+    const sectionPattern = /^\[projects\."((?:\\.|[^"\\])*)"\]\s*$/gm;
+    let sectionMatch;
+    while ((sectionMatch = sectionPattern.exec(configText)) !== null) {
+        const projectPath = unescapeTomlString(sectionMatch[1] ?? "");
+        const afterSection = configText.slice(sectionMatch.index + sectionMatch[0].length);
+        const nextSectionIndex = afterSection.search(/^\[/m);
+        const sectionBody = nextSectionIndex === -1 ? afterSection : afterSection.slice(0, nextSectionIndex);
+        if (/^trust_level\s*=\s*"trusted"\s*$/m.test(sectionBody) && await isSamePhysicalPath(projectPath, trustRoot)) {
+            return true;
+        }
+    }
+    return false;
+}
+function unescapeTomlString(value) {
+    return value.replace(/\\(["\\])/g, "$1");
+}
+async function isSamePhysicalPath(candidatePath, targetPath) {
+    try {
+        const [candidate, target] = await Promise.all([
+            realpath(path.resolve(candidatePath)),
+            realpath(path.resolve(targetPath))
+        ]);
+        return candidate === target;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeActorTimeout(value) {
+    if (normalizePositiveInteger(value) === null || value === undefined || value > LOCAL_CODEX_TUI_MAX_TIMEOUT_MS) {
+        return null;
+    }
+    return value;
+}
+function normalizePositiveInteger(value) {
+    if (!Number.isInteger(value) || value === undefined || value < 1) {
+        return null;
+    }
+    return value;
+}
+function readEnvInteger(name) {
+    const value = process.env[name];
+    if (value === undefined || value.trim() === "") {
+        return undefined;
+    }
+    return /^\d+$/.test(value) ? Number.parseInt(value, 10) : Number.NaN;
+}
+function personaPromptLine(selection) {
+    return renderPersonaPromptSection(selection.resolvedPersona);
+}
+function buildLocalCodexTuiPrompt(selection, verdictNonce) {
+    return [
+        "You are a Humanish local Codex TUI dogfood actor.",
+        personaPromptLine(selection),
+        `Scenario: ${selection.scenario.title}.`,
+        "Inspect this public repository's Humanish setup, run evidence, and Observer affordances.",
+        "Run at most two read-only inspection commands; prefer file reads, `node dist/cli.js --help`, or `pnpm typecheck` when available.",
+        "Do not run commands that write runtime artifacts or temp config, including `pnpm humanish`, `humanish watch`, `humanish feedback`, `humanish init`, tests, builds, installs, or commands that write `.humanish/`.",
+        "If the strongest proof would require writes in this read-only sandbox, inspect existing artifacts instead and name the write-required proof as a follow-up.",
+        "Use passed when read-only inspection confirms the committed harness and existing evidence contract; write-required follow-ups alone are not blockers.",
+        "Do not print secrets, do not commit, do not push, do not open GitHub issues, and do not use private data.",
+        "Finish by summarizing one public-safe harness improvement.",
+        `Then print exactly one final machine-readable line in this format: HUMANISH_ACTOR_VERDICT=<status> HUMANISH_ACTOR_NONCE=${verdictNonce}.`,
+        "Replace <status> with exactly one lowercase word: passed, blocked, or failed."
+    ].join(" ");
+}
+function localCodexExecFocus(index) {
+    const focuses = [
+        {
+            id: "install-readability",
+            label: "install/readability",
+            instruction: "audit whether a new user can understand the committed Humanish dogfood setup quickly",
+            suggestedCommands: [
+                "test -r humanish/README.md && sed -n '1,40p' humanish/README.md",
+                "test -r humanish/config.ts && wc -l humanish/config.ts"
+            ]
+        },
+        {
+            id: "public-safety-trust",
+            label: "public-safety/trust",
+            instruction: "check the local actor boundaries, public-safety claims, and trust-bootstrap language",
+            suggestedCommands: [
+                "test -r humanish/coverage-map.md && sed -n '1,80p' humanish/coverage-map.md",
+                "test -r docs/architecture/local-codex-tui-actor.md && sed -n '1,80p' docs/architecture/local-codex-tui-actor.md"
+            ]
+        },
+        {
+            id: "observer-evidence",
+            label: "Observer/evidence",
+            instruction: "inspect whether run evidence and Observer expectations are easy to verify",
+            suggestedCommands: [
+                "test -r humanish/coverage-matrix.md && sed -n '1,80p' humanish/coverage-matrix.md",
+                "test -r humanish/scenarios/onboarding-regression.yaml && sed -n '1,120p' humanish/scenarios/onboarding-regression.yaml"
+            ]
+        },
+        {
+            id: "verification-release",
+            label: "verification/release",
+            instruction: "inspect the verification and release-gate promises exposed to local dogfood actors",
+            suggestedCommands: [
+                "test -r package.json && node -e \"const p=require('./package.json'); console.log(p.scripts.check); console.log(p.scripts['public-surface:scan']);\"",
+                "test -r humanish/README.md && sed -n '1,80p' humanish/README.md"
+            ]
+        }
+    ];
+    return focuses[index % focuses.length] ?? focuses[0];
+}
+function aggregateActorStatus(statuses) {
+    if (statuses.includes("failed"))
+        return "failed";
+    if (statuses.includes("timed_out"))
+        return "timed_out";
+    if (statuses.includes("blocked"))
+        return "blocked";
+    return statuses.length > 0 && statuses.every((status) => status === "passed") ? "passed" : "failed";
+}
+function summarizeExecFanout(statuses) {
+    if (statuses.length === 1) {
+        return statuses[0] === "passed" ? "actor process exited successfully" : `actor lane ${statuses[0]}`;
+    }
+    const counts = statuses.reduce((current, status) => ({ ...current, [status]: current[status] + 1 }), { passed: 0, failed: 0, blocked: 0, timed_out: 0 });
+    const summary = Object.keys(counts)
+        .filter((status) => counts[status] > 0)
+        .map((status) => `${counts[status]} ${status}`)
+        .join(", ");
+    return statuses.every((status) => status === "passed")
+        ? `all ${statuses.length} Codex exec lanes passed`
+        : `${statuses.length} Codex exec lanes completed with ${summary}`;
+}
+function buildLocalCodexExecPrompt(selection, verdictNonce, lane) {
+    const suggestedCommands = lane?.focus.suggestedCommands ?? [
+        "test -r humanish/config.ts && wc -l humanish/config.ts",
+        "test -r humanish/README.md && sed -n '1,40p' humanish/README.md"
+    ];
+    return [
+        "You are a Humanish local Codex exec dogfood actor running noninteractively.",
+        personaPromptLine(selection),
+        `Scenario: ${selection.scenario.title}.`,
+        ...(lane ? [`Fanout lane ${lane.index}/${lane.total}. Focus: ${lane.focus.instruction}.`] : []),
+        "Run at most two read-only local inspection commands.",
+        `Suggested commands: \`${suggestedCommands[0]}\` and \`${suggestedCommands[1]}\`.`,
+        "Do not edit files, do not run network commands, do not commit, do not push, do not open GitHub issues, and do not print secrets.",
+        "Do not inspect additional files unless one suggested command fails.",
+        "Finish within three public-safe sentences.",
+        `Then print exactly one final machine-readable line in this format: HUMANISH_ACTOR_VERDICT=<status> HUMANISH_ACTOR_NONCE=${verdictNonce}.`,
+        "Replace <status> with exactly one lowercase word: passed, blocked, or failed."
+    ].join(" ");
+}
+// The app-server lane intentionally carries no verdict nonce: its verdict
+// comes from the structured turn/completed status on the app-server JSON-RPC
+// channel (see codex-app-server.ts), never from HUMANISH_ACTOR_VERDICT marker
+// extraction, so transcript text cannot set the run verdict on that lane.
+function buildLocalCodexAppServerPrompt(selection, lane) {
+    return [
+        "You are a Humanish Codex app-server dogfood actor running through the official Codex app-server protocol.",
+        personaPromptLine(selection),
+        `Scenario: ${selection.scenario.title}.`,
+        `Fanout lane ${lane.index}/${lane.total}. Focus: ${lane.focus.instruction}.`,
+        "Work read-only unless the host explicitly configured a stronger sandbox.",
+        "Inspect the current repository's Humanish setup, Observer proof contract, and public-safety posture.",
+        "Use at most two lightweight local commands or file reads.",
+        `Suggested commands: \`${lane.focus.suggestedCommands[0]}\` and \`${lane.focus.suggestedCommands[1]}\`.`,
+        "Do not print secrets, keys, raw private transcripts, private screenshots, or private source snippets.",
+        "Do not commit, push, open GitHub issues, mutate remote systems, or run provider-spend-heavy commands.",
+        "End with one concise public-safe recommendation for improving Humanish as a closed-loop user-study harness."
+    ].join(" ");
+}
+function readCodexAppServerSandboxFromEnv() {
+    const value = process.env.HUMANISH_CODEX_APP_SERVER_SANDBOX;
+    if (value === "workspace-write" || value === "danger-full-access") {
+        return value;
+    }
+    return "read-only";
+}
+function codexStateForStream(status) {
+    if (status === "running" || status === "preparing" || status === "queued") {
+        return "running";
+    }
+    if (status === "passed" || status === "complete") {
+        return "completed";
+    }
+    if (status === "failed") {
+        return "failed";
+    }
+    if (status === "timed_out") {
+        return "timed_out";
+    }
+    if (status === "blocked") {
+        return "blocked";
+    }
+    return "watching";
+}
+function prefixCodexAppServerResultPaths(result, prefix) {
+    if (!prefix) {
+        return result;
+    }
+    return {
+        ...result,
+        eventsPath: `${prefix}${result.eventsPath}`,
+        tracePath: `${prefix}${result.tracePath}`,
+        transcriptPath: `${prefix}${result.transcriptPath}`
+    };
+}
+function parseCommandLine(input) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escaping = false;
+    for (const char of input.trim()) {
+        if (escaping) {
+            current += char;
+            escaping = false;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            escaping = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current !== "") {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current !== "") {
+        tokens.push(current);
+    }
+    return quote ? [] : tokens;
+}
+function shellJoin(parts) {
+    return parts.map(shellQuote).join(" ");
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_/:=.,@%+-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function limitTranscript(value) {
+    if (value.length <= LOCAL_ACTOR_TRANSCRIPT_MAX_CHARS) {
+        return value;
+    }
+    return `[...sanitized transcript truncated to last ${LOCAL_ACTOR_TRANSCRIPT_MAX_CHARS} characters...]\n${value.slice(-LOCAL_ACTOR_TRANSCRIPT_MAX_CHARS)}`;
+}
+function normalizeSimCount(value) {
+    if (value === undefined) {
+        return 1;
+    }
+    if (!Number.isSafeInteger(value) || value < 1) {
+        return null;
+    }
+    return value;
+}
+export async function verifyRun(cwdInput, runInput) {
+    const cwd = path.resolve(cwdInput);
+    let runPaths;
+    try {
+        runPaths = await resolveRunPath(cwd, runInput);
+    }
+    catch {
+        return invalidRunStorageVerifyResult(cwd, runInput);
+    }
+    return verifyPreparedRun(cwd, runInput, runPaths);
+}
+function invalidRunStorageVerifyResult(cwd, runInput) {
+    return {
+        schema: VERIFY_SCHEMA,
+        ok: false,
+        cwd,
+        run: runInput,
+        checks: [{
+                name: "run storage containment",
+                ok: false,
+                message: "run storage must contain only identity-bound directories and single-link regular files"
+            }],
+        shareSafety: {
+            status: "blocked",
+            reasons: [{ code: "VERIFY_FAILED", message: "Run storage failed containment validation." }]
+        },
+        warnings: [],
+        error: {
+            code: "HUMANISH_INVALID_RUN_BUNDLE",
+            message: "Run storage failed containment validation."
+        }
+    };
+}
+async function verifyPreparedRun(cwd, runInput, runPaths) {
+    const checks = [];
+    if (!runPaths) {
+        return {
+            schema: VERIFY_SCHEMA,
+            ok: false,
+            cwd,
+            run: runInput,
+            checks,
+            shareSafety: {
+                status: "blocked",
+                reasons: [
+                    {
+                        code: "VERIFY_FAILED",
+                        message: `Run not found: ${runInput}`
+                    }
+                ]
+            },
+            warnings: [],
+            error: {
+                code: "HUMANISH_RUN_NOT_FOUND",
+                message: `Run not found: ${runInput}`
+            }
+        };
+    }
+    const bundlePath = path.join(runPaths.absoluteRunRoot, "run.json");
+    const bundle = await readRunJsonIfExists(runPaths, "run.json");
+    const cleanupJson = await readRunJsonIfExists(runPaths, "cleanup.json");
+    const reviewJson = await readRunJsonIfExists(runPaths, "review.json");
+    const reviewMarkdown = await readRunTextIfExists(runPaths, "review.md");
+    checks.push({
+        name: "run.json exists",
+        ok: bundle !== null,
+        message: bundle === null ? "run.json missing" : "run.json present"
+    });
+    checks.push({
+        name: "run schema",
+        ok: isRecord(bundle) && bundle.schema === RUN_BUNDLE_SCHEMA,
+        message: "run bundle schema is humanish.run-bundle.v1"
+    });
+    checks.push({
+        name: "run bundle shape",
+        ok: isRunBundle(bundle),
+        message: "run bundle must include source, persona, scenario, lifecycle, simulations, streams, events, artifacts, review, and feedback candidates"
+    });
+    checks.push({
+        name: "redaction passed",
+        ok: isRecord(bundle) && isRecord(bundle.redaction) && bundle.redaction.status === "passed",
+        message: "redaction status must be passed"
+    });
+    checks.push({
+        name: "review artifacts exist",
+        ok: reviewJson !== null && reviewMarkdown !== null,
+        message: "review.json and review.md must exist"
+    });
+    const publicSafetyFindings = await scanRunPublicSafetyArtifacts(runPaths);
+    checks.push({
+        name: "public-safety scan",
+        ok: publicSafetyFindings.length === 0,
+        message: publicSafetyFindings.length === 0
+            ? "run text artifacts and public-proof paths must not match known secret or browser-profile patterns"
+            : `public-safety findings: ${publicSafetyFindings.slice(0, 5).join(", ")}`
+    });
+    const missingEvidenceArtifacts = isRunBundle(bundle)
+        ? await missingLocalEvidenceArtifacts(runPaths, bundle)
+        : [];
+    const invalidEvidenceReferences = isRunBundle(bundle)
+        ? invalidRunEvidenceReferences(bundle)
+        : [];
+    checks.push({
+        name: "local evidence artifacts exist",
+        ok: missingEvidenceArtifacts.length === 0 && invalidEvidenceReferences.length === 0,
+        message: missingEvidenceArtifacts.length === 0 && invalidEvidenceReferences.length === 0
+            ? "referenced local screenshot/trace/log/filesystem artifacts are present"
+            : invalidEvidenceReferences.length > 0
+                ? `invalid evidence artifact references: ${invalidEvidenceReferences.join(", ")}`
+                : `missing local evidence artifacts: ${missingEvidenceArtifacts.join(", ")}`
+    });
+    const terminalProductFindings = isRunBundle(bundle)
+        ? await validateTerminalProductEvidence(runPaths, bundle)
+        : [];
+    checks.push({
+        name: "terminal-product evidence",
+        ok: terminalProductFindings.length === 0,
+        message: terminalProductFindings.length === 0
+            ? "live terminal-product streams either are absent or carry the substrate/cleanup/interventions/cost ledgers + a ledger-derived no-spend proof + redacted terminal evidence, with proven teardown and known spend within the declared cap"
+            : `terminal-product findings: ${terminalProductFindings.join(", ")}`
+    });
+    const codexAppServerFindings = isRunBundle(bundle)
+        ? await validateCodexAppServerEvidence(runPaths, bundle)
+        : [];
+    checks.push({
+        name: "codex app-server evidence",
+        ok: codexAppServerFindings.length === 0,
+        message: codexAppServerFindings.length === 0
+            ? "live Codex app-server streams either are absent or include valid redacted trace evidence"
+            : `codex app-server findings: ${codexAppServerFindings.join(", ")}`
+    });
+    const noEngagementFindings = isRunBundle(bundle) ? noEngagementActorFindings(bundle) : [];
+    checks.push({
+        name: "actor engagement",
+        ok: noEngagementFindings.length === 0,
+        message: noEngagementFindings.length === 0
+            ? "live actor traces that claim goal_satisfied carry at least one action or message"
+            : `no-engagement findings: ${noEngagementFindings.join(", ")} — a hollow run is not credible evidence`
+    });
+    const actorVerdictFindings = isRunBundle(bundle) ? actorVerdictConsistencyFindings(bundle) : [];
+    checks.push({
+        name: "actor verdict consistency",
+        ok: actorVerdictFindings.length === 0,
+        message: actorVerdictFindings.length === 0
+            ? "live pass verdicts do not hide failed, blocked, or timed-out actor traces"
+            : `actor verdict findings: ${actorVerdictFindings.join(", ")}`
+    });
+    const stateFindings = isRunBundle(bundle) ? subjectStateFindings(bundle) : [];
+    checks.push({
+        name: "subject state provenance",
+        ok: stateFindings.length === 0,
+        message: stateFindings.length === 0
+            ? "subject state claims match the recorded seed/external evidence (or the subject block is honestly absent)"
+            : `subject state findings: ${stateFindings.join(", ")}`
+    });
+    const sharedWorldFindings = isRunBundle(bundle) ? sharedWorldEvidenceFindings(bundle) : [];
+    checks.push({
+        name: "shared-world evidence",
+        ok: sharedWorldFindings.length === 0,
+        message: sharedWorldFindings.length === 0
+            ? "live shared-world runs either are absent or carry a well-formed alternating timeline (cp-baseline → turn → cp), single-plane provenance, digest-only checkpoints, the mandatory attributionLimits, and a checkpoint delta on a passed run"
+            : `shared-world findings: ${sharedWorldFindings.join(", ")}`
+    });
+    checks.push({
+        name: "cleanup receipt",
+        ok: cleanupJson === null || (isCleanupResult(cleanupJson) && cleanupJson.ok),
+        message: cleanupJson === null
+            ? "cleanup receipt not present; cleanup was not requested"
+            : isCleanupResult(cleanupJson) && cleanupJson.ok
+                ? "cleanup receipt is present and successful"
+                : "cleanup receipt is present but malformed or failed"
+    });
+    const rerunFindings = isRunBundle(bundle) ? rerunLineageFindings(bundle) : [];
+    checks.push({
+        name: "rerun lineage",
+        ok: rerunFindings.length === 0,
+        message: rerunFindings.length === 0
+            ? "rerun bundles either are absent or link selected lanes to prior lane status and a fan-out rerun event"
+            : `rerun lineage findings: ${rerunFindings.join(", ")}`
+    });
+    const ok = checks.every((check) => check.ok);
+    const warnings = isRunBundle(bundle)
+        ? [...rawScreenshotPostureWarnings(bundle), ...undeclaredSubjectStateWarnings(bundle)]
+        : [];
+    const shareSafety = isRunBundle(bundle)
+        ? buildShareSafety({ ok, bundle, publicSafetyFindings })
+        : {
+            status: "blocked",
+            reasons: [
+                {
+                    code: "VERIFY_FAILED",
+                    message: "Run bundle failed verification."
+                }
+            ]
+        };
+    return {
+        schema: VERIFY_SCHEMA,
+        ok,
+        cwd,
+        run: runInput,
+        bundlePath: path.relative(cwd, bundlePath),
+        checks,
+        shareSafety,
+        warnings,
+        ...(ok
+            ? {}
+            : {
+                error: {
+                    code: "HUMANISH_INVALID_RUN_BUNDLE",
+                    message: "Run bundle failed verification."
+                }
+            })
+    };
+}
+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 {
+            schema: CLEANUP_SCHEMA,
+            ok: false,
+            cwd,
+            run: runInput,
+            checkedAt,
+            summary: { resources: 0, killed: 0, alreadyClean: 0, failed: 0, skipped: 0 },
+            resources: [],
+            adapterResults: [],
+            warnings: [],
+            error: {
+                code: "HUMANISH_INVALID_RUN_BUNDLE",
+                message: "Run storage failed containment validation."
+            }
+        };
+    }
+    if (!resolved) {
+        return {
+            schema: CLEANUP_SCHEMA,
+            ok: false,
+            cwd,
+            run: runInput,
+            checkedAt,
+            summary: { resources: 0, killed: 0, alreadyClean: 0, failed: 0, skipped: 0 },
+            resources: [],
+            adapterResults: [],
+            warnings: [],
+            error: {
+                code: "HUMANISH_RUN_NOT_FOUND",
+                message: `Run not found: ${runInput}`
+            }
+        };
+    }
+    const runPaths = resolved;
+    const bundlePath = path.join(runPaths.absoluteRunRoot, "run.json");
+    const cleanupPath = path.join(runPaths.absoluteRunRoot, "cleanup.json");
+    await prepareContainedOutputFile(runPaths, "cleanup.json");
+    const bundleBytes = await readContainedRegularFile(runPaths, "run.json");
+    let bundle = null;
+    if (bundleBytes) {
+        try {
+            bundle = JSON.parse(bundleBytes.toString("utf8"));
+        }
+        catch {
+            bundle = null;
+        }
+    }
+    if (!isRunBundle(bundle)) {
+        return {
+            schema: CLEANUP_SCHEMA,
+            ok: false,
+            cwd,
+            run: runInput,
+            bundlePath: path.relative(cwd, bundlePath),
+            checkedAt,
+            summary: { resources: 0, killed: 0, alreadyClean: 0, failed: 0, skipped: 0 },
+            resources: [],
+            adapterResults: [],
+            warnings: [],
+            error: {
+                code: "HUMANISH_INVALID_RUN_BUNDLE",
+                message: "Run bundle failed cleanup shape validation."
+            }
+        };
+    }
+    const resources = [];
+    const warnings = [];
+    const providerResources = bundle.providerResources ?? [];
+    for (const resource of providerResources) {
+        if (resource.provider !== "e2b-desktop" || resource.kind !== "sandbox") {
+            resources.push({
+                provider: resource.provider,
+                kind: resource.kind,
+                id: resource.id,
+                status: "skipped",
+                message: "cleanup only supports e2b-desktop sandbox resources"
+            });
+            continue;
+        }
+        if (resource.status === "killed" || resource.cleanup?.killed === true) {
+            resources.push({
+                provider: resource.provider,
+                kind: resource.kind,
+                id: resource.id,
+                status: "already_clean",
+                message: "resource was already recorded as killed"
+            });
+            continue;
+        }
+        resources.push({
+            provider: resource.provider,
+            kind: resource.kind,
+            id: resource.id,
+            status: "failed",
+            message: "automatic provider cleanup requires a verified resource lease"
+        });
+    }
+    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: resources.filter((resource) => resource.status === "killed").length,
+        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 loadRunBundle(cwdInput, runInput) {
+    const cwd = path.resolve(cwdInput);
+    const runPaths = await resolveRunPath(cwd, runInput).catch(() => null);
+    if (!runPaths) {
+        return null;
+    }
+    return loadRunBundlePrepared(cwd, runPaths);
+}
+/** Internal continuity seam for callers that already bound one run identity. */
+export async function loadRunBundlePrepared(cwdInput, runPaths) {
+    const cwd = path.resolve(cwdInput);
+    await validatePreparedRunArtifactPaths(runPaths);
+    const bundlePath = path.join(runPaths.absoluteRunRoot, "run.json");
+    const bundle = await readRunJsonIfExists(runPaths, "run.json");
+    if (!isRunBundle(bundle)) {
+        return null;
+    }
+    return {
+        bundle,
+        bundlePath: path.relative(cwd, bundlePath),
+        runDir: runPaths.absoluteRunRoot
+    };
+}
+/** Internal continuity seam for callers that already bound one run identity. */
+export async function verifyRunPrepared(cwdInput, runInput, runPaths) {
+    const cwd = path.resolve(cwdInput);
+    try {
+        await validatePreparedRunArtifactPaths(runPaths);
+    }
+    catch {
+        return invalidRunStorageVerifyResult(cwd, runInput);
+    }
+    return verifyPreparedRun(cwd, runInput, runPaths);
+}
+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.json");
+        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 verifyPreparedRun(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."
+            }
+        };
+    }
+    return {
+        ...review,
+        path: path.relative(cwd, path.join(runPaths.absoluteRunRoot, "review.json")),
+        runId: path.basename(runPaths.absoluteRunRoot)
+    };
+}
+export async function doctor(cwdInput) {
+    const cwd = path.resolve(cwdInput);
+    const cwdOk = await validateCwd(cwd).then((error) => error === null).catch(() => false);
+    if (!cwdOk) {
+        const checks = [
+            { name: "target cwd", ok: false, message: "target directory exists" },
+            { name: "package.json", ok: false, message: "package.json is present and safe to read" },
+            { name: "humanish source", ok: false, message: "committed humanish/ source directory is present and safe to read" },
+            { name: "runtime ignore", ok: false, message: ".gitignore safely contains .humanish/" }
+        ];
+        return { schema: DOCTOR_SCHEMA, ok: false, cwd, checks };
+    }
+    let projectRoot;
+    try {
+        projectRoot = await prepareSelectedOutputDirectory(path.dirname(cwd), cwd);
+    }
+    catch {
+        const checks = [
+            { name: "target cwd", ok: false, message: "target directory failed containment validation" },
+            { name: "package.json", ok: false, message: "package.json is present and safe to read" },
+            { name: "humanish source", ok: false, message: "committed humanish/ source directory is present and safe to read" },
+            { name: "runtime ignore", ok: false, message: ".gitignore safely contains .humanish/" }
+        ];
+        return { schema: DOCTOR_SCHEMA, ok: false, cwd, checks };
+    }
+    const safeCheck = async (check) => {
+        try {
+            return await check();
+        }
+        catch {
+            return false;
+        }
+    };
+    const checks = [
+        {
+            name: "target cwd",
+            ok: true,
+            message: "target directory exists"
+        },
+        {
+            name: "package.json",
+            ok: await safeCheck(async () => await readImplicitProjectFile(projectRoot, "package.json") !== null),
+            message: "package.json is present and safe to read"
+        },
+        {
+            name: "humanish source",
+            ok: await safeCheck(() => implicitProjectDirectoryExists(projectRoot, "humanish")),
+            message: "committed humanish/ source directory is present and safe to read"
+        },
+        {
+            name: "runtime ignore",
+            ok: await safeCheck(async () => (await readImplicitProjectFile(projectRoot, ".gitignore"))?.includes(".humanish/") ?? false),
+            message: ".gitignore safely contains .humanish/"
+        }
+    ];
+    return {
+        schema: DOCTOR_SCHEMA,
+        ok: checks.every((check) => check.ok),
+        cwd,
+        checks
+    };
+}
+function createReviewSummary() {
+    return {
+        schema: REVIEW_SCHEMA,
+        verdict: "contract_proof_only",
+        summary: "Synthetic dry-run bundle was generated. This proves Humanish artifact plumbing, not product behavior.",
+        gaps: [
+            "No browser was launched.",
+            "No product state was verified.",
+            "No model, provider, or E2B substrate was used."
+        ]
+    };
+}
+function createLocalActorRunningReviewSummary(actorLabel) {
+    return {
+        schema: REVIEW_SCHEMA,
+        verdict: "contract_proof_only",
+        summary: `Live local ${actorLabel} actor is running. This is an in-progress Observer snapshot; final verdict will be written after sanitized actor evidence is captured.`,
+        gaps: [
+            "Final actor verdict and transcript artifacts are not available until the run completes.",
+            "Live Observer follow depends on polling observer/observer-data.json while this run is active.",
+            "No GitHub mutation, target OSS mutation, E2B substrate, or production data is used by this local actor contract."
+        ]
+    };
+}
+function createLocalActorReviewSummary(actorLabel, status, reason) {
+    const verdict = status === "passed"
+        ? "pass"
+        : status === "timed_out"
+            ? "timed_out"
+            : status === "blocked"
+                ? "blocked"
+                : "fail";
+    const isTui = actorLabel.toLowerCase().includes("tui");
+    const isFanout = actorLabel.toLowerCase().includes("fanout");
+    return {
+        schema: REVIEW_SCHEMA,
+        verdict,
+        summary: `Live local ${actorLabel} actor ${status}: ${reason}. This proves the local actor lifecycle and sanitized evidence path${isFanout ? " across requested fanout lanes" : ""}, not target product behavior.`,
+        gaps: [
+            isTui
+                ? "Only one local Codex TUI actor is supported in this slice."
+                : "Codex TUI trust bootstrap, PTY rendering, and keyboard-focus proof remain separate from the noninteractive exec actor.",
+            "Live follow uses polling Observer snapshots; raw interactive terminal streaming remains a follow-up hardening step.",
+            "No GitHub mutation, target OSS mutation, E2B substrate, or production data was used by this local actor contract."
+        ]
+    };
+}
+async function inspectImplicitProjectPath(projectRoot, relativePath) {
+    const segments = relativePath.replace(/\\/g, "/").split("/");
+    if (segments.length === 0 || segments.some((segment) => segment.length === 0)) {
+        throw new Error("Implicit project path must be a non-empty relative path.");
+    }
+    await assertPreparedSelectedOutputDirectory(projectRoot);
+    let current = projectRoot.physicalPath;
+    for (const [index, segment] of segments.entries()) {
+        assertSafeOutputPathSegment(segment, "Implicit project path segment");
+        current = path.join(current, segment);
+        let stats;
+        try {
+            stats = await lstat(current, { bigint: true });
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+        if (stats.isSymbolicLink()) {
+            throw new Error(`Implicit project path must not contain symbolic links: ${relativePath}`);
+        }
+        if (!stats.isDirectory() && !stats.isFile()) {
+            throw new Error(`Implicit project path must contain only regular files and directories: ${relativePath}`);
+        }
+        if (stats.isFile() && stats.nlink > 1n) {
+            throw new Error(`Implicit project files must be single-link regular files: ${relativePath}`);
+        }
+        if (index < segments.length - 1 && !stats.isDirectory()) {
+            throw new Error(`Implicit project path parent must be a directory: ${relativePath}`);
+        }
+        if (index === segments.length - 1) {
+            await assertPreparedSelectedOutputDirectory(projectRoot);
+            return stats;
+        }
+    }
+    return null;
+}
+async function implicitProjectDirectoryExists(projectRoot, relativePath) {
+    const stats = await inspectImplicitProjectPath(projectRoot, relativePath);
+    if (!stats) {
+        return false;
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`Implicit project directory has the wrong type: ${relativePath}`);
+    }
+    return true;
+}
+async function readImplicitProjectFile(projectRoot, relativePath) {
+    const stats = await inspectImplicitProjectPath(projectRoot, relativePath);
+    if (!stats) {
+        return null;
+    }
+    if (!stats.isFile() || stats.nlink !== 1n) {
+        throw new Error(`Implicit project file must be a single-link regular file: ${relativePath}`);
+    }
+    const bytes = await readContainedRegularFile(projectRoot, relativePath.replace(/\\/g, "/"));
+    if (!bytes) {
+        throw new Error(`Implicit project file changed while it was being read: ${relativePath}`);
+    }
+    return bytes.toString("utf8");
+}
+async function listImplicitProjectDirectory(projectRoot, relativePath) {
+    if (!await implicitProjectDirectoryExists(projectRoot, relativePath)) {
+        return [];
+    }
+    const directory = path.join(projectRoot.physicalPath, ...relativePath.replace(/\\/g, "/").split("/"));
+    const names = await readdir(directory);
+    await assertPreparedSelectedOutputDirectory(projectRoot);
+    for (const name of names) {
+        assertSafeOutputPathSegment(name, "Implicit project directory entry");
+        await inspectImplicitProjectPath(projectRoot, `${relativePath.replace(/\\/g, "/")}/${name}`);
+    }
+    return names;
+}
+async function loadDryRunSelection(projectRoot, humanishSource) {
+    const warnings = [];
+    if (humanishSource === "missing") {
+        return {
+            persona: builtinPersona,
+            resolvedPersona: parseResolvedPersona({}, { id: builtinPersona.id, name: builtinPersona.name }),
+            scenario: builtinScenario,
+            warnings
+        };
+    }
+    const personaPath = "humanish/personas/synthetic-new-user.yaml";
+    const scenarioPath = "humanish/scenarios/first-run-smoke.yaml";
+    const personaText = await readImplicitProjectFile(projectRoot, personaPath);
+    const scenarioText = await readImplicitProjectFile(projectRoot, scenarioPath);
+    const browserJourneySelection = await loadBrowserPersonaJourneySelection(projectRoot);
+    if (personaText === null) {
+        warnings.push(`${personaPath} was not found; using built-in persona defaults.`);
+    }
+    if (scenarioText === null) {
+        warnings.push(`${scenarioPath} was not found; using built-in scenario defaults.`);
+    }
+    let resolvedPersona;
+    if (personaText === null) {
+        resolvedPersona = parseResolvedPersona({}, { id: builtinPersona.id, name: builtinPersona.name });
+    }
+    else {
+        const parsedPersona = parsePersonaYaml(personaText);
+        if (parsedPersona.failed) {
+            warnings.push(`${personaPath} could not be parsed as YAML; using built-in persona trait defaults.`);
+        }
+        resolvedPersona = parseResolvedPersona(parsedPersona.value, {
+            id: "synthetic-new-user",
+            name: "Synthetic New User"
+        });
+    }
+    return {
+        ...(browserJourneySelection.journey ? { browserJourney: browserJourneySelection.journey } : {}),
+        ...(browserJourneySelection.failure ? { browserJourneyFailure: browserJourneySelection.failure } : {}),
+        persona: personaText === null
+            ? builtinPersona
+            : {
+                id: readYamlScalar(personaText, "id") ?? "synthetic-new-user",
+                name: readYamlScalar(personaText, "name") ?? "Synthetic New User",
+                source: personaPath,
+                sourceDigest: digestText(personaText)
+            },
+        resolvedPersona,
+        scenario: scenarioText === null
+            ? builtinScenario
+            : {
+                id: readYamlScalar(scenarioText, "id") ?? "first-run-smoke",
+                title: readYamlScalar(scenarioText, "title") ?? "First-run smoke",
+                goal: readYamlScalar(scenarioText, "goal") ?? "Run a public-safe first-run smoke scenario.",
+                source: scenarioPath,
+                sourceDigest: digestText(scenarioText)
+            },
+        warnings: [...warnings, ...browserJourneySelection.warnings]
+    };
+}
+async function loadBrowserPersonaJourneySelection(projectRoot) {
+    const warnings = [];
+    const names = await listImplicitProjectDirectory(projectRoot, "humanish/scenarios");
+    const files = names
+        .filter((name) => name.endsWith(".yaml") || name.endsWith(".yml"))
+        .sort((left, right) => {
+        if (left === "first-run-smoke.yaml")
+            return -1;
+        if (right === "first-run-smoke.yaml")
+            return 1;
+        return left.localeCompare(right);
+    });
+    for (const name of files) {
+        const relativePath = path.join("humanish", "scenarios", name);
+        const text = await readImplicitProjectFile(projectRoot, relativePath);
+        if (text === null) {
+            continue;
+        }
+        let raw;
+        try {
+            raw = parseYaml(text);
+        }
+        catch (error) {
+            return {
+                failure: `${relativePath} could not be parsed as YAML; browser persona journey failed closed.`,
+                warnings
+            };
+        }
+        const parsed = parseBrowserPersonaJourneyFromScenario({
+            raw,
+            relativePath,
+            sourceDigest: digestText(text)
+        });
+        if (parsed.failure) {
+            return {
+                failure: parsed.failure,
+                warnings
+            };
+        }
+        if (parsed.journey) {
+            return {
+                journey: parsed.journey,
+                warnings
+            };
+        }
+    }
+    return { warnings };
+}
+function renderReviewMarkdown(bundle) {
+    return `# Humanish Run Review
+
+Run: ${bundle.runId}
+
+Mode: ${bundle.mode}
+
+Verdict: ${bundle.review.verdict}
+
+${bundle.review.summary}
+
+## Public-Safety
+
+- Redaction: ${bundle.redaction.status}
+- Notes: ${bundle.redaction.notes}
+
+## Gaps
+
+${bundle.review.gaps.map((gap) => `- ${gap}`).join("\n")}
+`;
+}
+function readYamlScalar(text, key) {
+    const match = text.match(new RegExp(`^${escapeRegExp(key)}:\\s*(.+?)\\s*$`, "m"));
+    if (!match?.[1]) {
+        return null;
+    }
+    return match[1].replace(/^["']|["']$/g, "");
+}
+function parsePersonaYaml(text) {
+    try {
+        return { value: parseYaml(text), failed: false };
+    }
+    catch {
+        return { value: {}, failed: true };
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function resolveRunPath(cwd, runInput) {
+    if (runInput === "latest") {
+        const runsRoot = await bindExistingManagedHumanishOutputDirectory(cwd, "runs");
+        if (!runsRoot) {
+            return null;
+        }
+        const latest = await readLatest(runsRoot);
+        const expected = latest ? resolveLatestRunDirectory(cwd, latest) : null;
+        if (!latest || !expected) {
+            return null;
+        }
+        const runPaths = await bindExistingRunArtifactPaths(cwd, latest.runId);
+        if (runPaths.absoluteRunRoot !== expected
+            || runPaths.physicalRunsRoot !== runsRoot.physicalPath) {
+            throw new Error("Latest run pointer changed physical runs root.");
+        }
+        await assertPreparedSelectedOutputDirectory(runsRoot);
+        return runPaths;
+    }
+    if (!isSafeRunIdSegment(runInput) || !await resolveExistingRunDirectory(cwd, runInput)) {
+        return null;
+    }
+    return bindExistingRunArtifactPaths(cwd, runInput);
+}
+async function readLatest(runsRoot) {
+    const latestPath = path.join(runsRoot.physicalPath, "latest.json");
+    let latestStats;
+    try {
+        latestStats = await lstat(latestPath, { bigint: true });
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+    if (latestStats.isSymbolicLink() || !latestStats.isFile() || latestStats.nlink !== 1n) {
+        throw new Error("Latest run pointer must be a single-link regular file.");
+    }
+    const bytes = await readContainedRegularFile(runsRoot, "latest.json");
+    if (!bytes) {
+        throw new Error("Latest run pointer changed while it was being read.");
+    }
+    let latest;
+    try {
+        latest = JSON.parse(bytes.toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+    return isRunPointer(latest) ? latest : null;
+}
+async function readPackageName(projectRoot) {
+    const text = await readImplicitProjectFile(projectRoot, "package.json");
+    if (text === null) {
+        return null;
+    }
+    try {
+        const packageJson = JSON.parse(text);
+        return isRecord(packageJson) && typeof packageJson.name === "string" ? packageJson.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function readRunJsonIfExists(runPaths, ...segments) {
+    const text = await readRunTextIfExists(runPaths, ...segments);
+    if (text === null) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+async function readRunTextIfExists(runPaths, ...segments) {
+    const bytes = await readContainedRegularFile(runPaths, segments.join("/"));
+    return bytes?.toString("utf8") ?? null;
+}
+async function readSafeRunArtifactBytes(runPaths, relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/");
+    const segments = normalized.split("/");
+    if (path.isAbsolute(relativePath)
+        || path.win32.isAbsolute(relativePath)
+        || segments.length === 0
+        || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+        return null;
+    }
+    return readContainedRegularFile(runPaths, normalized);
+}
+async function readSafeRunArtifactJson(runPaths, relativePath) {
+    const bytes = await readSafeRunArtifactBytes(runPaths, relativePath);
+    if (!bytes) {
+        return null;
+    }
+    try {
+        return JSON.parse(bytes.toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function readTextIfExists(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeRunBundleArtifacts(runPaths, bundle) {
+    const publicBundle = {
+        ...bundle,
+        cwd: PUBLIC_TARGET_CWD
+    };
+    await writeContainedOutputFile(runPaths, "run.json", `${JSON.stringify(publicBundle, null, 2)}\n`, "utf8");
+    await writeContainedOutputFile(runPaths, "review.json", `${JSON.stringify(publicBundle.review, null, 2)}\n`, "utf8");
+    await writeContainedOutputFile(runPaths, "review.md", renderReviewMarkdown(publicBundle), "utf8");
+    await writeContainedOutputFile(runPaths, "events.ndjson", `${publicBundle.events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf8");
+    await writeContainedOutputFile(runPaths, "observer/observer-data.json", `${JSON.stringify(buildObserverData(publicBundle), null, 2)}\n`, "utf8");
+}
+async function missingLocalEvidenceArtifacts(runPaths, bundle) {
+    const requiredPaths = new Map();
+    const addRequiredPath = (artifactPath, options = {}) => {
+        const existing = requiredPaths.get(artifactPath);
+        requiredPaths.set(artifactPath, { screenshot: Boolean(existing?.screenshot || options.screenshot) });
+    };
+    for (const stream of bundle.streams) {
+        for (const artifact of stream.artifacts) {
+            if (isLocalEvidenceArtifactPath(artifact.path)) {
+                addRequiredPath(artifact.path, { screenshot: artifact.kind === "screenshot" });
+            }
+        }
+        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 artifact of bundle.adapterArtifacts ?? []) {
+        if (isLocalEvidenceArtifactPath(artifact.path)) {
+            addRequiredPath(artifact.path, { screenshot: artifact.kind === "screenshot" });
+        }
+    }
+    const missing = [];
+    for (const [artifactPath, requirements] of requiredPaths) {
+        const bytes = await readSafeRunArtifactBytes(runPaths, artifactPath);
+        if (!bytes || bytes.length === 0) {
+            missing.push(artifactPath);
+            continue;
+        }
+        if (requirements.screenshot) {
+            const imageError = screenshotEvidenceError(artifactPath, bytes);
+            if (imageError) {
+                missing.push(`${artifactPath} (${imageError})`);
+            }
+        }
+    }
+    return missing;
+}
+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 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}`);
+        }
+    }
+    return findings.slice(0, 50);
+}
+// The fixed artifact filenames the terminal-product lane (src/e2b-terminal-lab.ts) persists.
+// Kept in sync with TERMINAL_LEDGERS_ARTIFACT / TERMINAL_EVENTS_ARTIFACT / TERMINAL_TRANSCRIPT_ARTIFACT.
+const TERMINAL_LEDGERS_FILE = "terminal-ledgers.json";
+const TERMINAL_EVENTS_FILE = "terminal-events.ndjson";
+const TERMINAL_TRANSCRIPT_FILE = "terminal-transcript.txt";
+/**
+ * Verifier for the terminal-product real-agent lane (issue #154, 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 proven-teardown invariant. Dry-run/contract bundles are exempt (mode !== live).
+ */
+async function validateTerminalProductEvidence(runPaths, bundle) {
+    if (bundle.mode !== "live") {
+        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.
+    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.
+    const ledgers = await readSafeRunArtifactJson(runPaths, TERMINAL_LEDGERS_FILE);
+    if (!isRecord(ledgers) || ledgers.schema !== "humanish.terminal-ledgers.v1") {
+        findings.push(`missing or malformed ${TERMINAL_LEDGERS_FILE} (humanish.terminal-ledgers.v1)`);
+        return findings;
+    }
+    // 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)");
+    }
+    // Command log: present (an array; empty is allowed only if the session never reached exec, which
+    // the lifecycle/cleanup records still cover).
+    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
+    // 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).
+    // 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).
+    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`);
+    }
+    // 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_FILE))) {
+        findings.push(`missing terminal event stream artifact (${TERMINAL_EVENTS_FILE})`);
+    }
+    if (!(await readSafeRunArtifactBytes(runPaths, TERMINAL_TRANSCRIPT_FILE))) {
+        findings.push(`missing normalized terminal transcript artifact (${TERMINAL_TRANSCRIPT_FILE})`);
+    }
+    // The provider-neutral actor trace must be on the terminal lane with redaction passed.
+    for (const stream of terminalStreams) {
+        const traceArtifact = stream.artifacts.find((artifact) => artifact.kind === "trace");
+        const tracePath = traceArtifact?.path ?? "actor.json";
+        const trace = await readSafeRunArtifactJson(runPaths, tracePath);
+        if (!isRecord(trace) || trace.lane !== "terminal") {
+            findings.push(`${stream.id} missing terminal-lane actor trace`);
+            continue;
+        }
+        if (!isRecord(trace.redaction) || trace.redaction.status !== "passed") {
+            findings.push(`${stream.id} actor trace redaction status must be passed`);
+        }
+    }
+    // --- SLICE 3: the cost ledger + no-spend proof must be present + internally honest. ---
+    findings.push(...validateTerminalCostEvidence(ledgers));
+    return findings;
+}
+// The four cost categories the no-spend proof + cost ledger reason over. Kept in sync with
+// e2b-terminal-lab.ts COST_CATEGORIES (a missing category on either side is a finding).
+const TERMINAL_COST_CATEGORIES = ["product", "media", "payment", "provider"];
+/**
+ * Verifier for the SLICE-3 cost ledger + no-spend proof (issue #154's cost/no-spend asks). 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
+ * 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");
+        return findings;
+    }
+    const lines = isRecord(cost.lines) ? cost.lines : undefined;
+    if (!lines) {
+        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"
+    // 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 TERMINAL_COST_CATEGORIES) {
+        const line = isRecord(lines[category]) ? lines[category] : undefined;
+        if (!line || !("usd" in line)) {
+            findings.push(`cost ledger line "${category}" is missing its usd field (unknowns must be explicit null, never omitted)`);
+            continue;
+        }
+        const usd = line.usd;
+        if (usd === null) {
+            nullCategories.add(category);
+        }
+        else if (typeof usd !== "number") {
+            findings.push(`cost ledger line "${category}" usd must be a number or null (got ${typeof usd})`);
+        }
+    }
+    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");
+        return findings;
+    }
+    // HONESTY 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.
+    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`);
+        }
+    }
+    // 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`);
+    }
+    // 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).
+    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(", ")})`);
+    }
+    return findings;
+}
+async function validateCodexAppServerEvidence(runPaths, bundle) {
+    if (bundle.mode !== "live") {
+        return [];
+    }
+    const findings = [];
+    const appServerStreams = bundle.streams.filter((stream) => stream.status !== "contract_proof_only"
+        && (stream.codex?.provider === "codex-app-server"
+            || stream.artifacts.some((artifact) => artifact.path.includes("codex-app-server"))));
+    for (const stream of appServerStreams) {
+        if (stream.codex?.provider !== "codex-app-server") {
+            findings.push(`${stream.id} missing first-class codex app-server metadata`);
+        }
+        if (stream.status === "running" || stream.codex?.state === "connecting" || stream.codex?.state === "running") {
+            continue;
+        }
+        const traceArtifact = stream.artifacts.find((artifact) => artifact.kind === "trace"
+            && artifact.path.includes("codex-app-server"));
+        const eventsArtifact = stream.artifacts.find((artifact) => artifact.kind === "events"
+            && artifact.path.includes("codex-app-server"));
+        const logArtifact = stream.artifacts.find((artifact) => artifact.kind === "log"
+            && artifact.path.includes("codex-app-server"));
+        if (!traceArtifact) {
+            findings.push(`${stream.id} missing codex app-server trace artifact`);
+            continue;
+        }
+        const trace = await readSafeRunArtifactJson(runPaths, traceArtifact.path);
+        if (!isRecord(trace) || ![CODEX_APP_SERVER_TRACE_SCHEMA, CODEX_APP_SERVER_PROJECTED_TRACE_SCHEMA].includes(String(trace.schema))) {
+            findings.push(`${stream.id} trace artifact must use ${CODEX_APP_SERVER_TRACE_SCHEMA} or ${CODEX_APP_SERVER_PROJECTED_TRACE_SCHEMA}`);
+        }
+        if (!isRecord(trace) || !isRecord(trace.redaction) || trace.redaction.status !== "passed") {
+            findings.push(`${stream.id} trace redaction status must be passed`);
+        }
+        if (!eventsArtifact) {
+            findings.push(`${stream.id} missing codex app-server event envelope log`);
+        }
+        if (!logArtifact) {
+            findings.push(`${stream.id} missing codex app-server transcript summary log`);
+        }
+    }
+    return findings;
+}
+// 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", "command", "tool_call", "file_change"]);
+/**
+ * Independent mirror of the producer-side no-engagement guard (cua-actor-lab.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; the hollow-run
+ * regression class (the 0.3.0–0.6.0 CUA parser bug) 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.
+ */
+function noEngagementActorFindings(bundle) {
+    if (bundle.mode !== "live") {
+        return [];
+    }
+    const findings = [];
+    for (const stream of bundle.streams) {
+        const trace = stream.actor;
+        if (!isRecord(trace) || trace.schema !== ACTOR_TRACE_SCHEMA || trace.completionReason !== "goal_satisfied") {
+            continue;
+        }
+        const items = Array.isArray(trace.items) ? trace.items : [];
+        const counts = isRecord(trace.counts) ? trace.counts : {};
+        const countOf = (key) => {
+            const value = counts[key];
+            return typeof value === "number" && Number.isFinite(value) ? value : 0;
+        };
+        const engaged = countOf("actions") > 0
+            || countOf("messages") > 0
+            || hasStopWhenObservationEvidence(items, countOf("screenshots"))
+            || items.some((item) => isRecord(item)
+                && typeof item.kind === "string"
+                && (item.kind === "message" || ACTION_BEARING_ACTOR_ITEM_KINDS.has(item.kind)));
+        if (!engaged) {
+            const provider = typeof trace.provider === "string" ? trace.provider : "unknown provider";
+            findings.push(`${stream.id} live actor trace (${provider}) claims goal_satisfied with zero actions and zero messages`);
+        }
+    }
+    return findings;
+}
+function hasStopWhenObservationEvidence(items, screenshotCount) {
+    const hasScreenshot = screenshotCount > 0 || items.some((item) => isRecord(item)
+        && item.kind === "screenshot"
+        && isRecord(item.screenshotRef)
+        && typeof item.screenshotRef.path === "string"
+        && item.screenshotRef.path.length > 0);
+    if (!hasScreenshot)
+        return false;
+    return items.some((item) => isRecord(item)
+        && item.kind === "notice"
+        && item.status === "matched"
+        && typeof item.title === "string"
+        && item.title.startsWith("stopWhen matched"));
+}
+function actorVerdictConsistencyFindings(bundle) {
+    if (bundle.mode !== "live" || bundle.review.verdict !== "pass") {
+        return [];
+    }
+    const findings = [];
+    for (const stream of bundle.streams) {
+        const trace = stream.actor;
+        if (!isRecord(trace) || trace.schema !== ACTOR_TRACE_SCHEMA) {
+            continue;
+        }
+        if (trace.status !== "passed") {
+            const provider = typeof trace.provider === "string" ? trace.provider : "unknown provider";
+            const reason = typeof trace.reason === "string" ? trace.reason : "no actor reason";
+            findings.push(`${stream.id} live actor trace (${provider}) has status ${String(trace.status)} under a pass review verdict: ${reason}`);
+        }
+    }
+    return 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.
+ */
+function rawScreenshotPostureWarnings(bundle) {
+    const rawStreamIds = rawScreenshotStreamIds(bundle);
+    if (rawStreamIds.length === 0) {
+        return [];
+    }
+    return [
+        `Screenshots are FULL-FIDELITY (raw) 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.`
+    ];
+}
+function rawScreenshotStreamIds(bundle) {
+    const rawStreamIds = [];
+    for (const stream of bundle.streams) {
+        const trace = stream.actor;
+        if (isRecord(trace) && isRecord(trace.redaction) && trace.redaction.screenshots === "raw") {
+            rawStreamIds.push(stream.id);
+        }
+    }
+    return rawStreamIds;
+}
+function buildShareSafety(args) {
+    const reasons = [];
+    if (!args.ok) {
+        reasons.push({
+            code: "VERIFY_FAILED",
+            message: "The run bundle is not valid enough to promote into public feedback."
+        });
+    }
+    if (args.publicSafetyFindings.length > 0) {
+        reasons.push({
+            code: "PUBLIC_SAFETY_FINDINGS",
+            message: "Text artifacts or public-proof paths matched known secret, token, local-path, browser-profile, or hosted-substrate URL patterns."
+        });
+    }
+    const rawStreamIds = rawScreenshotStreamIds(args.bundle);
+    if (rawStreamIds.length > 0) {
+        reasons.push({
+            code: "RAW_SCREENSHOTS",
+            message: `Full-fidelity screenshots are present on ${rawStreamIds.join(", ")}. This is valid local evidence, but not share-ready as-is.`
+        });
+    }
+    if (reasons.some((reason) => reason.code === "VERIFY_FAILED" || reason.code === "PUBLIC_SAFETY_FINDINGS")) {
+        return { status: "blocked", reasons };
+    }
+    if (reasons.length > 0) {
+        return { status: "local_only", reasons };
+    }
+    return { status: "share_ready", reasons: [] };
+}
+// The promptDigest convention: sha256 hex, first 16 chars. A "seeded" record without a real
+// digest cannot pin "same recipe" across bundles, so verify treats it as a hollow claim.
+const COMMAND_DIGEST_PATTERN = /^[0-9a-f]{16}$/;
+// Env var NAME shape (mirrors lab-config's ENV_NAME_PATTERN). externalEnvNames must hold
+// NAMES only — a value sneaking into the list trips this check (a free secret tripwire).
+const SUBJECT_ENV_NAME_PATTERN = /^[A-Z][A-Z0-9_]*$/;
+/**
+ * The `subject state provenance` check (invariant 5 + invariant 4): a bundle's subject CLAIM
+ * must match its recorded evidence. Bundles without a subject block (all pre-existing and
+ * non-cua bundles) pass untouched. Live-vs-dry-run is judged from bundle.mode, exactly like
+ * noEngagementActorFindings. Covers both the state story (seed/external) and, for the
+ * local-tree route, the archive content pin.
+ */
+function subjectStateFindings(bundle) {
+    const subject = bundle.subject;
+    if (subject === undefined) {
+        return [];
+    }
+    const findings = [];
+    const state = subject.state;
+    const seed = state.seed ?? [];
+    const live = bundle.mode === "live";
+    // Local-tree fail-closed pin: a LIVE local-tree subject must carry a well-formed archive
+    // digest -- a dirty tree cannot be commit-pinned, so archiveSha256 is the only content pin
+    // this route has. Mirrors the seeded-on-dry-run discriminator immediately below: judged by
+    // bundle.mode, never by the presence/shape of other fields. Never echoes the malformed value
+    // (it could itself be a leaked value, same discipline as the externalEnvNames check below).
+    if (live && subject.source === "local-tree") {
+        // Note: a malformed-but-present string is already rejected upstream by the
+        // isRunSubjectProvenance shape gate, so in practice this branch fires for the
+        // MISSING case; the pattern re-check stays as defense in depth for callers
+        // that bypass the schema gate.
+        const pin = subject.archiveSha256;
+        if (typeof pin !== "string" || !ARCHIVE_SHA256_PATTERN.test(pin)) {
+            findings.push("subject.source is local-tree on a live run but archiveSha256 is missing or malformed (a local-tree subject must carry a well-formed 64-hex archive digest)");
+        }
+    }
+    // Marker-independent rule: a passed LIVE run can never ride on a seed step that did not
+    // complete ok (closes the hollow-seeded × unpinned hole — an unpinned bundle still carries
+    // its seed records, and a failed migration must not hide behind the external marker).
+    if (live && bundle.review.verdict === "pass" && seed.some((record) => record.ok !== true)) {
+        findings.push("review verdict is pass but a recorded seed step did not complete ok — a passed live run cannot carry failed or unexecuted state steps");
+    }
+    switch (state.provenance) {
+        case "seeded": {
+            if (!live) {
+                findings.push('state marker "seeded" on a dry-run bundle — a contract bundle cannot claim executed state');
+            }
+            if (seed.length === 0) {
+                findings.push('state marker "seeded" with zero seed step records is a hollow state claim');
+            }
+            for (const record of seed) {
+                if (!COMMAND_DIGEST_PATTERN.test(record.commandDigest)) {
+                    findings.push(`seed step "${record.name}" lacks a sha256-16 commandDigest`);
+                }
+                if (live && record.ok !== true) {
+                    findings.push(`state marker "seeded" but step "${record.name}" did not complete ok`);
+                }
+            }
+            break;
+        }
+        case "unpinned": {
+            const externalEnvNames = state.externalEnvNames ?? [];
+            if (externalEnvNames.length === 0) {
+                findings.push('state marker "unpinned" requires non-empty externalEnvNames (the declaration must name the external channel)');
+            }
+            for (const name of externalEnvNames) {
+                if (!SUBJECT_ENV_NAME_PATTERN.test(name)) {
+                    // Deliberately does NOT echo the entry: a malformed entry may BE a value.
+                    findings.push("externalEnvNames carries an entry that is not an env var NAME shape (values must never appear in evidence)");
+                }
+            }
+            break;
+        }
+        case "declared-not-run": {
+            if (live && bundle.review.verdict === "pass") {
+                findings.push("a passed live run cannot claim its declared seed steps did not run (state marker \"declared-not-run\")");
+            }
+            break;
+        }
+        case "undeclared":
+            break;
+        default:
+            findings.push("unknown subject state provenance marker");
+    }
+    return findings;
+}
+function rerunLineageFindings(bundle) {
+    const rerun = bundle.rerun;
+    if (!rerun) {
+        return [];
+    }
+    const findings = [];
+    const selectedLaneIds = rerun.selectedLaneIds;
+    const selectedSet = new Set(selectedLaneIds);
+    const previousLaneIds = rerun.previous.map((entry) => entry.laneId);
+    const previousSet = new Set(previousLaneIds);
+    const currentLaneIds = bundle.streams.map((stream) => stream.laneId);
+    const currentConcreteLaneIds = currentLaneIds.filter((laneId) => typeof laneId === "string" && laneId.trim().length > 0);
+    const currentSet = new Set(currentConcreteLaneIds);
+    if (selectedSet.size !== selectedLaneIds.length) {
+        findings.push("selectedLaneIds contains duplicate lane ids");
+    }
+    if (previousSet.size !== previousLaneIds.length) {
+        findings.push("previous contains duplicate lane ids");
+    }
+    if (currentConcreteLaneIds.length !== bundle.streams.length) {
+        findings.push("every rerun stream must carry a laneId");
+    }
+    for (const laneId of selectedLaneIds) {
+        if (!previousSet.has(laneId)) {
+            findings.push(`selected lane ${laneId} is missing prior status`);
+        }
+        if (!currentSet.has(laneId)) {
+            findings.push(`selected lane ${laneId} is missing from current streams`);
+        }
+    }
+    for (const laneId of previousLaneIds) {
+        if (!selectedSet.has(laneId)) {
+            findings.push(`previous lane ${laneId} was not selected`);
+        }
+    }
+    for (const laneId of currentConcreteLaneIds) {
+        if (!selectedSet.has(laneId)) {
+            findings.push(`current stream lane ${laneId} was not selected`);
+        }
+    }
+    if (!bundle.events.some((event) => event.type === "cua-lab.fanout.rerun")) {
+        findings.push("missing cua-lab.fanout.rerun event");
+    }
+    return findings;
+}
+// SEQUENTIAL: the three disclosures a sequential shared-world bundle MUST pin (verify fails closed
+// if any is absent — omission overclaims): sequential turns only, no concurrency/races handled, and
+// a checkpoint delta is attributed to the TURN it followed, not a specific action (correlation).
+const MANDATORY_ATTRIBUTION_LIMITS = [
+    "sequential-only",
+    "no-concurrent-races",
+    "delta-attributed-to-turn-not-action"
+];
+// CONCURRENT (#164 phase 2, FIX-5): the REQUIRED set (all must be present) AND a FORBIDDEN set (any
+// present == a sequential claim leaking into a concurrent bundle == overclaim). verify needs BOTH
+// checks — presence-only would let an incoherent union pass.
+const CONCURRENT_REQUIRED_LIMITS = [
+    "concurrent",
+    "best-effort-causal-attribution",
+    "non-deterministic-shared-state",
+    "window-and-snapshot-granularity",
+    "contention-observed-not-proven-safe",
+    "state-change-not-isolated-to-actors"
+];
+const CONCURRENT_FORBIDDEN_LIMITS = ["sequential-only", "no-concurrent-races"];
+// A shared-world checkpoint record persists DIGEST-ONLY: exactly these keys, nothing value-shaped.
+const SHARED_WORLD_CHECKPOINT_KEYS = new Set(["kind", "name", "digest", "deltaFromPrev"]);
+// CONCURRENT stateSeries record is DIGEST-ONLY too (FIX-7): permit ONLY a numeric timestamp + the
+// sha256-16 digest; any other key is a value-shaped leak / a smuggled per-delta→actor field.
+const SHARED_WORLD_STATESERIES_KEYS = new Set(["timestamp", "digest"]);
+/**
+ * The `shared-world evidence` check (#164; invariant 4 + invariant 6): a LIVE shared-world bundle's
+ * interaction CLAIM must match its recorded timeline + plane provenance, and its attribution
+ * ceiling must be pinned. Mirrors validateTerminalProductEvidence: live-only (dry-run contract
+ * bundles are skipped, exactly like the other live-only checks). Fail-closed on every overclaim.
+ */
+function sharedWorldEvidenceFindings(bundle) {
+    if (bundle.mode !== "live") {
+        return [];
+    }
+    const sw = bundle.sharedWorld;
+    if (!sw) {
+        // A live bundle that DECLARES shared-world attribution but carries no evidence block is a
+        // hollow claim — fail closed. (Absent attributionClass + absent block == an ordinary bundle.)
+        return bundle.attributionClass === "shared-world"
+            ? ["attributionClass is shared-world but the sharedWorld evidence block is missing"]
+            : [];
+    }
+    // FIX-8: dispatch on topologyMode FIRST; unknown/missing → fail closed.
+    const topologyMode = sw.topologyMode;
+    if (topologyMode === "sequential") {
+        return sequentialSharedWorldFindings(bundle, sw);
+    }
+    if (topologyMode === "concurrent") {
+        return concurrentSharedWorldFindings(bundle, sw);
+    }
+    return ['sharedWorld.topologyMode must be "sequential" or "concurrent" (missing/unknown → fail closed)'];
+}
+/** Common shape findings shared by both topologyMode branches. */
+function sharedWorldCommonFindings(bundle, sw) {
+    const findings = [];
+    if (sw.schema !== SHARED_WORLD_SCHEMA) {
+        findings.push(`sharedWorld.schema must be ${SHARED_WORLD_SCHEMA}`);
+    }
+    if (bundle.attributionClass !== "shared-world") {
+        findings.push("a sharedWorld evidence block requires attributionClass: shared-world");
+    }
+    const plane = sw.plane;
+    if (!isRecord(plane) || typeof plane.seedDigest !== "string" || !COMMAND_DIGEST_PATTERN.test(plane.seedDigest)) {
+        findings.push("sharedWorld.plane.seedDigest must be a sha256-16 value");
+    }
+    if (isRecord(plane) && Array.isArray(plane.envNames)) {
+        for (const name of plane.envNames) {
+            if (typeof name !== "string" || !SUBJECT_ENV_NAME_PATTERN.test(name)) {
+                // Does NOT echo the entry: a malformed entry may BE a value.
+                findings.push("sharedWorld.plane.envNames carries an entry that is not an env var NAME shape (values must never appear in evidence)");
+            }
+        }
+    }
+    return findings;
+}
+/**
+ * SEQUENTIAL branch (the PoC #164): the alternating timeline must be well-formed, single-plane,
+ * digest-only, and carry the sequential attributionLimits. FIX-8: a sequential bundle must NOT
+ * carry concurrent fields (laneWindows).
+ */
+function sequentialSharedWorldFindings(bundle, sw) {
+    const findings = sharedWorldCommonFindings(bundle, sw);
+    // Read the raw record so an injected value-shaped field on a checkpoint is visible (the typed
+    // view would hide unexpected keys).
+    const rawTimeline = Array.isArray(sw.timeline)
+        ? (sw.timeline)
+        : [];
+    if (!Array.isArray(sw.timeline)) {
+        findings.push("a sequential shared-world bundle must carry a timeline");
+    }
+    if (Array.isArray(sw.laneWindows)) {
+        findings.push("a sequential shared-world bundle must NOT carry concurrent laneWindows (topologyMode mismatch)");
+    }
+    const sequence = Array.isArray(sw.sequence) ? sw.sequence : [];
+    // Attribution ceiling: every mandatory limit MUST be present (omission overclaims → fail).
+    const limits = Array.isArray(sw.attributionLimits) ? sw.attributionLimits : [];
+    for (const required of MANDATORY_ATTRIBUTION_LIMITS) {
+        if (!limits.includes(required)) {
+            findings.push(`attributionLimits is missing the mandatory disclosure "${required}" — an absent ceiling overclaims`);
+        }
+    }
+    const checkpoints = rawTimeline.filter((entry) => isRecord(entry) && entry.kind === "checkpoint");
+    const turns = rawTimeline.filter((entry) => isRecord(entry) && entry.kind === "turn");
+    // Phantom/dropped role: sequence length == roleCount == executed-turn count.
+    if (!(sequence.length === sw.roleCount && turns.length === sw.roleCount)) {
+        findings.push(`phantom/dropped role: sequence length (${sequence.length}), roleCount (${sw.roleCount}), and timeline turn count (${turns.length}) must all match`);
+    }
+    // Timeline well-formed: starts with cp-baseline, strictly alternates checkpoint → turn →
+    // checkpoint, ends on a checkpoint, and turn order == sequence.
+    if (rawTimeline.length === 0) {
+        findings.push("timeline is empty");
+    }
+    else {
+        const first = rawTimeline[0];
+        if (!isRecord(first) || first.kind !== "checkpoint" || first.name !== "cp-baseline") {
+            findings.push('timeline must start with the "cp-baseline" checkpoint');
+        }
+        const last = rawTimeline[rawTimeline.length - 1];
+        if (!isRecord(last) || last.kind !== "checkpoint") {
+            findings.push("timeline must end on a checkpoint");
+        }
+        rawTimeline.forEach((entry, index) => {
+            const expected = index % 2 === 0 ? "checkpoint" : "turn";
+            if (!isRecord(entry) || entry.kind !== expected) {
+                findings.push(`timeline must strictly alternate checkpoint → turn → checkpoint (index ${index} is not a ${expected})`);
+            }
+        });
+        if (rawTimeline.length !== 1 + 2 * turns.length) {
+            findings.push("timeline length must be 1 baseline checkpoint + 2 entries (turn + checkpoint) per role");
+        }
+    }
+    turns.forEach((turn, index) => {
+        if (turn.roleId !== sequence[index]) {
+            findings.push(`turn order does not match the declared sequence at position ${index} (turn "${String(turn.roleId)}" vs sequence "${String(sequence[index])}")`);
+        }
+    });
+    // Checkpoints: digest is sha256-16 and the record carries NO value-shaped field (digest-only).
+    for (const checkpoint of checkpoints) {
+        const name = typeof checkpoint.name === "string" ? checkpoint.name : "(unnamed)";
+        if (typeof checkpoint.digest !== "string" || !COMMAND_DIGEST_PATTERN.test(checkpoint.digest)) {
+            findings.push(`checkpoint "${name}" digest is not a sha256-16 value (a value-shaped checkpoint field is rejected)`);
+        }
+        for (const key of Object.keys(checkpoint)) {
+            if (!SHARED_WORLD_CHECKPOINT_KEYS.has(key)) {
+                findings.push(`checkpoint "${name}" carries an unexpected field "${key}" — checkpoints persist digest-only`);
+            }
+        }
+    }
+    // Turns: simId/streamId resolve to a real sim/stream.
+    for (const turn of turns) {
+        const roleId = typeof turn.roleId === "string" ? turn.roleId : "(unnamed)";
+        if (!bundle.simulations.some((sim) => sim.id === turn.simId)) {
+            findings.push(`turn "${roleId}" references unknown simId "${String(turn.simId)}"`);
+        }
+        if (!bundle.streams.some((stream) => stream.id === turn.streamId)) {
+            findings.push(`turn "${roleId}" references unknown streamId "${String(turn.streamId)}"`);
+        }
+    }
+    // Single-plane provenance: every turn shares ONE (commit, seedDigest), matching sharedWorld.plane.
+    // (plane.seedDigest + plane.envNames shape are checked in sharedWorldCommonFindings.)
+    const plane = sw.plane;
+    const planeKeys = new Set(turns.map((turn) => `${String(turn.commit ?? "")}::${String(turn.seedDigest ?? "")}`));
+    if (planeKeys.size > 1) {
+        findings.push("turns reference divergent plane provenance (commit/seedDigest) — a shared-world run drives ONE plane");
+    }
+    if (isRecord(plane)) {
+        for (const turn of turns) {
+            if (String(turn.seedDigest ?? "") !== String(plane.seedDigest ?? "")
+                || String(turn.commit ?? "") !== String(plane.commit ?? "")) {
+                const roleId = typeof turn.roleId === "string" ? turn.roleId : "(unnamed)";
+                findings.push(`turn "${roleId}" plane provenance diverges from sharedWorld.plane`);
+                break;
+            }
+        }
+    }
+    // The delta-on-pass gate: a PASSED shared-world run MUST show at least one checkpoint delta —
+    // otherwise the roles never interacted through shared state and the claim is hollow.
+    if (bundle.review.verdict === "pass" && !checkpoints.some((checkpoint) => checkpoint.deltaFromPrev === true)) {
+        findings.push("review verdict is pass but no checkpoint shows deltaFromPrev — the interaction is hollow (no observed shared-state change)");
+    }
+    return findings;
+}
+/**
+ * CONCURRENT branch (#164 phase 2): N personas drove ONE getHost-exposed plane at once. Verify
+ * fail-closed: the shape (laneWindows + stateSeries + outcomes, NO timeline — FIX-8); the
+ * corrected required + forbidden attributionLimits (FIX-5); the harness-minted getHost target every
+ * actor drove (FIX-2); the synthetic-subject provenance gate (FIX-3); digest-only state series with
+ * the allowed-keys tripwire (FIX-7); single-plane provenance; and the concurrency-on-pass gate
+ * (genuine overlap + a state delta AT/AFTER an overlap start — FIX-6).
+ */
+function concurrentSharedWorldFindings(bundle, sw) {
+    const findings = sharedWorldCommonFindings(bundle, sw);
+    // FIX-8: shape coherence — concurrent carries laneWindows/stateSeries/outcomes, NOT a timeline.
+    if (Array.isArray(sw.timeline)) {
+        findings.push("a concurrent shared-world bundle must NOT carry a sequential timeline (topologyMode mismatch)");
+    }
+    const laneWindows = Array.isArray(sw.laneWindows) ? sw.laneWindows.filter(isRecord) : null;
+    const stateSeries = Array.isArray(sw.stateSeries) ? sw.stateSeries.filter(isRecord) : null;
+    const outcomes = Array.isArray(sw.outcomes) ? sw.outcomes.filter(isRecord) : null;
+    if (laneWindows === null)
+        findings.push("a concurrent shared-world bundle must carry laneWindows");
+    if (stateSeries === null)
+        findings.push("a concurrent shared-world bundle must carry stateSeries");
+    if (outcomes === null)
+        findings.push("a concurrent shared-world bundle must carry outcomes");
+    if (laneWindows === null || stateSeries === null || outcomes === null) {
+        return findings; // can't reason further without the core series
+    }
+    // FIX-5: required limits all present AND forbidden limits all absent.
+    const limits = Array.isArray(sw.attributionLimits) ? sw.attributionLimits : [];
+    for (const required of CONCURRENT_REQUIRED_LIMITS) {
+        if (!limits.includes(required)) {
+            findings.push(`attributionLimits is missing the mandatory concurrent disclosure "${required}" — an absent ceiling overclaims`);
+        }
+    }
+    for (const forbidden of CONCURRENT_FORBIDDEN_LIMITS) {
+        if (limits.includes(forbidden)) {
+            findings.push(`attributionLimits carries the forbidden disclosure "${forbidden}" — a concurrent run cannot claim a sequential guarantee`);
+        }
+    }
+    // Phantom/dropped role: laneWindows + outcomes each cover exactly roleCount (actors are
+    // INDEPENDENT — none are blocked by another, so all N produce a window + outcome).
+    if (laneWindows.length !== sw.roleCount) {
+        findings.push(`phantom/dropped role: laneWindows count (${laneWindows.length}) must equal roleCount (${sw.roleCount})`);
+    }
+    if (outcomes.length !== sw.roleCount) {
+        findings.push(`phantom/dropped role: outcomes count (${outcomes.length}) must equal roleCount (${sw.roleCount})`);
+    }
+    // laneWindows: numeric well-ordered windows; sim/stream resolve; route-host digest present.
+    for (const window of laneWindows) {
+        const roleId = typeof window.roleId === "string" ? window.roleId : "(unnamed)";
+        const startedAt = window.startedAt;
+        const endedAt = window.endedAt;
+        if (typeof startedAt !== "number" || typeof endedAt !== "number" || !(startedAt <= endedAt)) {
+            findings.push(`laneWindow "${roleId}" must carry numeric startedAt <= endedAt on one clock`);
+        }
+        if (typeof window.routeHostDigest !== "string" || !COMMAND_DIGEST_PATTERN.test(window.routeHostDigest)) {
+            findings.push(`laneWindow "${roleId}" must record a sha256-16 routeHostDigest of the host it drove`);
+        }
+        if (!bundle.simulations.some((sim) => sim.id === window.simId)) {
+            findings.push(`laneWindow "${roleId}" references unknown simId "${String(window.simId)}"`);
+        }
+        if (!bundle.streams.some((stream) => stream.id === window.streamId)) {
+            findings.push(`laneWindow "${roleId}" references unknown streamId "${String(window.streamId)}"`);
+        }
+    }
+    // FIX-2: the harness-minted getHost target. plane.hostDigest present (sha256-16) + every actor's
+    // routeHostDigest equals it (every actor drove EXACTLY the harness-minted host — invariant 2).
+    const plane = isRecord(sw.plane) ? sw.plane : {};
+    const hostDigest = typeof plane.hostDigest === "string" ? plane.hostDigest : undefined;
+    if (!hostDigest || !COMMAND_DIGEST_PATTERN.test(hostDigest)) {
+        findings.push("sharedWorld.plane.hostDigest (sha256-16 of the harness-minted getHost origin) is required on the concurrent route");
+    }
+    else {
+        for (const window of laneWindows) {
+            const roleId = typeof window.roleId === "string" ? window.roleId : "(unnamed)";
+            if (typeof window.routeHostDigest === "string" && window.routeHostDigest !== hostDigest) {
+                findings.push(`laneWindow "${roleId}" drove a host that differs from the harness-minted plane.hostDigest (invariant 2)`);
+            }
+        }
+    }
+    // FIX-3: synthetic-subject provenance gate (a getHost URL is internet-reachable; real/external
+    // data behind it is the hazard). Author attestation + a seeded provenance check.
+    if (plane.exposure !== "synthetic") {
+        findings.push('sharedWorld.plane.exposure must be "synthetic" — the getHost route requires the author attestation that the subject is synthetic seeded data (author-trust + provenance gate, not a no-real-data guarantee)');
+    }
+    if (bundle.subject?.state.provenance !== "seeded") {
+        findings.push(`the concurrent getHost route requires subject.state.provenance == "seeded" (got "${bundle.subject?.state.provenance ?? "absent"}") — external/unpinned/undeclared data behind an internet-reachable URL is rejected`);
+    }
+    // Single-plane provenance: every laneWindow shares ONE (commit, seedDigest) matching plane.
+    const planeKeys = new Set(laneWindows.map((window) => `${String(window.commit ?? "")}::${String(window.seedDigest ?? "")}`));
+    if (planeKeys.size > 1) {
+        findings.push("laneWindows reference divergent plane provenance (commit/seedDigest) — a concurrent run drives ONE plane");
+    }
+    for (const window of laneWindows) {
+        if (String(window.seedDigest ?? "") !== String(plane.seedDigest ?? "")
+            || String(window.commit ?? "") !== String(plane.commit ?? "")) {
+            const roleId = typeof window.roleId === "string" ? window.roleId : "(unnamed)";
+            findings.push(`laneWindow "${roleId}" plane provenance diverges from sharedWorld.plane`);
+            break;
+        }
+    }
+    // FIX-7: stateSeries is DIGEST-ONLY with the allowed-keys tripwire (no per-delta→actor field).
+    for (const snapshot of stateSeries) {
+        if (typeof snapshot.timestamp !== "number") {
+            findings.push("a stateSeries snapshot must carry a numeric timestamp");
+        }
+        if (typeof snapshot.digest !== "string" || !COMMAND_DIGEST_PATTERN.test(snapshot.digest)) {
+            findings.push("a stateSeries snapshot digest is not a sha256-16 value (a value-shaped field is rejected)");
+        }
+        for (const key of Object.keys(snapshot)) {
+            if (!SHARED_WORLD_STATESERIES_KEYS.has(key)) {
+                findings.push(`a stateSeries snapshot carries an unexpected field "${key}" — the series is digest-only (no per-delta attribution)`);
+            }
+        }
+    }
+    // The concurrency-on-pass gate (FIX-6): a PASSED concurrent run MUST show genuine overlap (≥2
+    // laneWindows overlapping in time) AND a stateSeries delta whose timestamp is AT/AFTER the start
+    // of an overlap interval — otherwise it was not actually concurrent, or the world never changed
+    // under contention (a hollow concurrent claim).
+    if (bundle.review.verdict === "pass") {
+        const overlapStarts = [];
+        for (let i = 0; i < laneWindows.length; i += 1) {
+            for (let j = i + 1; j < laneWindows.length; j += 1) {
+                const a = laneWindows[i];
+                const b = laneWindows[j];
+                const aStart = a.startedAt;
+                const aEnd = a.endedAt;
+                const bStart = b.startedAt;
+                const bEnd = b.endedAt;
+                if (typeof aStart === "number" && typeof aEnd === "number" && typeof bStart === "number" && typeof bEnd === "number"
+                    && aStart < bEnd && bStart < aEnd) {
+                    overlapStarts.push(Math.max(aStart, bStart));
+                }
+            }
+        }
+        if (overlapStarts.length === 0) {
+            findings.push("review verdict is pass but no two laneWindows overlap in time — the run was not actually concurrent");
+        }
+        else {
+            const earliestOverlapStart = Math.min(...overlapStarts);
+            const sorted = [...stateSeries]
+                .map((snapshot) => ({ timestamp: snapshot.timestamp, digest: String(snapshot.digest) }))
+                .filter((snapshot) => typeof snapshot.timestamp === "number")
+                .sort((x, y) => x.timestamp - y.timestamp);
+            let deltaInWindow = false;
+            for (let i = 1; i < sorted.length; i += 1) {
+                if (sorted[i].digest !== sorted[i - 1].digest && sorted[i].timestamp >= earliestOverlapStart) {
+                    deltaInWindow = true;
+                    break;
+                }
+            }
+            if (!deltaInWindow) {
+                findings.push("review verdict is pass but no stateSeries delta occurs at/after an overlap interval start — the shared world did not change under concurrent load (hollow concurrent claim)");
+            }
+        }
+    }
+    return findings;
+}
+/**
+ * Advisory (never flips ok): a LIVE clone bundle whose subject env is provisioned while its
+ * state story is undeclared probably points at state the lab does not control. Emitted at
+ * most ONCE per bundle (the subject block is bundle-level, never per stream). GITHUB_TOKEN
+ * is mechanically excluded: the harness consumes that name for clone auth — it carries no
+ * state implication.
+ */
+function undeclaredSubjectStateWarnings(bundle) {
+    const subject = bundle.subject;
+    if (subject === undefined || bundle.mode !== "live" || subject.source !== "clone") {
+        return [];
+    }
+    if (subject.state.provenance !== "undeclared") {
+        return [];
+    }
+    const stateRelevantEnvNames = (subject.envNames ?? []).filter((name) => name !== "GITHUB_TOKEN");
+    if (stateRelevantEnvNames.length === 0) {
+        return [];
+    }
+    return [
+        `Subject env is provisioned (${stateRelevantEnvNames.join(", ")}) but no state story is declared; if any name points at external state, declare subject.state.external (recorded UNPINNED) or seed in-sandbox state with subject.state.seed.`
+    ];
+}
+const riskyPublicArtifactPathSegments = new Set([
+    ".git",
+    "Cookies",
+    "Login Data",
+    "Local Storage",
+    "Preferences",
+    "Secure Preferences",
+    "profiles"
+]);
+async function scanRunPublicSafetyArtifacts(runPaths) {
+    const findings = [];
+    await validatePreparedRunArtifactPaths(runPaths);
+    await scanRunPublicSafetyDirectory(runPaths, "", findings);
+    await validatePreparedRunArtifactPaths(runPaths);
+    return findings;
+}
+async function scanRunPublicSafetyDirectory(runPaths, relativeDirectory, findings) {
+    if (findings.length >= 50) {
+        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;
+        if (isRiskyPublicArtifactPath(relativePath) || containsSensitivePattern(relativePath)) {
+            findings.push(`risky artifact path ${relativePath}`);
+            if (findings.length >= 50)
+                return;
+        }
+        const stats = await lstat(path.join(current, entryName), { bigint: true }).catch(() => null);
+        if (!stats || stats.isSymbolicLink() || (!stats.isDirectory() && !stats.isFile()) || (stats.isFile() && stats.nlink > 1n)) {
+            findings.push(`unsafe artifact leaf ${relativePath}`);
+            if (findings.length >= 50)
+                return;
+            continue;
+        }
+        if (stats.isDirectory()) {
+            await scanRunPublicSafetyDirectory(runPaths, relativePath, findings);
+            if (findings.length >= 50)
+                return;
+            continue;
+        }
+        if (!shouldScanTextArtifact(relativePath)) {
+            continue;
+        }
+        const bytes = await readSafeRunArtifactBytes(runPaths, relativePath);
+        const text = bytes?.toString("utf8") ?? null;
+        if (text !== null && containsSensitivePattern(text)) {
+            findings.push(`sensitive text ${relativePath}`);
+            if (findings.length >= 50)
+                return;
+        }
+    }
+}
+function isRiskyPublicArtifactPath(relativePath) {
+    return relativePath.split(/[\\/]/).some((segment) => riskyPublicArtifactPathSegments.has(segment));
+}
+function shouldScanTextArtifact(relativePath) {
+    const extension = path.extname(relativePath).toLowerCase();
+    return ![".png", ".jpg", ".jpeg", ".webp", ".gif", ".tgz", ".gz", ".zip"].includes(extension);
+}
+function isLocalEvidenceArtifactPath(value) {
+    const normalized = value.replace(/\\/g, "/");
+    return value.length > 0
+        && !/^\[[a-z0-9._-]+\]$/i.test(normalized)
+        && !path.isAbsolute(normalized)
+        && !normalized.includes("://")
+        && !normalized.startsWith("..")
+        && !normalized.split("/").includes("..")
+        && !isRiskyPublicArtifactPath(normalized);
+}
+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;
+}
+async function validateCwd(cwd) {
+    try {
+        const stats = await stat(cwd);
+        if (!stats.isDirectory()) {
+            return {
+                code: "HUMANISH_INVALID_CWD",
+                message: `Target cwd is not a directory: ${cwd}`
+            };
+        }
+        return null;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return {
+                code: "HUMANISH_INVALID_CWD",
+                message: `Target cwd does not exist: ${cwd}`
+            };
+        }
+        throw error;
+    }
+}
+function containsSensitivePattern(text) {
+    return containsSensitive(text);
+}
+function redactSensitiveText(text) {
+    return redactToSecretLabel(text);
+}
+function isRunBundle(value) {
+    return isRecord(value)
+        && value.schema === RUN_BUNDLE_SCHEMA
+        && typeof value.runId === "string"
+        && (value.mode === "dry-run" || value.mode === "live")
+        && isPositiveSafeInteger(value.simCount)
+        && typeof value.createdAt === "string"
+        && value.cwd === PUBLIC_TARGET_CWD
+        && typeof value.artifactRoot === "string"
+        && isRunSource(value.source)
+        && isPersonaSummary(value.persona)
+        && isScenarioSummary(value.scenario)
+        && Array.isArray(value.lifecycle)
+        && value.lifecycle.every(isLifecycleEvent)
+        && Array.isArray(value.simulations)
+        && value.simulations.length === value.simCount
+        && value.simulations.every(isRunSimulation)
+        && Array.isArray(value.streams)
+        && value.streams.every(isRunStream)
+        && hasConsistentSimulationStreams(value.simulations, value.streams)
+        && Array.isArray(value.events)
+        && value.events.every(isRunEvent)
+        && isRunArtifactIndex(value.artifacts)
+        && isRecord(value.review)
+        && isReviewSummary(value.review)
+        && isRecord(value.redaction)
+        && value.redaction.status === "passed"
+        && Array.isArray(value.feedbackCandidates)
+        && value.feedbackCandidates.every(isRunFeedbackCandidate)
+        // Optional and additive: pre-existing bundles (and non-cua backends) carry no subject
+        // block; when present it must be well-shaped (semantics are the verify check's job).
+        && (value.subject === undefined || isRunSubjectProvenance(value.subject))
+        && (value.desktopBrowser === undefined || isDesktopBrowserEvidence(value.desktopBrowser))
+        && (value.rerun === undefined || isRunRerunLineage(value.rerun))
+        // Optional + additive shared-world fields (#164). Tolerant SHAPE guard only — the interaction
+        // semantics (timeline well-formedness, single-plane, delta-on-pass) are the verify check's job.
+        && (value.attributionClass === undefined || value.attributionClass === "isolated" || value.attributionClass === "shared-world")
+        && (value.sharedWorld === undefined || isSharedWorldEvidence(value.sharedWorld))
+        // Optional, adapter-namespaced product score (the extension seam). When present, validate only
+        // its SHAPE; core never reads the adapter's `data` payload.
+        && (value.adapterScore === undefined || isRunAdapterScore(value.adapterScore))
+        && (value.adapterArtifacts === undefined
+            || (Array.isArray(value.adapterArtifacts) && value.adapterArtifacts.every(isRunAdapterArtifact)))
+        && (value.providerResources === undefined
+            || (Array.isArray(value.providerResources) && value.providerResources.every(isRunProviderResource)));
+}
+function isRunProviderResource(value) {
+    return isRecord(value)
+        && value.schema === "humanish.provider-resource.v1"
+        && value.provider === "e2b-desktop"
+        && value.kind === "sandbox"
+        && typeof value.id === "string"
+        && value.id.trim().length > 0
+        && value.owner === "humanish"
+        && (value.status === "running" || value.status === "killed" || value.status === "unknown")
+        && (value.simId === undefined || typeof value.simId === "string")
+        && (value.streamId === undefined || typeof value.streamId === "string")
+        && (value.laneId === undefined || typeof value.laneId === "string")
+        && (value.createdAt === undefined || typeof value.createdAt === "string")
+        && (value.cleanup === undefined
+            || (isRecord(value.cleanup)
+                && typeof value.cleanup.killed === "boolean"
+                && typeof value.cleanup.reason === "string"));
+}
+function isCleanupResult(value) {
+    return isRecord(value)
+        && value.schema === CLEANUP_SCHEMA
+        && typeof value.ok === "boolean"
+        && typeof value.cwd === "string"
+        && typeof value.run === "string"
+        && typeof value.checkedAt === "string"
+        && (value.runId === undefined || typeof value.runId === "string")
+        && (value.bundlePath === undefined || typeof value.bundlePath === "string")
+        && (value.cleanupPath === undefined || typeof value.cleanupPath === "string")
+        && isRecord(value.summary)
+        && isNonNegativeSafeInteger(value.summary.resources)
+        && isNonNegativeSafeInteger(value.summary.killed)
+        && isNonNegativeSafeInteger(value.summary.alreadyClean)
+        && isNonNegativeSafeInteger(value.summary.failed)
+        && isNonNegativeSafeInteger(value.summary.skipped)
+        && Array.isArray(value.resources)
+        && value.resources.every(isCleanupResourceResult)
+        && Array.isArray(value.adapterResults)
+        && value.adapterResults.every(isCleanupAdapterResult)
+        && Array.isArray(value.warnings)
+        && value.warnings.every((warning) => typeof warning === "string");
+}
+function isCleanupResourceResult(value) {
+    return isRecord(value)
+        && value.provider === "e2b-desktop"
+        && value.kind === "sandbox"
+        && typeof value.id === "string"
+        && value.id.trim().length > 0
+        && (value.status === "killed" || value.status === "already_clean" || value.status === "failed" || value.status === "skipped")
+        && typeof value.message === "string";
+}
+function isCleanupAdapterResult(value) {
+    return isRecord(value)
+        && typeof value.id === "string"
+        && value.id.trim().length > 0
+        && typeof value.ok === "boolean"
+        && typeof value.message === "string";
+}
+function isRunRerunLineage(value) {
+    return isRecord(value)
+        && typeof value.sourceRunId === "string"
+        && value.sourceRunId.trim().length > 0
+        && Array.isArray(value.selectedLaneIds)
+        && value.selectedLaneIds.length > 0
+        && value.selectedLaneIds.every((laneId) => typeof laneId === "string" && laneId.trim().length > 0)
+        && Array.isArray(value.previous)
+        && value.previous.length > 0
+        && value.previous.every((entry) => isRecord(entry)
+            && typeof entry.laneId === "string"
+            && entry.laneId.trim().length > 0
+            && (entry.streamId === undefined || typeof entry.streamId === "string")
+            && typeof entry.status === "string"
+            && entry.status.trim().length > 0
+            && (entry.reason === undefined || typeof entry.reason === "string")
+            && (entry.actorStatus === undefined || typeof entry.actorStatus === "string")
+            && (entry.completionReason === undefined || typeof entry.completionReason === "string"));
+}
+function isDesktopBrowserEvidence(value) {
+    return isRecord(value)
+        && (value.requested === "default" || value.requested === "chrome" || value.requested === "chromium" || value.requested === "firefox")
+        && (value.resolved === undefined || typeof value.resolved === "string");
+}
+function isRunAdapterScore(value) {
+    return isRecord(value)
+        && value.schema === "humanish.adapter-score.v1"
+        && typeof value.namespace === "string"
+        && value.namespace.trim().length > 0
+        && (value.status === "pass" || value.status === "partial" || value.status === "fail")
+        && typeof value.score === "number"
+        && Number.isFinite(value.score)
+        && typeof value.summary === "string"
+        && (value.data === undefined || isRecord(value.data));
+}
+/**
+ * Tolerant SHAPE guard for the shared-world evidence block (#164). Validates required fields +
+ * types but TOLERATES extra keys (additive): the strict value-shape/timeline checks are
+ * sharedWorldEvidenceFindings' job (an injected value-shaped checkpoint field must pass the shape
+ * guard so verify can catch it fail-closed, not silently bounce off isRunBundle).
+ */
+function isSharedWorldEvidence(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.schema !== SHARED_WORLD_SCHEMA)
+        return false;
+    if (value.topology !== "shared-world")
+        return false;
+    if (!isNonNegativeSafeInteger(value.roleCount))
+        return false;
+    const plane = value.plane;
+    if (!isRecord(plane))
+        return false;
+    if (plane.commit !== undefined && typeof plane.commit !== "string")
+        return false;
+    if (typeof plane.seedDigest !== "string")
+        return false;
+    if (!(Array.isArray(plane.envNames) && plane.envNames.every((name) => typeof name === "string")))
+        return false;
+    if (plane.hostDigest !== undefined && typeof plane.hostDigest !== "string")
+        return false;
+    if (plane.exposure !== undefined && typeof plane.exposure !== "string")
+        return false;
+    if (!(Array.isArray(value.attributionLimits) && value.attributionLimits.every((limit) => typeof limit === "string")))
+        return false;
+    // Tolerant: validate the TYPE of each present field only (the coherence + topologyMode dispatch
+    // are validateSharedWorldEvidence's job — an injected value-shaped field must pass this guard so
+    // verify catches it fail-closed). A bundle must carry at least one of the two shapes.
+    if (value.sequence !== undefined && !(Array.isArray(value.sequence) && value.sequence.every((id) => typeof id === "string")))
+        return false;
+    if (value.timeline !== undefined && !(Array.isArray(value.timeline) && value.timeline.every(isSharedWorldTimelineEntry)))
+        return false;
+    if (value.laneWindows !== undefined && !(Array.isArray(value.laneWindows) && value.laneWindows.every(isSharedWorldLaneWindow)))
+        return false;
+    if (value.stateSeries !== undefined && !(Array.isArray(value.stateSeries) && value.stateSeries.every(isSharedWorldStateSnapshot)))
+        return false;
+    if (value.outcomes !== undefined && !(Array.isArray(value.outcomes) && value.outcomes.every(isSharedWorldOutcome)))
+        return false;
+    if (value.timeline === undefined && value.laneWindows === undefined)
+        return false;
+    return true;
+}
+function isSharedWorldTimelineEntry(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind === "checkpoint") {
+        return typeof value.name === "string"
+            && typeof value.digest === "string"
+            && typeof value.deltaFromPrev === "boolean";
+    }
+    if (value.kind === "turn") {
+        return typeof value.roleId === "string"
+            && typeof value.simId === "string"
+            && typeof value.streamId === "string"
+            && typeof value.seedDigest === "string"
+            && (value.commit === undefined || typeof value.commit === "string");
+    }
+    return false;
+}
+// Tolerant shape guards for the CONCURRENT series (extra keys tolerated — the digest-only /
+// allowed-keys tripwires are validateSharedWorldEvidence's strict job).
+function isSharedWorldLaneWindow(value) {
+    return isRecord(value)
+        && typeof value.roleId === "string"
+        && (value.actorType === undefined || typeof value.actorType === "string")
+        && (value.surface === undefined || typeof value.surface === "string")
+        && (value.caseGroup === undefined || typeof value.caseGroup === "string")
+        && typeof value.simId === "string"
+        && typeof value.streamId === "string"
+        && typeof value.startedAt === "number"
+        && typeof value.endedAt === "number"
+        && typeof value.verdict === "string"
+        && typeof value.routeHostDigest === "string"
+        && typeof value.seedDigest === "string"
+        && (value.commit === undefined || typeof value.commit === "string");
+}
+function isSharedWorldStateSnapshot(value) {
+    return isRecord(value) && typeof value.timestamp === "number" && typeof value.digest === "string";
+}
+function isSharedWorldOutcome(value) {
+    return isRecord(value)
+        && typeof value.roleId === "string"
+        && (value.actorType === undefined || typeof value.actorType === "string")
+        && (value.surface === undefined || typeof value.surface === "string")
+        && (value.caseGroup === undefined || typeof value.caseGroup === "string")
+        && typeof value.simId === "string"
+        && typeof value.streamId === "string"
+        && typeof value.status === "string"
+        && typeof value.ok === "boolean";
+}
+// The local-tree archive content pin: sha256 hex, full 64 chars (NOT the repo's 16-char
+// display-digest convention -- this value is the provenance pin itself, persisted in full).
+const ARCHIVE_SHA256_PATTERN = /^[a-f0-9]{64}$/;
+function isRunSubjectProvenance(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.source !== "clone" && value.source !== "app-url" && value.source !== "local-tree")
+        return false;
+    if (value.repo !== undefined && typeof value.repo !== "string")
+        return false;
+    if (value.commit !== undefined && typeof value.commit !== "string")
+        return false;
+    if (value.archiveSha256 !== undefined
+        && (typeof value.archiveSha256 !== "string" || !ARCHIVE_SHA256_PATTERN.test(value.archiveSha256))) {
+        return false;
+    }
+    if (value.dirty !== undefined && typeof value.dirty !== "boolean")
+        return false;
+    if (value.envNames !== undefined
+        && !(Array.isArray(value.envNames) && value.envNames.every((name) => typeof name === "string"))) {
+        return false;
+    }
+    const state = value.state;
+    if (!isRecord(state))
+        return false;
+    if (state.provenance !== "seeded" && state.provenance !== "unpinned"
+        && state.provenance !== "declared-not-run" && state.provenance !== "undeclared") {
+        return false;
+    }
+    if (state.seed !== undefined
+        && !(Array.isArray(state.seed) && state.seed.every(isRunSubjectStateStepRecord))) {
+        return false;
+    }
+    if (state.externalEnvNames !== undefined
+        && !(Array.isArray(state.externalEnvNames) && state.externalEnvNames.every((name) => typeof name === "string"))) {
+        return false;
+    }
+    return true;
+}
+function isRunSubjectStateStepRecord(value) {
+    return isRecord(value)
+        && typeof value.name === "string"
+        && (value.when === "before-build" || value.when === "before-start" || value.when === "after-ready")
+        && typeof value.commandDigest === "string"
+        && (value.ok === undefined || typeof value.ok === "boolean")
+        && (value.exitCode === undefined || typeof value.exitCode === "number")
+        && (value.timedOut === undefined || typeof value.timedOut === "boolean")
+        && (value.durationMs === undefined || typeof value.durationMs === "number");
+}
+function isRunSource(value) {
+    return isRecord(value)
+        && (typeof value.packageName === "string" || value.packageName === null)
+        && (value.humanishSource === "present" || value.humanishSource === "missing")
+        && isCapturedGitState(value.git);
+}
+function isCapturedGitState(value) {
+    return isRecord(value)
+        && value.schema === GIT_STATE_SCHEMA
+        && (value.status === "clean" || value.status === "dirty" || value.status === "missing" || value.status === "unavailable")
+        && typeof value.capturedAt === "string"
+        && isRecord(value.head)
+        && (isSafeGitShortSha(value.head.shortSha) || value.head.shortSha === null)
+        && (value.head.refState === "attached" || value.head.refState === "detached" || value.head.refState === "unborn" || value.head.refState === "unknown")
+        && isRecord(value.changes)
+        && isNonNegativeSafeInteger(value.changes.staged)
+        && isNonNegativeSafeInteger(value.changes.unstaged)
+        && isNonNegativeSafeInteger(value.changes.untracked)
+        && isNonNegativeSafeInteger(value.changes.total)
+        && typeof value.note === "string"
+        && SAFE_GIT_NOTES.has(value.note);
+}
+function isPersonaSummary(value) {
+    return isRecord(value)
+        && typeof value.id === "string"
+        && typeof value.name === "string"
+        && typeof value.source === "string"
+        && typeof value.sourceDigest === "string";
+}
+function isScenarioSummary(value) {
+    return isRecord(value)
+        && typeof value.id === "string"
+        && typeof value.title === "string"
+        && typeof value.goal === "string"
+        && typeof value.source === "string"
+        && typeof value.sourceDigest === "string";
+}
+function isLifecycleEvent(value) {
+    return isRecord(value)
+        && typeof value.at === "string"
+        && typeof value.event === "string"
+        && typeof value.message === "string";
+}
+function isRunSimulation(value) {
+    return isRecord(value)
+        && typeof value.id === "string"
+        && isPositiveSafeInteger(value.index)
+        && typeof value.personaId === "string"
+        && typeof value.scenarioId === "string"
+        && isRunSimulationStatus(value.status)
+        && isRunStreamKind(value.streamKind)
+        && (value.mode === "browser-sim" || value.mode === "cli-sim" || value.mode === "tui-sim" || value.mode === "codex-app-sim")
+        && typeof value.progress === "number"
+        && typeof value.currentStep === "string"
+        && typeof value.summary === "string"
+        && Array.isArray(value.streamIds)
+        && value.streamIds.every((streamId) => typeof streamId === "string")
+        && typeof value.startedAt === "string"
+        && typeof value.updatedAt === "string";
+}
+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"
+        && Array.isArray(value.artifacts)
+        && value.artifacts.every(isRunStreamArtifact);
+}
+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");
+}
+function isRunAdapterArtifact(value) {
+    return isRecord(value)
+        && value.schema === "humanish.adapter-artifact.v1"
+        && typeof value.namespace === "string"
+        && value.namespace.trim().length > 0
+        && typeof value.label === "string"
+        && value.label.trim().length > 0
+        && typeof value.path === "string"
+        && value.path.trim().length > 0
+        && isLocalEvidenceArtifactPath(value.path)
+        && (value.kind === "state"
+            || value.kind === "review"
+            || value.kind === "log"
+            || value.kind === "trace"
+            || value.kind === "screenshot"
+            || value.kind === "filesystem"
+            || value.kind === "summary")
+        && typeof value.note === "string"
+        && value.note.trim().length > 0;
+}
+function isRunEvent(value) {
+    return isRecord(value)
+        && typeof value.id === "string"
+        && typeof value.at === "string"
+        && (value.level === "info" || value.level === "warn" || value.level === "error")
+        && typeof value.type === "string"
+        && typeof value.message === "string";
+}
+function isRunArtifactIndex(value) {
+    return isRecord(value)
+        && typeof value.run === "string"
+        && typeof value.reviewJson === "string"
+        && typeof value.reviewMarkdown === "string"
+        && typeof value.observerData === "string"
+        && typeof value.events === "string";
+}
+function isRunFeedbackCandidate(value) {
+    return isRecord(value)
+        && value.schema === "humanish.feedback-candidate.v1"
+        && typeof value.id === "string"
+        && typeof value.run_id === "string"
+        && (typeof value.stream_id === "string" || value.stream_id === undefined)
+        && typeof value.adapter_id === "string"
+        && typeof value.scenario_id === "string"
+        && typeof value.persona_id === "string"
+        && isFeedbackActor(value.actor)
+        && isFeedbackSubstrate(value.substrate)
+        && isFeedbackFailureOwner(value.failure_owner)
+        && typeof value.summary === "string"
+        && typeof value.expected === "string"
+        && typeof value.actual === "string"
+        && Array.isArray(value.evidence)
+        && value.evidence.every(isRunFeedbackEvidence)
+        && isRecord(value.redaction)
+        && value.redaction.status === "passed"
+        && typeof value.redaction.notes === "string"
+        && typeof value.idempotency_key === "string"
+        && isFeedbackNextState(value.proposed_next_state)
+        && Array.isArray(value.acceptance_proof)
+        && value.acceptance_proof.every((item) => typeof item === "string")
+        // Optional, adapter-namespaced product-noun block: when present, validate only its SHAPE
+        // (a non-empty namespace + a data record). Core never inspects the keys inside `data`.
+        && (value.adapter === undefined || isFeedbackAdapterBlock(value.adapter));
+}
+function isFeedbackAdapterBlock(value) {
+    return isRecord(value)
+        && typeof value.namespace === "string"
+        && value.namespace.trim().length > 0
+        && isRecord(value.data);
+}
+function isRunFeedbackEvidence(value) {
+    return isRecord(value)
+        && typeof value.path === "string"
+        && value.path.length > 0
+        && !path.isAbsolute(value.path)
+        && !value.path.includes("://")
+        && !value.path.includes("..")
+        && (value.kind === "review"
+            || value.kind === "state"
+            || value.kind === "log"
+            || value.kind === "trace"
+            || value.kind === "screenshot"
+            || value.kind === "filesystem")
+        && typeof value.note === "string";
+}
+function hasConsistentSimulationStreams(simulations, streams) {
+    const simIds = new Set();
+    const expectedStreamSimIds = new Map();
+    const streamById = new Map();
+    for (const simulation of simulations) {
+        if (!isRunSimulation(simulation)) {
+            return false;
+        }
+        simIds.add(simulation.id);
+        for (const streamId of simulation.streamIds) {
+            if (expectedStreamSimIds.has(streamId)) {
+                return false;
+            }
+            expectedStreamSimIds.set(streamId, simulation.id);
+        }
+    }
+    for (const stream of streams) {
+        if (!isRunStream(stream) || !simIds.has(stream.simId) || streamById.has(stream.id)) {
+            return false;
+        }
+        const expectedSimId = expectedStreamSimIds.get(stream.id);
+        if (expectedSimId === undefined || stream.simId !== expectedSimId) {
+            return false;
+        }
+        streamById.set(stream.id, stream);
+    }
+    return streamById.size === expectedStreamSimIds.size;
+}
+function isRunSimulationStatus(value) {
+    return value === "queued"
+        || value === "preparing"
+        || value === "running"
+        || value === "passed"
+        || value === "complete"
+        || value === "blocked"
+        || value === "timed_out"
+        || value === "failed"
+        || value === "contract_proof_only";
+}
+function isRunStreamKind(value) {
+    return value === "ui"
+        || value === "browser"
+        || value === "terminal"
+        || value === "tui"
+        || value === "codex-ui"
+        || value === "artifact"
+        || value === "summary";
+}
+function isSafeGitShortSha(value) {
+    return typeof value === "string" && /^[a-f0-9]{7,12}$/.test(value);
+}
+function isFeedbackActor(value) {
+    return value === "codex-tui"
+        || value === "codex-exec"
+        || value === "codex-app-server"
+        || value === "synthetic-dry-run"
+        || value === "unknown";
+}
+function isFeedbackSubstrate(value) {
+    return value === "e2b-desktop"
+        || value === "e2b-terminal"
+        || value === "local-filesystem"
+        || value === "codex-app-server"
+        || value === "unknown";
+}
+function isFeedbackFailureOwner(value) {
+    return value === "harness"
+        || value === "target-app"
+        || value === "actor"
+        || value === "environment"
+        || value === "unknown";
+}
+function isFeedbackNextState(value) {
+    return value === "watch"
+        || value === "adapter-hardening"
+        || value === "target-app-setup"
+        || value === "actor-auth"
+        || value === "setup-quality-review"
+        || value === "study-quality-review";
+}
+function isPositiveSafeInteger(value) {
+    return Number.isSafeInteger(value) && typeof value === "number" && value >= 1;
+}
+function isNonNegativeSafeInteger(value) {
+    return Number.isSafeInteger(value) && typeof value === "number" && value >= 0;
+}
+function isReviewSummary(value) {
+    return isRecord(value)
+        && value.schema === REVIEW_SCHEMA
+        && (value.verdict === "contract_proof_only"
+            || value.verdict === "pass"
+            || value.verdict === "fail"
+            || value.verdict === "blocked"
+            || value.verdict === "timed_out")
+        && typeof value.summary === "string"
+        && Array.isArray(value.gaps)
+        && value.gaps.every((gap) => typeof gap === "string");
+}
+function isRunPointer(value) {
+    return isRecord(value)
+        && value.schema === "humanish.latest-run.v1"
+        && typeof value.runId === "string"
+        && typeof value.path === "string"
+        && typeof value.updatedAt === "string";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+//# sourceMappingURL=run.js.map