rea-agents 6.4.0 → 6.7.0

package/dist/process/WindowsBatchCommand.js

@@ -0,0 +1,46 @@
+import { win32 } from "node:path";
+import { snapshotEnvironment } from "./snapshotEnvironment.js";
+export class WindowsBatchCommandError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = "WindowsBatchCommandError";
+    }
+}
+/**
+ * Windows runs `.bat` and `.cmd` files only through cmd.exe, so Node rejects
+ * them without a shell (CVE-2024-27980).
+ */
+export const isWindowsBatchFile = (command) => /\.(?:bat|cmd)$/iu.test(command);
+/**
+ * Quote one token for cmd.exe. Tokens that cmd.exe could expand, split or
+ * redirect are rejected instead of escaped.
+ */
+export const quoteWindowsBatchToken = (value) => {
+    if (value.length === 0 ||
+        value.includes("\0") ||
+        value.includes("\r") ||
+        value.includes("\n") ||
+        /["%^!&|<>]/u.test(value))
+        throw new WindowsBatchCommandError("metacharacter", "Windows batch arguments cannot contain command-interpreter metacharacters");
+    return `"${value}"`;
+};
+/** Run a batch file through an explicit, non-AutoRun cmd.exe invocation. */
+export const windowsBatchCommand = (options) => {
+    const environment = snapshotEnvironment(options.environment, "win32");
+    const systemRoot = environment.SYSTEMROOT;
+    const comSpec = options.comSpec ??
+        environment.COMSPEC ??
+        (systemRoot === undefined
+            ? "C:\\Windows\\System32\\cmd.exe"
+            : win32.join(systemRoot, "System32", "cmd.exe"));
+    if (!win32.isAbsolute(comSpec) ||
+        win32.basename(comSpec).toLowerCase() !== "cmd.exe")
+        throw new WindowsBatchCommandError("invalid_comspec", "Windows ComSpec must be an absolute cmd.exe path");
+    const tokens = [options.batchPath, ...options.arguments].map(quoteWindowsBatchToken);
+    return {
+        command: comSpec,
+        arguments: ["/d", "/e:on", "/v:off", "/s", "/c", `"${tokens.join(" ")}"`],
+    };
+};

package/dist/process/boundedUtf8Text.js

@@ -0,0 +1,13 @@
+/** Keep a UTF-8 string within a byte budget without cutting a code point. */
+export const boundedUtf8Text = (value, maximumBytes) => {
+    let bytes = 0;
+    let end = 0;
+    for (const codePoint of value) {
+        const codePointBytes = Buffer.byteLength(codePoint, "utf8");
+        if (bytes + codePointBytes > maximumBytes)
+            return { text: value.slice(0, end), truncated: true };
+        bytes += codePointBytes;
+        end += codePoint.length;
+    }
+    return { text: value, truncated: false };
+};

package/dist/process/capture/FilesystemSnapshot.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { lstat, open, opendir, readlink } from "node:fs/promises";
-import { dirname, join, relative, resolve } from "node:path";
+import { join, relative } from "node:path";
 const hasSameIdentity = (before, after, expected) => before.dev === after.dev &&
     before.ino === after.ino &&
     (expected === "directory" ? after.isDirectory() : after.isSymbolicLink());
@@ -30,23 +30,32 @@ const fileUnavailableSystemCode = (cause) => {
         ? code
         : undefined;
 };
-const lstatIfPresent = async (path) => {
+const lstatIfPresent = async (path, previouslyObservedRoot = false, signal) => {
+    signal?.throwIfAborted();
     try {
-        return await lstat(path);
+        const stats = await lstat(path);
+        signal?.throwIfAborted();
+        return stats;
     }
     catch (cause) {
-        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+        if (cause instanceof Error &&
+            "code" in cause &&
+            (cause.code === "ENOENT" ||
+                (previouslyObservedRoot && cause.code === "ENOTDIR"))) {
+            signal?.throwIfAborted();
             return undefined;
+        }
         throw cause;
     }
 };
 /** Hash a file only when its opened descriptor still matches the captured path state. */
 export const hashFile = async (path, expected, maxBytes, signal) => {
     signal?.throwIfAborted();
+    const noFollowAvailable = typeof fsConstants.O_NOFOLLOW === "number" && fsConstants.O_NOFOLLOW !== 0;
     let handle;
     try {
         handle = await open(path, fsConstants.O_RDONLY |
-            (fsConstants.O_NOFOLLOW ?? 0) |
+            (noFollowAvailable ? fsConstants.O_NOFOLLOW : 0) |
             (fsConstants.O_NONBLOCK ?? 0));
     }
     catch (cause) {
@@ -62,6 +71,18 @@ export const hashFile = async (path, expected, maxBytes, signal) => {
     }
     try {
         signal?.throwIfAborted();
+        // On hosts without O_NOFOLLOW, compare the leaf's identity with the
+        // captured regular file. Ancestor aliases do not change file identity.
+        if (!noFollowAvailable) {
+            const named = await lstat(path);
+            signal?.throwIfAborted();
+            if (!hasSameFileState(expected, named))
+                return {
+                    state: "omitted",
+                    reason: "file_changed_or_short_read",
+                    system_code: null,
+                };
+        }
         const stats = await handle.stat();
         signal?.throwIfAborted();
         if (!hasSameFileState(expected, stats) || stats.size > maxBytes)
@@ -87,7 +108,13 @@ export const hashFile = async (path, expected, maxBytes, signal) => {
         }
         const after = await handle.stat();
         signal?.throwIfAborted();
-        if (!hasSameFileState(stats, after))
+        let unchanged = hasSameFileState(stats, after);
+        if (unchanged && !noFollowAvailable) {
+            const namedAfter = await lstat(path);
+            signal?.throwIfAborted();
+            unchanged = hasSameFileState(after, namedAfter);
+        }
+        if (!unchanged)
             return {
                 state: "omitted",
                 reason: "file_changed_or_short_read",
@@ -111,13 +138,17 @@ export const hashFile = async (path, expected, maxBytes, signal) => {
     }
 };
 /** Capture bounded, root-aliased filesystem state without following symlinks. */
-export const snapshotRoots = async (scenario, signal) => {
+export const snapshotRoots = async (scenario, signal, previous) => {
+    // A prior root entry establishes same-run admission. Preserve initial
+    // obstruction errors; a later non-directory ancestor makes it absent.
+    const previousPaths = new Set(previous?.files.map(({ path }) => path));
     const entries = [];
     const completeRoots = [];
     let remainingBytes = scenario.limits.file_bytes;
     let pendingNames = 0;
     let truncated = false;
     const enumerationReasons = new Set();
+    const enumerationOmissions = [];
     const hashOmissions = [];
     const visit = async (root, rootAlias, path, depth) => {
         signal?.throwIfAborted();
@@ -130,12 +161,13 @@ export const snapshotRoots = async (scenario, signal) => {
                 enumerationReasons.add("depth_limit");
             return false;
         }
-        const stats = await lstatIfPresent(path);
+        const stats = await lstatIfPresent(path, previousPaths.has(`${rootAlias}:.`), signal);
         if (stats === undefined)
             return true;
         const relativePath = relative(root, path) || ".";
         if (stats.isSymbolicLink()) {
-            const target = resolve(dirname(path), await readlink(path));
+            // Keep the target as stored: lexical resolution can merge distinct targets.
+            const target = await readlink(path);
             const afterRead = await lstat(path);
             if (!hasSameIdentity(stats, afterRead, "symlink")) {
                 truncated = true;
@@ -208,7 +240,25 @@ export const snapshotRoots = async (scenario, signal) => {
         const children = [];
         let complete = true;
         const remainingEntries = scenario.limits.files - entries.length - pendingNames;
-        const directory = await opendir(path);
+        let directory;
+        try {
+            directory = await opendir(path);
+        }
+        catch (cause) {
+            signal?.throwIfAborted();
+            const systemCode = fileUnavailableSystemCode(cause);
+            if (systemCode === undefined)
+                throw cause;
+            truncated = true;
+            complete = false;
+            enumerationReasons.add("directory_unavailable");
+            enumerationOmissions.push({
+                path: `${rootAlias}:${relativePath}`,
+                reason: "directory_unavailable",
+                system_code: systemCode,
+            });
+            return false;
+        }
         for await (const child of directory) {
             signal?.throwIfAborted();
             if (children.length >= remainingEntries ||
@@ -244,7 +294,8 @@ export const snapshotRoots = async (scenario, signal) => {
     };
     for (const [index, root] of scenario.filesystem_observation_paths.entries()) {
         const alias = `root_${String(index)}`;
-        if ((await lstatIfPresent(root)) === undefined) {
+        if ((await lstatIfPresent(root, previousPaths.has(`${alias}:.`), signal)) ===
+            undefined) {
             completeRoots.push(alias);
             continue;
         }
@@ -260,6 +311,7 @@ export const snapshotRoots = async (scenario, signal) => {
             depth_limit: scenario.limits.filesystem_depth,
             enumeration_truncated: completeRoots.length !== scenario.filesystem_observation_paths.length,
             enumeration_reasons: [...enumerationReasons],
+            enumeration_omissions: enumerationOmissions,
             hash_budget_bytes: scenario.limits.file_bytes,
             hashed_bytes: scenario.limits.file_bytes - remainingBytes,
             hash_omissions: hashOmissions,

package/dist/process/capture/ProcessCaptureClock.js

@@ -0,0 +1,2 @@
+/** Keep wall-clock timestamps separate from capture-relative elapsed time. */
+export const monotonicProcessCaptureClock = () => Math.floor(performance.now());

package/dist/process/capture/ProcessCaptureError.js

@@ -1,13 +1,11 @@
 import { DarwinProcessOwnershipInspectionError } from "../DarwinProcessRunTokenReader.js";
-import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { AnalysisError, } from "../../domain/analysisErrorBase.js";
 /** Typed application failure produced by controlled process capture. */
 export class ProcessCaptureError extends AnalysisError {
     _tag = "ProcessCaptureError";
     userMessage;
     userCategory;
     reason;
-    cleanupIncomplete;
-    cleanupResources;
     executionFailure;
     partialObservation;
     cleanupReport;
@@ -18,12 +16,51 @@ export class ProcessCaptureError extends AnalysisError {
         this.reason =
             options?.reason ??
                 (options?.userCategory === "cancelled" ? "cancelled" : "capture_failed");
-        this.cleanupIncomplete = this.reason === "cleanup_incomplete";
-        this.cleanupResources = options?.cleanupResources ?? [];
+        this.cleanupIncomplete ||= this.reason === "cleanup_incomplete";
         this.executionFailure = options?.executionFailure ?? message;
         this.partialObservation = options?.partialObservation;
         this.cleanupReport = options?.cleanupReport;
     }
+    /** Add final capture observations while preserving primary facts and cleanup ownership. */
+    withFinalization(options) {
+        const secondary = options.cleanupFailure;
+        const resources = [
+            ...new Set([
+                ...this.cleanupResources,
+                ...(secondary?.cleanupResources ?? []),
+            ]),
+        ];
+        const executionFailure = this.executionFailure ?? options.executionFailure;
+        const partialObservation = this.partialObservation ?? options.partialObservation;
+        const cleanupReport = this.cleanupReport ?? options.cleanupReport;
+        return new ProcessCaptureError(this.message, {
+            ...(Object.hasOwn(this, "cause") ? { cause: this.cause } : {}),
+            ...(this.userMessage === undefined
+                ? {}
+                : { userMessage: this.userMessage }),
+            ...(this.userCategory === undefined
+                ? {}
+                : { userCategory: this.userCategory }),
+            reason: this.reason,
+            ...(this.diagnostics === undefined
+                ? {}
+                : { diagnostics: this.diagnostics }),
+            ...(this.capturedOutput === undefined
+                ? {}
+                : { capturedOutput: this.capturedOutput }),
+            ...(secondary === undefined
+                ? this.cleanup === undefined
+                    ? {}
+                    : { cleanup: this.cleanup }
+                : { cleanup: { reason: secondary.message, resources } }),
+            ...(executionFailure === undefined ? {} : { executionFailure }),
+            ...(partialObservation === undefined ? {} : { partialObservation }),
+            ...(cleanupReport === undefined ? {} : { cleanupReport }),
+        }).bindCleanupDependencies([
+            this,
+            ...(secondary === undefined ? [] : [secondary]),
+        ]);
+    }
 }
 /** Return one non-recursive, domain-neutral summary of an execution failure. */
 export const describeProcessCaptureExecutionFailure = (failure) => {
@@ -45,8 +82,28 @@ export const processCaptureCancelled = () => new ProcessCaptureError("process ca
 export const normalizeCaptureFailure = (cause, signal) => {
     if (cause instanceof ProcessCaptureError)
         return cause;
-    if (cause instanceof DarwinProcessOwnershipInspectionError)
-        return new ProcessCaptureError(cause.message, { cause });
+    if (cause instanceof DarwinProcessOwnershipInspectionError) {
+        const normalized = new ProcessCaptureError(cause.message, {
+            cause,
+            ...(cause.cancellation === undefined
+                ? {}
+                : { userCategory: "cancelled", reason: "cancelled" }),
+            ...(cause.cleanupFailure === undefined
+                ? {}
+                : {
+                    cleanup: {
+                        reason: cause.cleanupFailure.message,
+                        resources: cause.cleanupFailure.cleanupResources,
+                    },
+                }),
+            ...(cause.capturedOutput === undefined
+                ? {}
+                : { capturedOutput: cause.capturedOutput }),
+        });
+        return cause.cleanupFailure === undefined
+            ? normalized
+            : normalized.bindCleanupDependencies([cause.cleanupFailure]);
+    }
     if (signal?.aborted === true &&
         (cause === signal.reason ||
             (cause instanceof Error && cause.name === "AbortError")))

package/dist/process/capture/ProcessCaptureJournal.js

@@ -1,5 +1,6 @@
 import { normalizeProcessElapsedTime, normalizeProcessText, } from "./ProcessNormalization.js";
 import { scheduleProcessDelay } from "./ProcessTimer.js";
+import { monotonicProcessCaptureClock } from "./ProcessCaptureClock.js";
 /** Create one monotonic event journal for a process capture. */
 export const createProcessCaptureJournal = () => {
     const entries = [];
@@ -18,7 +19,7 @@ export const scheduleScenarioInteractions = (options) => {
         const timer = scheduleProcessDelay(event.at_ms, () => {
             options.dispatchedEventIndexes.add(eventIndex);
             const terminal = getTerminal();
-            const dispatchedAt = Math.max(0, Date.now() - started);
+            const dispatchedAt = Math.max(0, monotonicProcessCaptureClock() - started);
             let outcome = "dispatched";
             if (terminal === undefined)
                 outcome = "target_exited";

package/dist/process/capture/ProcessCaptureLifecycle.js

@@ -3,7 +3,7 @@ import { constants, statSync } from "node:fs";
 import { open, mkdtemp, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
+import { setImmediate, setTimeout as delay } from "node:timers/promises";
 import { digestProcessCommitment, processComparisonContract, processScenarioCommitment, } from "../../domain/process/processScenario.js";
 import { parseProcessCapture } from "../../domain/process/processCaptureParsing.js";
 import { PRODUCT_IDENTITY } from "../../identity.js";
@@ -13,11 +13,12 @@ import { cleanupOwnedProcessGroup, verifyNoTokenOwnedProcesses, } from "../Proce
 import { observeOwnedProcessGroups, prepareProcessOwnershipInspection, systemProcessOwnershipHost, } from "../ProcessOwnershipObservation.js";
 import { describeProcessCaptureExecutionFailure, normalizeCaptureFailure, ProcessCaptureError, } from "./ProcessCaptureError.js";
 import { assertNotCancelled } from "./ProcessScenarioRuntimeValidation.js";
-import { normalizeProcessElapsedTime, normalizeProcessSamples, normalizeProcessText, } from "./ProcessNormalization.js";
+import { normalizeProcessElapsedTime, normalizeProcessSamples, } from "./ProcessNormalization.js";
 import { PROCESS_PROVIDER } from "../../domain/process/processEvidenceProvider.js";
 import { TerminalRenderer } from "./TerminalRenderer.js";
 import { hasCaptureTruncation, } from "../../domain/process/processCaptureCoverage.js";
 import { scheduleProcessInterval } from "./ProcessTimer.js";
+import { monotonicProcessCaptureClock } from "./ProcessCaptureClock.js";
 import { partialProcessCaptureObservationSchema } from "../../domain/process/processCapture.js";
 /** Seed explicit observation availability before capture completion begins. */
 export const createProcessCaptureObservationBuffer = (options) => ({
@@ -83,16 +84,20 @@ const normalizePartialProcessObservations = (observations, context) => {
 };
 /** Wait for trailing PTY callbacks before the capture becomes immutable. */
 export const settleProcessCaptureJournal = async (journal, quietMs = 25, maxWaitMs = 500) => {
-    const deadline = Date.now() + maxWaitMs;
+    const deadline = monotonicProcessCaptureClock() + maxWaitMs;
     let observed = journal.length;
-    let lastChangeAt = Date.now();
-    while (Date.now() < deadline) {
+    let lastChangeAt = monotonicProcessCaptureClock();
+    while (monotonicProcessCaptureClock() < deadline) {
         await new Promise((resolve) => setTimeout(resolve, 4));
+        // A stalled event loop can leave timer and poll callbacks that were already
+        // due queued behind this wake-up. Drain them before judging silence so a
+        // trailing observation is not dropped by an early settle.
+        await setImmediate();
         if (journal.length !== observed) {
             observed = journal.length;
-            lastChangeAt = Date.now();
+            lastChangeAt = monotonicProcessCaptureClock();
         }
-        else if (Date.now() - lastChangeAt >= quietMs)
+        else if (monotonicProcessCaptureClock() - lastChangeAt >= quietMs)
             return;
     }
 };
@@ -132,6 +137,12 @@ export const buildCaptureResult = (options) => {
         truncation_details: options.truncationDetails,
         limitations: [
             "The executable digest is a prelaunch file sample; matching path metadata immediately after spawn does not prove an atomic operating-system image binding.",
+            ...(Date.parse(options.manifest.completed_at) <
+                Date.parse(options.manifest.started_at)
+                ? [
+                    "Wall-clock completion time precedes start time; elapsed capture timing is recorded separately and remains monotonic.",
+                ]
+                : []),
             "Process trees are sampled and may omit short-lived descendants.",
             ...(options.samplingPartial
                 ? ["Process-tree sampling ended with an incomplete observation."]
@@ -184,13 +195,17 @@ const captureCoverageUnknowns = (details) => {
     if (details.raw_terminal.observed_frames > details.raw_terminal.retained_frames)
         unknowns.push({
             scope: "terminal",
-            reason: "Raw PTY chunks exceeded output_bytes and were omitted; rendered states also lack those inputs. See truncation_details.raw_terminal.",
+            reason: (details.normalized_terminal?.omitted_frames ?? 0) > 0
+                ? "Raw PTY chunks were omitted because original input exceeded output_bytes or an ordered normalization stage exceeded its remaining bound; final normalized sizes for the latter omissions are unknown. Rendered states also lack those inputs. See raw_terminal and normalized_terminal retention details, including the normalized omission count."
+                : "Raw PTY chunks exceeded output_bytes and were omitted; rendered states also lack those inputs. See truncation_details.raw_terminal.",
         });
     if (details.rendered_terminal.observed_frames >
         details.rendered_terminal.retained_frames)
         unknowns.push({
             scope: "terminal",
-            reason: "Cumulative rendered state and visible-line bytes exceeded output_bytes; whole rendered frames were omitted. Raw PTY coverage is reported separately. See truncation_details.rendered_terminal.",
+            reason: (details.rendered_terminal.unknown_size_frames ?? 0) > 0
+                ? "Rendered frames were omitted because a normalization stage exceeded the remaining output_bytes budget; final rendered byte totals are unknown for those frames. See truncation_details.rendered_terminal."
+                : "Cumulative rendered state and visible-line bytes exceeded output_bytes; whole rendered frames were omitted. Raw PTY coverage is reported separately. See truncation_details.rendered_terminal.",
         });
     for (const [name, coverage] of [
         ["before", details.filesystem_before],
@@ -367,8 +382,9 @@ export const observeSettlement = async (runId, processGroupIds, settleMs, record
         recordEvent("lifecycle", 1);
         return { state: "unverifiable", elapsed_ms: 0 };
     }
-    const started = Date.now();
+    const started = monotonicProcessCaptureClock();
     let consecutiveEmpty = 0;
+    let sawLive = false;
     let deadlineReached = false;
     while (!deadlineReached) {
         onLiveProgress?.();
@@ -377,24 +393,42 @@ export const observeSettlement = async (runId, processGroupIds, settleMs, record
         assertNotCancelled(signal);
         if ([...observations.values()].some(({ state }) => state === "unverifiable")) {
             recordEvent("lifecycle", 1);
-            return { state: "unverifiable", elapsed_ms: Date.now() - started };
+            return {
+                state: "unverifiable",
+                elapsed_ms: monotonicProcessCaptureClock() - started,
+            };
         }
         if ([...observations.values()].every(({ state }) => state === "empty")) {
             consecutiveEmpty += 1;
             if (consecutiveEmpty >= 2) {
                 recordEvent("lifecycle", 1);
-                return { state: "quiesced", elapsed_ms: Date.now() - started };
+                return {
+                    state: "quiesced",
+                    elapsed_ms: monotonicProcessCaptureClock() - started,
+                };
             }
         }
-        else
+        else {
             consecutiveEmpty = 0;
-        deadlineReached = Date.now() - started >= settleMs;
+            sawLive = true;
+        }
+        deadlineReached = monotonicProcessCaptureClock() - started >= settleMs;
         if (deadlineReached)
             break;
         await delay(50, undefined, { signal });
     }
     recordEvent("lifecycle", 1);
-    return { state: "alive_at_deadline", elapsed_ms: Date.now() - started };
+    // A lone empty observation proves neither liveness nor quiescence; only an
+    // observed live member justifies alive_at_deadline.
+    return sawLive
+        ? {
+            state: "alive_at_deadline",
+            elapsed_ms: monotonicProcessCaptureClock() - started,
+        }
+        : {
+            state: "unverifiable",
+            elapsed_ms: monotonicProcessCaptureClock() - started,
+        };
 };
 /** Name why an attempt is unverified; a blank message never reaches the capture schema. */
 export const describeUnverifiedCause = (cause, fallback) => {
@@ -456,7 +490,7 @@ export const awaitTerminalExit = async ({ terminal, scenario, started, lastOutpu
             return;
         const record = {
             signal: finalizationSignal,
-            sent_at_ms: Math.round(performance.now() - finalizationStartedAt),
+            sent_at_ms: Math.max(0, monotonicProcessCaptureClock() - finalizationStartedAt),
             delivery: "unverified",
             reason: "delivery had not settled when the record was published",
         };
@@ -515,7 +549,7 @@ export const awaitTerminalExit = async ({ terminal, scenario, started, lastOutpu
             terminal.kill("SIGKILL");
             return;
         }
-        finalizationStartedAt = performance.now();
+        finalizationStartedAt = monotonicProcessCaptureClock();
         attempt("SIGTERM");
     };
     terminal.onExit((exit) => {
@@ -526,7 +560,7 @@ export const awaitTerminalExit = async ({ terminal, scenario, started, lastOutpu
         // ended the process; the PTY layer can deliver the notification late.
         const finalizationElapsedMs = finalizationStartedAt === undefined
             ? undefined
-            : Math.round(performance.now() - finalizationStartedAt);
+            : Math.max(0, monotonicProcessCaptureClock() - finalizationStartedAt);
         recordEvent("lifecycle", 0);
         for (const [eventIndex, event] of scenario.events.entries()) {
             if (dispatchedEventIndexes.has(eventIndex))
@@ -535,7 +569,7 @@ export const awaitTerminalExit = async ({ terminal, scenario, started, lastOutpu
             interactions.push({
                 sequence,
                 scheduled_at_ms: event.at_ms,
-                dispatched_at_ms: Math.max(0, Date.now() - started),
+                dispatched_at_ms: Math.max(0, monotonicProcessCaptureClock() - started),
                 type: event.type,
                 data: event.type === "input"
                     ? "<not-dispatched>"
@@ -592,15 +626,17 @@ export const awaitTerminalExit = async ({ terminal, scenario, started, lastOutpu
             forceKill();
         }
         else if (finalizationStartedAt !== undefined) {
-            if (performance.now() - finalizationStartedAt >=
+            if (monotonicProcessCaptureClock() - finalizationStartedAt >=
                 scenario.finalization_ms)
                 forceKill();
         }
-        else if (Date.now() - started >= scenario.timeout_ms) {
+        else if (monotonicProcessCaptureClock() - started >=
+            scenario.timeout_ms) {
             reason = "timeout";
             terminateAtDeadline();
         }
-        else if (Date.now() - lastOutput() >= scenario.idle_timeout_ms) {
+        else if (monotonicProcessCaptureClock() - lastOutput() >=
+            scenario.idle_timeout_ms) {
             reason = "idle_timeout";
             terminateAtDeadline();
         }
@@ -616,10 +652,10 @@ const processCaptureCleanupHost = {
 const PROCESS_CLEANUP_VERIFICATION_GRACE_MS = 1_000;
 const PROCESS_CLEANUP_VERIFICATION_INTERVAL_MS = 25;
 const verifyTokenOwnedProcessesUntilSettled = async (verify) => {
-    const deadline = Date.now() + PROCESS_CLEANUP_VERIFICATION_GRACE_MS;
+    const deadline = monotonicProcessCaptureClock() + PROCESS_CLEANUP_VERIFICATION_GRACE_MS;
     let result = await verify();
     while (!result.cleaned) {
-        const remaining = deadline - Date.now();
+        const remaining = deadline - monotonicProcessCaptureClock();
         if (remaining <= 0)
             return result;
         await new Promise((resolve) => setTimeout(resolve, Math.min(PROCESS_CLEANUP_VERIFICATION_INTERVAL_MS, remaining)));
@@ -844,36 +880,51 @@ export const cleanupReportFailure = (report) => {
             .join("; ");
 };
 export const captureTerminalFrames = (options) => {
-    let outputBytes = 0;
+    let rawBytes = 0;
+    let normalizedBytes = 0;
     let observedBytes = 0;
     let observedFrames = 0;
+    let normalizedOmittedFrames = 0;
     options.terminal.onData((data) => {
         options.onOutput();
         const bytes = Buffer.byteLength(data);
         observedBytes += bytes;
         observedFrames += 1;
-        if (outputBytes + bytes > options.scenario.limits.output_bytes) {
+        const budget = options.scenario.limits.output_bytes;
+        if (bytes > budget - rawBytes) {
+            return;
+        }
+        const normalized = options.normalizeText(data, budget - normalizedBytes);
+        if (normalized.state === "over_budget") {
+            normalizedOmittedFrames += 1;
             return;
         }
-        outputBytes += bytes;
-        const atMs = normalizeProcessElapsedTime(Date.now() - options.started, options.scenario.normalization.time_bucket_ms);
-        const normalized = normalizeProcessText(data, options.scenario, options.temporaryRoot, options.terminal.pid);
+        rawBytes += bytes;
+        normalizedBytes += normalized.utf8Bytes;
+        const atMs = normalizeProcessElapsedTime(monotonicProcessCaptureClock() - options.started, options.scenario.normalization.time_bucket_ms);
         const sequence = options.frames.length;
         options.frames.push({
             sequence,
             at_ms: atMs,
-            data: normalized,
-            ...(normalized === data ? {} : { raw_data: data }),
+            data: normalized.value,
+            ...(normalized.value === data ? {} : { raw_data: data }),
         });
         options.renderer.write(data, atMs);
         options.recordEvent("frames", sequence);
     });
     return () => ({
-        budget_bytes: options.scenario.limits.output_bytes,
-        observed_bytes: observedBytes,
-        retained_bytes: outputBytes,
-        observed_frames: observedFrames,
-        retained_frames: options.frames.length,
+        raw_terminal: {
+            budget_bytes: options.scenario.limits.output_bytes,
+            observed_bytes: observedBytes,
+            retained_bytes: rawBytes,
+            observed_frames: observedFrames,
+            retained_frames: options.frames.length,
+        },
+        normalized_terminal: {
+            budget_bytes: options.scenario.limits.output_bytes,
+            retained_bytes: normalizedBytes,
+            omitted_frames: normalizedOmittedFrames,
+        },
     });
 };
 export const resolveProcessResult = (capture, executionFailure, cleanup, observations, partialContext) => {
@@ -925,37 +976,34 @@ export const resolveProcessResult = (capture, executionFailure, cleanup, observa
         const cleanupResources = Object.entries(cleanup)
             .filter(([, outcome]) => outcome.state === "failed" || outcome.state === "unverified")
             .map(([resource]) => resource);
-        throw new ProcessCaptureError(cleanupFailure, {
+        const cleanupError = new ProcessCaptureError(cleanupFailure, {
             cause: executionFailure,
             reason: "cleanup_incomplete",
-            cleanupResources,
+            cleanup: { reason: cleanupFailure, resources: cleanupResources },
             ...(executionFailureReason === undefined
                 ? {}
                 : { executionFailure: executionFailureReason }),
             ...(partialObservation === undefined ? {} : { partialObservation }),
             cleanupReport: cleanup,
         });
+        if (executionFailure instanceof ProcessCaptureError)
+            throw executionFailure.withFinalization({
+                ...(executionFailureReason === undefined
+                    ? {}
+                    : { executionFailure: executionFailureReason }),
+                ...(partialObservation === undefined ? {} : { partialObservation }),
+                cleanupReport: cleanup,
+                cleanupFailure: cleanupError,
+            });
+        throw cleanupError;
     }
     if (executionFailure instanceof ProcessCaptureError) {
-        const retainedExecutionFailure = executionFailure.executionFailure ?? executionFailureReason;
-        const retainedPartialObservation = executionFailure.partialObservation ?? partialObservation;
-        throw new ProcessCaptureError(executionFailure.message, {
-            cause: executionFailure,
-            ...(executionFailure.userMessage === undefined
-                ? {}
-                : { userMessage: executionFailure.userMessage }),
-            ...(executionFailure.userCategory === undefined
-                ? {}
-                : { userCategory: executionFailure.userCategory }),
-            reason: executionFailure.reason,
-            cleanupResources: executionFailure.cleanupResources,
-            ...(retainedExecutionFailure === undefined
-                ? {}
-                : { executionFailure: retainedExecutionFailure }),
-            ...(retainedPartialObservation === undefined
+        throw executionFailure.withFinalization({
+            ...(executionFailureReason === undefined
                 ? {}
-                : { partialObservation: retainedPartialObservation }),
-            cleanupReport: executionFailure.cleanupReport ?? cleanup,
+                : { executionFailure: executionFailureReason }),
+            ...(partialObservation === undefined ? {} : { partialObservation }),
+            cleanupReport: cleanup,
         });
     }
     if (executionFailure !== undefined) {