rea-agents 3.0.0 → 3.2.0

package/dist/application/ProcessCaptureLifecycle.js

@@ -13,8 +13,8 @@ import { assertNotCancelled, assertRealPathAuthority, } from "./ProcessCaptureAu
 import { normalizeProcessElapsedTime, normalizeProcessSamples, normalizeProcessText, redactProtocolEvents, } from "./ProcessNormalization.js";
 import { PROCESS_PROVIDER } from "./ProcessEvidence.js";
 import { TerminalRenderer } from "./TerminalRenderer.js";
+import { scheduleProcessInterval } from "./ProcessTimer.js";
 export const buildCaptureResult = (options) => ({
-    schema_version: 4,
     manifest: options.manifest,
     normalization: options.scenario.normalization,
     frames: options.frames,
@@ -33,7 +33,6 @@ export const buildCaptureResult = (options) => ({
     shim_events: options.shimEvents,
     protocol_events: redactProtocolEvents(options.replay.events, options.scenario),
     replay_transitions: options.replay.transitions,
-    reactive_run: options.reactiveRun,
     event_journal: options.eventJournal,
     files_before: options.before.files,
     files_after: options.after.files,
@@ -57,10 +56,6 @@ export const buildCaptureResult = (options) => ({
             reason: "External network isolation is not enforced by this adapter.",
         },
     ],
-    cleanup: {
-        owned_process_group: "verified",
-        temporary_root: "removed",
-    },
 });
 const hashFile = async (path) => {
     const hash = createHash("sha256");
@@ -153,13 +148,12 @@ export const awaitTerminalExit = async ({ terminal, scenario, started, lastOutpu
             recordEvent("interaction_events", sequence);
         }
         for (const timer of timers) {
-            clearTimeout(timer);
-            clearInterval(timer);
+            timer.cancel();
         }
         timers.clear();
         resolveExit({ ...exit, reason });
     });
-    const timeout = setInterval(() => {
+    const timeout = scheduleProcessInterval(() => {
         if (signal?.aborted === true) {
             reason = "cancelled";
             terminal.kill("SIGKILL");
@@ -177,7 +171,7 @@ export const awaitTerminalExit = async ({ terminal, scenario, started, lastOutpu
 });
 export const releaseProcessResources = async (options) => {
     for (const timer of options.timers)
-        clearTimeout(timer);
+        timer.cancel();
     let failure;
     try {
         await options.replay?.close();
@@ -228,8 +222,7 @@ export const captureTerminalFrames = (options) => {
     options.terminal.onData((data) => {
         options.onOutput();
         const bytes = Buffer.byteLength(data);
-        if (options.frames.length >= options.scenario.limits.frames ||
-            outputBytes + bytes > options.scenario.limits.output_bytes) {
+        if (outputBytes + bytes > options.scenario.limits.output_bytes) {
             truncated = true;
             return;
         }
@@ -264,6 +257,11 @@ export const resolveProcessResult = (capture, executionFailure, cleanupFailure)
     return capture;
 };
 export const prepareProcessCapture = async (scenario, policy, signal, host = systemProcessPreparationHost) => {
+    if (policy.status === "disabled")
+        throw new ProcessCaptureError("process capture is disabled", {
+            userCategory: "permission_required",
+            userMessage: processPolicyMessage("process capture is disabled"),
+        });
     const decision = authorizeProcessScenario(scenario, policy);
     if (!decision.allowed)
         throw new ProcessCaptureError(decision.reason, {

package/dist/application/ProcessCheckpoints.js

@@ -1,4 +1,5 @@
 import { snapshotRoots } from "./FilesystemSnapshot.js";
+import { scheduleProcessDelay } from "./ProcessTimer.js";
 /** Classify path-stable filesystem effects between two bounded states. */
 export const classifyFilesystemEffects = (before, after) => {
     const beforeByPath = new Map(before.map((file) => [file.path, file]));
@@ -8,14 +9,31 @@ export const classifyFilesystemEffects = (before, after) => {
         .map((path) => {
         const beforeFile = beforeByPath.get(path) ?? null;
         const afterFile = afterByPath.get(path) ?? null;
-        const status = beforeFile === null
-            ? "created"
-            : afterFile === null
-                ? "deleted"
-                : JSON.stringify(beforeFile) === JSON.stringify(afterFile)
-                    ? "unchanged"
-                    : "modified";
-        return { path, status, before: beforeFile, after: afterFile };
+        if (beforeFile === null) {
+            if (afterFile === null)
+                throw new TypeError(`Filesystem effect ${path} has no file state`);
+            return {
+                path,
+                status: "created",
+                before: null,
+                after: afterFile,
+            };
+        }
+        if (afterFile === null)
+            return {
+                path,
+                status: "deleted",
+                before: beforeFile,
+                after: null,
+            };
+        return {
+            path,
+            status: JSON.stringify(beforeFile) === JSON.stringify(afterFile)
+                ? "unchanged"
+                : "modified",
+            before: beforeFile,
+            after: afterFile,
+        };
     });
 };
 /** Coordinates named lifecycle filesystem observations without overlapping scans. */
@@ -47,7 +65,7 @@ export class ProcessCheckpoints {
         for (const checkpoint of scenario.checkpoints) {
             if (checkpoint.trigger.type !== "time")
                 continue;
-            const timer = setTimeout(() => this.capture(checkpoint.name), checkpoint.trigger.at_ms);
+            const timer = scheduleProcessDelay(checkpoint.trigger.at_ms, () => this.capture(checkpoint.name));
             this.#timers.add(timer);
         }
     }
@@ -124,7 +142,7 @@ export class ProcessCheckpoints {
     /** Finish pending snapshots and return them in observation order. */
     async finish(after) {
         for (const timer of this.#timers)
-            clearTimeout(timer);
+            timer.cancel();
         await this.#pending;
         const previous = this.#captures.at(-1)?.files ?? [];
         const index = this.#captures.length;
@@ -141,7 +159,7 @@ export class ProcessCheckpoints {
     /** Cancel scheduled captures and await any snapshot already in progress. */
     async dispose() {
         for (const timer of this.#timers)
-            clearTimeout(timer);
+            timer.cancel();
         this.#timers.clear();
         await this.#pending;
     }

package/dist/application/ProcessCli.js

@@ -1,16 +1,16 @@
+import { projectPermissionFailure } from "./PermissionFailure.js";
 import { readFile } from "node:fs/promises";
 import { parseConfig } from "../config.js";
-import { AnalysisError, AnalysisInputError, AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "../domain/errors.js";
+import { AnalysisError, AnalysisInputError, projectAnalysisError, } from "../domain/errors.js";
 import { createEvidence, parseEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
 import { processTraceSpecificationSchema } from "../domain/processTraceComparison.js";
-import { compareProcessCaptures, LEGACY_PROCESS_CAPTURE_MESSAGE, parseProcessScenario, parseProcessCapture, } from "../domain/processCapture.js";
+import { compareProcessCaptures, parseProcessScenario, parseProcessCapture, } from "../domain/processCapture.js";
 import { captureProcessScenario } from "./ProcessHarness.js";
 import { processCapturePermissionRequest } from "./ProcessCapturePermission.js";
 import { PROCESS_PROVIDER, createProcessCaptureEvidence, } from "./ProcessEvidence.js";
 import { loadConfiguredPermissionAuthority } from "./PermissionConfiguration.js";
-const MAX_INPUT_BYTES = 64 * 1024 * 1024;
 /** Capture one JSON scenario through the same policy and evidence contract as MCP. */
 export const captureProcessScenarioFile = async (path) => {
     try {
@@ -30,11 +30,7 @@ export const captureProcessScenarioFile = async (path) => {
             return cliAnalysisError(authority.error);
         const authorized = await authority.value.authorize(processCapturePermissionRequest(scenario), "read");
         if (!authorized.ok)
-            return cliAnalysisError(authorized.error instanceof PermissionRequiredError
-                ? authorized.error
-                : new AnalysisProtocolError(authorized.error.message, {
-                    cause: authorized.error,
-                }));
+            return cliAnalysisError(projectPermissionFailure(authorized.error));
         const captured = await captureProcessScenario(scenario, config.value.processExecutionPolicy);
         if (!captured.ok)
             return cliAnalysisError(captured.error);
@@ -58,9 +54,7 @@ export const compareProcessEvidenceFiles = async (leftPath, rightPath, traceSpec
                 traceSpecification,
             });
         return createEvidence(undefined, PROCESS_PROVIDER, {
-            predicateType: traceSpecification === undefined
-                ? "rea.process-comparison/v3"
-                : "rea.process-comparison/v4",
+            predicateType: "rea.process-comparison",
             operation: "compare_process_captures",
             parameters: {
                 left_evidence_id: left.id,
@@ -92,11 +86,9 @@ const parseCaptureEvidence = (input) => {
         throw invalidCaptureEvidence();
     }
     if (evidence.operation !== "capture_process_scenario" ||
-        evidence.predicate_type !== "rea.process-capture/v4" ||
+        evidence.predicate_type !== "rea.process-capture" ||
         evidence.provider.id !== PROCESS_PROVIDER.id ||
         evidence.provider.version !== PROCESS_PROVIDER.version) {
-        if (evidence.predicate_type === "rea.process-capture/v3")
-            throw new ProcessCliFailure("invalid_input", LEGACY_PROCESS_CAPTURE_MESSAGE);
         throw new ProcessCliFailure("invalid_input", "Capture evidence is not from the current process-capture workflow. Create new capture evidence, then try again.");
     }
     try {
@@ -125,10 +117,9 @@ const readJson = async (path) => {
     catch {
         throw new ProcessCliFailure("invalid_input", "Process input file could not be read. Check that the path exists and is readable.");
     }
-    if (bytes.length > MAX_INPUT_BYTES)
-        throw new ProcessCliFailure("truncated", "Process input file is too large. Reduce it below 64 MiB, then try again.");
     try {
-        return JSON.parse(bytes.toString("utf8"));
+        const parsed = JSON.parse(bytes.toString("utf8"));
+        return parsed;
     }
     catch {
         throw new ProcessCliFailure("invalid_input", "Process input file is not valid JSON. Repair the file, then try again.");

package/dist/application/ProcessEvidence.js

@@ -1,7 +1,6 @@
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { parseProcessCapture } from "../domain/processCapture.js";
-/** Provider identity for controlled Process Capture v4 evidence. */
+/** Provider identity for controlled process capture evidence. */
 export const PROCESS_PROVIDER = {
     id: "rea-process",
     name: "REA deterministic process harness",
@@ -17,14 +16,13 @@ const processEvidenceParameters = (scenario) => ({
     command_shim_count: scenario.command_shims.length,
     normalization: scenario.normalization,
 });
-/** Create one canonical observed Process Capture v4 Evidence record. */
+/** Create one canonical observed process capture Evidence record. */
 export const createProcessCaptureEvidence = (scenario, capture) => {
-    const validatedCapture = parseProcessCapture(capture);
     return createEvidence(undefined, PROCESS_PROVIDER, {
-        predicateType: "rea.process-capture/v4",
+        predicateType: "rea.process-capture",
         operation: "capture_process_scenario",
         parameters: processEvidenceParameters(scenario),
-        result: jsonValueSchema.parse(validatedCapture),
+        result: jsonValueSchema.parse(capture),
         confidence: "observed",
         authority: "controlled-replay",
         environment: {
@@ -33,6 +31,6 @@ export const createProcessCaptureEvidence = (scenario, capture) => {
             architecture: process.arch,
             isolation: "process",
         },
-        limitations: validatedCapture.limitations,
+        limitations: capture.limitations,
     });
 };

package/dist/application/ProcessHarness.js

@@ -1,4 +1,4 @@
-import { validateProcessCapture } from "../domain/processCapture.js";
+import { parseProcessCapture } from "../domain/processCapture.js";
 import { err, ok } from "../domain/result.js";
 import { ProcessCaptureError, processCaptureCancelled, } from "./ProcessCaptureError.js";
 export { ProcessCaptureError } from "./ProcessCaptureError.js";
@@ -33,11 +33,35 @@ const createTerminalRenderer = (scenario, temporaryRoot, terminalPid, recordEven
     columns: scenario.terminal.columns,
     rows: scenario.terminal.rows,
     scrollback: scenario.terminal.scrollback,
-    maxFrames: scenario.limits.frames,
     maxBytes: scenario.limits.output_bytes,
     normalize: (value) => normalizeProcessText(value, scenario, temporaryRoot, terminalPid()),
     recordEvent,
 });
+/**
+ * Wait until the capture journal stops growing.
+ *
+ * node-pty reports buffered output through `onData` callbacks rather than an
+ * awaitable read, so chunks can still be in flight after the child exits. The
+ * quiet interval is measured in elapsed time rather than scheduler turns:
+ * consecutive `setImmediate` turns elapse in microseconds, so any fixed number
+ * of them finishes long before a delayed pty callback under host contention,
+ * which is exactly when the trailing chunk matters. `maxWaitMs` bounds the
+ * total wait so a pathological stream cannot stall exit.
+ */
+const settleTrailingJournal = async (journal, quietMs = 25, maxWaitMs = 500) => {
+    const deadline = Date.now() + maxWaitMs;
+    let observed = journal.length;
+    let lastChangeAt = Date.now();
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 4));
+        if (journal.length !== observed) {
+            observed = journal.length;
+            lastChangeAt = Date.now();
+        }
+        else if (Date.now() - lastChangeAt >= quietMs)
+            return;
+    }
+};
 const reactiveCapture = (options, protocolEvents) => ({
     ...options,
     processSamples: options.samples,
@@ -154,24 +178,28 @@ const finishProcessRun = async (options) => {
         });
     await options.runtime?.reactive?.coordinator.close();
     let { capture, executionFailure } = options;
-    if (capture !== undefined) {
-        capture = {
+    let verifiedCapture;
+    if (capture !== undefined && cleanupFailure === undefined) {
+        const settlement = capture.settlement.state === "quiesced"
+            ? { ...capture.settlement, cleanup_outcome: "not_required" }
+            : { ...capture.settlement, cleanup_outcome: "cleaned" };
+        const completedCapture = {
             ...capture,
             reactive_run: projectProcessReactiveRun(options.runtime?.reactive),
-            settlement: {
-                ...capture.settlement,
-                cleanup_outcome: capture.settlement.state === "quiesced"
-                    ? "not_required"
-                    : cleanupFailure === undefined
-                        ? "cleaned"
-                        : "failed",
+            settlement,
+            cleanup: {
+                owned_process_group: "verified",
+                temporary_root: "removed",
             },
         };
-        const issue = validateProcessCapture(capture)[0];
-        if (issue !== undefined)
-            executionFailure = new ProcessCaptureError(`process capture validation failed: ${issue.path}: ${issue.message}`);
+        try {
+            verifiedCapture = parseProcessCapture(completedCapture);
+        }
+        catch (cause) {
+            executionFailure = new ProcessCaptureError(`process capture validation failed${cause instanceof Error ? `: ${cause.message}` : ""}`, { cause });
+        }
     }
-    return resolveProcessResult(capture, executionFailure, cleanupFailure);
+    return resolveProcessResult(verifiedCapture, executionFailure, cleanupFailure);
 };
 const completeCapture = async (options) => {
     const { runtime, scenario } = options;
@@ -184,13 +212,26 @@ const completeCapture = async (options) => {
         }
         throw processCaptureCancelled();
     }
+    const settlement = await observeSettlement(options.runId, selectCapturedProcessGroupIds(runtime.terminal.pid, options.samples), scenario.settle_ms, options.recordEvent);
+    runtime.checkpoints.trigger("settled");
+    const samplingPartial = (await runtime.stopSampler()).partial;
     if (runtime.reactive !== undefined) {
+        // Process, filesystem, shim, and protocol observations can be recorded
+        // during settlement after the PTY exits. Make target loss terminal only
+        // after that journal has drained, otherwise the coordinator's control
+        // priority discards a valid multi-source completion predicate.
+        //
+        // Draining the coordinator is not sufficient on its own: node-pty delivers
+        // buffered output through onData callbacks, which run outside the
+        // coordinator's queue. A trailing chunk that has not been delivered yet has
+        // produced no journal entry, so the drain has nothing to wait for and the
+        // target is declared lost while a terminal trigger is still satisfiable.
+        // Let any trailing chunks land first.
+        await settleTrailingJournal(options.eventJournal);
+        await runtime.reactive.coordinator.drain();
         await runtime.reactive.coordinator.submit({ kind: "target_lost" });
         runtime.reactive.unsubscribe();
     }
-    const settlement = await observeSettlement(options.runId, selectCapturedProcessGroupIds(runtime.terminal.pid, options.samples), scenario.settle_ms, options.recordEvent);
-    runtime.checkpoints.trigger("settled");
-    const samplingPartial = (await runtime.stopSampler()).partial;
     assertNotCancelled(options.signal);
     const after = await snapshotRoots(scenario, options.signal);
     const renderedFrames = await runtime.renderer.frames();
@@ -210,7 +251,6 @@ const completeCapture = async (options) => {
         exit: { ...options.exit, reason },
         samples: options.samples,
         replay: runtime.replay,
-        reactiveRun: projectProcessReactiveRun(runtime.reactive),
         before: options.before,
         after,
         truncated,
@@ -221,7 +261,7 @@ const completeCapture = async (options) => {
         interactions: options.interactions,
         checkpoints,
         shimEvents: normalizedShimEvents(runtime, scenario, options.temporaryRoot),
-        settlement: { ...settlement, cleanup_outcome: "not_required" },
+        settlement,
         manifest,
         eventJournal: options.eventJournal,
     });

package/dist/application/ProcessNormalization.js

@@ -39,9 +39,10 @@ export const normalizeProcessSamples = (samples, scenario, rootPid) => {
             mapping.set(identifier, mapping.size + 1);
     const normalizeCommand = (command) => {
         const normalized = normalizeProcessText(command, scenario, "<no-temporary-root>", rootPid);
-        return scenario.normalization.pids
+        const withNormalizedPids = scenario.normalization.pids
             ? normalizePidTokens(normalized, identifiers)
             : normalized;
+        return withNormalizedPids.trim();
     };
     return samples.map((sample) => ({
         at_ms: normalizeProcessElapsedTime(sample.at_ms, scenario.normalization.time_bucket_ms),

package/dist/application/ProcessReactiveCoordinator.js

@@ -1,9 +1,7 @@
 import { commitProcessReactiveProposal, createProcessReactiveSnapshot, reduceProcessReactiveScenario, } from "../domain/processReactiveRuntime.js";
+import { scheduleProcessDelay } from "./ProcessTimer.js";
 const systemTimerHost = {
-    schedule: (callback, delayMs) => {
-        const timer = setTimeout(callback, delayMs);
-        return { cancel: () => clearTimeout(timer) };
-    },
+    schedule: (callback, delayMs) => scheduleProcessDelay(delayMs, callback),
 };
 /**
  * Serializes live observations, deadlines, and effect commits for one run.

package/dist/application/ProcessReactiveEffects.js

@@ -1,4 +1,5 @@
 import { createProcessObservation } from "../domain/processObservation.js";
+import { normalizeProcessElapsedTime } from "./ProcessNormalization.js";
 const elapsed = (host) => Math.max(0, host.now() - host.startedAtMs);
 const interactionData = (action) => {
     if (action.type === "send_input")
@@ -20,12 +21,17 @@ const interactionType = (action) => {
         return "stdin_close";
     return "signal";
 };
-const performTerminalAction = (terminal, renderer, action, atMs) => {
+const performTerminalAction = (host, terminal, action, atMs) => {
     if (action.type === "send_input")
         terminal.write(action.data);
     else if (action.type === "resize") {
         terminal.resize(action.columns, action.rows);
-        renderer.resize(action.columns, action.rows, atMs);
+        // Rendered frames share the normalized clock used by captured terminal
+        // frames and by the scheduled-event resize path. Passing the raw elapsed
+        // time here stamped this frame on a different clock, so the next bucketed
+        // frame could appear to move backwards and fail capture validation with
+        // "rendered_frames: timestamps must be ordered".
+        host.renderer.resize(action.columns, action.rows, normalizeProcessElapsedTime(atMs, host.timeBucketMs));
     }
     else if (action.type === "close_stdin")
         terminal.closeInput();
@@ -67,7 +73,7 @@ const executeTerminalAction = (host, action) => {
     const atMs = elapsed(host);
     let outcome = "dispatched";
     try {
-        performTerminalAction(terminal, host.renderer, action, atMs);
+        performTerminalAction(host, terminal, action, atMs);
     }
     catch {
         outcome = "failed";

package/dist/application/ProcessReactiveHarness.js

@@ -49,6 +49,7 @@ export const startProcessReactiveHarness = (options) => {
                 journal: options.capture.journal,
                 startedAtMs: options.started,
                 now: Date.now,
+                timeBucketMs: options.scenario.normalization.time_bucket_ms,
             }, actions, signal),
         },
         onDecision: (decision, input) => {
@@ -89,12 +90,17 @@ export const startProcessReactiveHarness = (options) => {
     };
 };
 /** Project internal reducer state into the stable Process Capture shape. */
-export const projectProcessReactiveRun = (harness) => harness === undefined
-    ? null
-    : {
-        status: harness.coordinator.snapshot.status,
-        outcome: harness.coordinator.snapshot.outcome,
-        active_state: harness.coordinator.snapshot.active_state,
-        transitions: harness.coordinator.snapshot.transitions,
+export const projectProcessReactiveRun = (harness) => {
+    if (harness === undefined)
+        return null;
+    const snapshot = harness.coordinator.snapshot;
+    const completion = snapshot.status === "running"
+        ? { status: snapshot.status, outcome: null }
+        : { status: snapshot.status, outcome: snapshot.outcome };
+    return {
+        ...completion,
+        active_state: snapshot.active_state,
+        transitions: snapshot.transitions,
         controls: harness.controls,
     };
+};

package/dist/application/ProcessSampling.js

@@ -1,8 +1,6 @@
-import { execFile } from "node:child_process";
 import { readFile, readdir } from "node:fs/promises";
-import { promisify } from "node:util";
+import { execFileOutput } from "../process/ExecFileOutput.js";
 import { readProcessRunId } from "../process/ProcessOwnership.js";
-const execFileAsync = promisify(execFile);
 const PROC_READ_CONCURRENCY = 64;
 /** Prove that forkpty completed session setup and installed the run token. */
 export const isInitializedPtyRoot = (options) => {
@@ -210,7 +208,7 @@ const sampleLinux = async (context) => {
     return rows;
 };
 const readPsRows = async (signal) => {
-    const { stdout } = await execFileAsync("ps", ["-axo", "pid=,ppid=,pgid=,sess=,command="], { signal });
+    const { stdout } = await execFileOutput("ps", ["-axo", "pid=,ppid=,pgid=,sess=,command="], { signal });
     return stdout
         .split("\n")
         .map((line) => /\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(.*)/u.exec(line))

package/dist/application/ProcessTimer.js

@@ -0,0 +1,39 @@
+const systemTimerScheduler = (callback, delayMs) => {
+    const timer = setTimeout(callback, delayMs);
+    return { cancel: () => clearTimeout(timer) };
+};
+/** Schedule a delay using consecutive Node timers without shortening long waits. */
+export const scheduleProcessDelay = (delayMs, callback, schedule = systemTimerScheduler) => {
+    if (!Number.isSafeInteger(delayMs) || delayMs < 0)
+        throw new RangeError("Process delay must be a nonnegative safe integer");
+    const maximumTimerDelay = 2_147_483_647;
+    let remaining = delayMs;
+    let timer;
+    let cancelled = false;
+    const scheduleNext = () => {
+        if (cancelled)
+            return;
+        const interval = Math.min(remaining, maximumTimerDelay);
+        timer = schedule(() => {
+            if (cancelled)
+                return;
+            remaining -= interval;
+            if (remaining === 0)
+                callback();
+            else
+                scheduleNext();
+        }, interval);
+    };
+    scheduleNext();
+    return {
+        cancel: () => {
+            cancelled = true;
+            timer?.cancel();
+        },
+    };
+};
+/** Create an owned interval that shares process-capture cancellation handling. */
+export const scheduleProcessInterval = (callback, intervalMs) => {
+    const timer = setInterval(callback, intervalMs);
+    return { cancel: () => clearInterval(timer) };
+};