rea-agents 2.4.0 → 3.0.0

package/dist/application/JavaScriptSemanticGraphFlowProjection.js

@@ -1,7 +1,134 @@
 import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
-import { addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
+import { sourceRangesEqual } from "../domain/javascriptStaticAnalysisHelpers.js";
+import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
 import { inferredSemanticEvidenceAt, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
 import { semanticNodesWithinRange } from "./JavaScriptSemanticGraphProjection.js";
+/** Find the retained call-site node at one exact semantic source range. */
+export const semanticCallSiteAt = (context, location) => {
+    const call = context.ir.callSites.find(({ location: candidate }) => sourceRangesEqual(candidate, location));
+    return call === undefined
+        ? undefined
+        : context.callSiteNodes.get(call.callSiteId);
+};
+/** Project explicit static Promise/task ownership without runtime claims. */
+export const projectSemanticPromises = (context) => {
+    const promiseNodes = new Map(context.ir.promiseOperations.flatMap((operation) => {
+        const owner = operation.ownerCallableId === null
+            ? undefined
+            : context.callableNodes.get(operation.ownerCallableId);
+        const node = addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+            kind: operation.kind === "awaited-expression" ? "task" : "promise",
+            roleKey: operation.promiseId,
+            location: operation.location,
+            label: promiseLabel(operation),
+            functionNodeId: owner?.node_id ?? null,
+            properties: {
+                method: operation.method,
+                operation_kind: operation.kind,
+                ownership: operation.ownership,
+                source_resolution: operation.sourceResolution,
+            },
+        }, context.state));
+        return node === null ? [] : [[operation.promiseId, node]];
+    }));
+    for (const operation of context.ir.promiseOperations) {
+        const promise = promiseNodes.get(operation.promiseId);
+        if (promise === undefined)
+            continue;
+        projectPromiseCreation(context, operation, promise);
+        projectPromiseSources(context, operation, promise, promiseNodes);
+        projectPromiseOwnership(context, operation, promise);
+        if (operation.sourceResolution !== "complete" &&
+            ["chain", "aggregate", "awaited-expression"].includes(operation.kind))
+            addPromiseUnknown(context, operation, promise, promiseNodes);
+    }
+};
+const promiseLabel = (operation) => operation.kind === "awaited-expression"
+    ? "awaited expression"
+    : `Promise.${operation.method}`;
+const projectPromiseCreation = (context, operation, promise) => {
+    if (operation.kind === "awaited-expression")
+        return;
+    addSemanticGraphRelation(context.state, {
+        source: semanticCallSiteAt(context, operation.location),
+        target: promise,
+        relation: "creates-promise",
+        resolution: operation.kind === "chain" || operation.sourceResolution !== "complete"
+            ? "candidate"
+            : "resolved",
+    });
+};
+const projectPromiseSources = (context, operation, promise, promiseNodes) => {
+    for (const sourceId of operation.sourcePromiseIds) {
+        const source = promiseNodes.get(sourceId);
+        if (operation.kind === "aggregate")
+            addSemanticGraphRelation(context.state, {
+                source: promise,
+                target: source,
+                relation: "aggregates",
+                resolution: operation.sourceResolution === "complete" ? "resolved" : "candidate",
+            });
+        else
+            addSemanticGraphRelation(context.state, {
+                source,
+                target: promise,
+                relation: "chains",
+                resolution: operation.sourceResolution === "complete" ? "resolved" : "candidate",
+            });
+    }
+};
+const projectPromiseOwnership = (context, operation, promise) => {
+    const owner = operation.ownerCallableId === null
+        ? context.moduleNode
+        : context.callableNodes.get(operation.ownerCallableId);
+    if (operation.ownership === "awaited")
+        addSemanticGraphRelation(context.state, {
+            source: owner,
+            target: promise,
+            relation: "awaits",
+            resolution: "resolved",
+        });
+    else if (operation.ownership === "assigned")
+        addSemanticGraphRelation(context.state, {
+            source: operation.ownerBindingId === null
+                ? undefined
+                : context.bindingNodes.get(operation.ownerBindingId),
+            target: promise,
+            relation: "owns",
+            resolution: "resolved",
+        });
+    else if (operation.ownership === "returned")
+        addSemanticGraphRelation(context.state, {
+            source: operation.returnSiteId === null
+                ? undefined
+                : context.returnSiteNodes.get(operation.returnSiteId),
+            target: promise,
+            relation: "returns-task",
+            resolution: "resolved",
+        });
+    else if (operation.ownership === "detached")
+        addSemanticGraphRelation(context.state, {
+            source: owner,
+            target: promise,
+            relation: "detaches-task",
+            resolution: "resolved",
+        });
+};
+const addPromiseUnknown = (context, operation, promise, promiseNodes) => {
+    const relation = operation.kind === "aggregate" ? "aggregates" : "chains";
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: promise.node_id,
+        family: "promise-ownership",
+        relation_kinds: [relation],
+        reason: "ambiguous-target",
+        detail: `Static ${operation.method} source resolution was ${operation.sourceResolution}.`,
+        candidate_node_ids: operation.sourcePromiseIds.flatMap((identifier) => {
+            const candidate = promiseNodes.get(identifier);
+            return candidate === undefined ? [] : [candidate.node_id];
+        }),
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }));
+};
 /** Link direct return expressions to their retained semantic references. */
 export const projectSemanticReturnValues = (context) => {
     for (const callable of context.ir.callables)
@@ -14,18 +141,12 @@ export const projectSemanticReturnValues = (context) => {
                     target: returnNode,
                     relation: "aliases",
                     resolution: site.identityReferenceLocation !== null &&
-                        rangesEqual(reference.identity.source_range, site.identityReferenceLocation)
+                        sourceRangesEqual(reference.identity.source_range, site.identityReferenceLocation)
                         ? "resolved"
                         : "candidate",
                 });
         }
 };
-const rangesEqual = (left, right) => left !== null &&
-    right !== null &&
-    left.start.line === right.start.line &&
-    left.start.column === right.start.column &&
-    left.end.line === right.end.line &&
-    left.end.column === right.end.column;
 /** Link each captured binding to the callable at the exact reference site. */
 export const projectSemanticClosureCaptures = (context) => {
     for (const capture of context.ir.closureCaptures)

package/dist/application/JavaScriptSemanticGraphObjectProjection.js

@@ -0,0 +1,81 @@
+import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
+import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticPropertySlot } from "./JavaScriptSemanticGraphValueProjection.js";
+/** Project static object reads, writes, spreads, and destructuring. */
+export const projectSemanticObjects = (context) => {
+    for (const operation of context.ir.objectOperations) {
+        const occurrence = addObjectOccurrence(context, operation);
+        const slot = operation.objectBindingId === null || operation.propertyName === null
+            ? null
+            : semanticPropertySlot(context, operation.objectBindingId, operation.propertyName);
+        if (operation.kind === "read")
+            addSemanticGraphRelation(context.state, {
+                source: slot,
+                target: occurrence,
+                relation: "reads-property",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        else if (operation.kind === "write")
+            addSemanticGraphRelation(context.state, {
+                source: occurrence,
+                target: slot,
+                relation: "writes-property",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        else if (operation.kind === "destructure")
+            addSemanticGraphRelation(context.state, {
+                source: slot,
+                target: operation.targetBindingId === null
+                    ? undefined
+                    : context.bindingNodes.get(operation.targetBindingId),
+                relation: "destructures",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        else
+            addSemanticGraphRelation(context.state, {
+                source: operation.objectBindingId === null
+                    ? undefined
+                    : context.bindingNodes.get(operation.objectBindingId),
+                target: occurrence,
+                relation: "spreads",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        if (operation.resolution !== "complete")
+            addObjectUnknown(context, operation, slot ?? occurrence);
+    }
+};
+const addObjectOccurrence = (context, operation) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "expression",
+    roleKey: operation.objectOperationId,
+    location: operation.location,
+    label: operation.propertyName === null
+        ? operation.kind
+        : `${operation.kind}:${operation.propertyName}`,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: {
+        operation_kind: operation.kind,
+        property_name: operation.propertyName,
+    },
+}, context.state));
+const addObjectUnknown = (context, operation, node) => {
+    const relation = operation.kind === "read"
+        ? "reads-property"
+        : operation.kind === "write"
+            ? "writes-property"
+            : operation.kind === "spread"
+                ? "spreads"
+                : "destructures";
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: node?.node_id ?? null,
+        family: "object-flow",
+        relation_kinds: [relation],
+        reason: "ambiguous-target",
+        detail: `Static ${operation.kind} object identity is partial.`,
+        candidate_node_ids: [],
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }));
+};

package/dist/application/JavaScriptSemanticGraphProjection.js

@@ -15,18 +15,25 @@ export const semanticNodesWithinRange = (nodes, range) => nodes.filter((node) =>
     contains(range, node.identity.source_range));
 /** Report extractor support without treating missing families as absence. */
 export const semanticFamilyStatus = (family, analysis, truncated) => {
-    if (!["call-flow", "closure", "data-flow", "object-flow"].includes(family))
+    if (![
+        "call-flow",
+        "boundary",
+        "child-process",
+        "closure",
+        "configuration",
+        "data-flow",
+        "event",
+        "object-flow",
+        "promise-ownership",
+        "request",
+        "resource-lifecycle",
+        "timer",
+    ].includes(family))
         return "unsupported";
     if (truncated)
         return "unknown";
     return analysis.truncated_scopes === 0 ? "partial" : "unknown";
 };
-/** Compare two exact semantic source ranges. */
-export const semanticRangesEqual = (left, right) => left !== null &&
-    left.start.line === right.start.line &&
-    left.start.column === right.start.column &&
-    left.end.line === right.end.line &&
-    left.end.column === right.end.column;
 const contains = (outer, inner) => pointCompare(outer.start, inner.start) <= 0 &&
     pointCompare(outer.end, inner.end) >= 0;
 const pointCompare = (left, right) => left.line - right.line || left.column - right.column;

package/dist/application/JavaScriptSemanticGraphResourceProjection.js

@@ -0,0 +1,59 @@
+import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
+import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticCallSiteAt, } from "./JavaScriptSemanticGraphFlowProjection.js";
+/** Project built-in resource acquisition and exact local release handles. */
+export const projectSemanticResources = (context) => {
+    const resourceNodes = new Map(context.ir.resourceOperations.flatMap((operation) => {
+        if (operation.kind !== "acquire")
+            return [];
+        const node = addResourceNode(context, operation);
+        return node === null ? [] : [[operation.resourceId, node]];
+    }));
+    for (const operation of context.ir.resourceOperations)
+        if (operation.kind === "acquire")
+            addSemanticGraphRelation(context.state, {
+                source: semanticCallSiteAt(context, operation.location),
+                target: resourceNodes.get(operation.resourceId),
+                relation: "acquires",
+                resolution: "resolved",
+            });
+        else
+            projectRelease(context, operation, resourceNodes);
+};
+const addResourceNode = (context, operation) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "resource",
+    roleKey: operation.resourceId,
+    location: operation.location,
+    label: operation.method,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: { method: operation.method },
+}, context.state));
+const projectRelease = (context, operation, resourceNodes) => {
+    const callSite = semanticCallSiteAt(context, operation.location);
+    const resources = operation.linkedResourceIds.flatMap((identifier) => {
+        const resource = resourceNodes.get(identifier);
+        return resource === undefined ? [] : [resource];
+    });
+    for (const resource of resources)
+        addSemanticGraphRelation(context.state, {
+            source: callSite,
+            target: resource,
+            relation: "releases",
+            resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+        });
+    if (operation.resolution === "complete")
+        return;
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: callSite?.node_id ?? null,
+        family: "resource-lifecycle",
+        relation_kinds: ["releases"],
+        reason: "ambiguous-target",
+        detail: `Static ${operation.method} resource ownership is ambiguous.`,
+        candidate_node_ids: resources.map(({ node_id: identifier }) => identifier),
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }));
+};

package/dist/application/JavaScriptSemanticGraphValueProjection.js

@@ -0,0 +1,77 @@
+import { addSemanticGraphNode, addSemanticGraphRelation, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+/** Project bounded literal values and object slots for exact query seeds. */
+export const projectSemanticValues = (context) => {
+    for (const binding of context.ir.bindings) {
+        const bindingNode = context.bindingNodes.get(binding.bindingId);
+        if (bindingNode === undefined)
+            continue;
+        projectValue({
+            context,
+            binding,
+            value: binding.value,
+            target: bindingNode,
+            role: "binding",
+        });
+    }
+};
+const projectValue = (input) => {
+    const { context, binding, value, target, role } = input;
+    if (target === null)
+        return;
+    if (value.status === "literal") {
+        const literal = addLiteralNode(context, binding, value.value, role);
+        addSemanticGraphRelation(context.state, {
+            source: literal,
+            target,
+            relation: "defines",
+            resolution: "resolved",
+        });
+    }
+    else if (value.status === "union")
+        for (const primitive of value.values) {
+            const literal = addLiteralNode(context, binding, primitive, role);
+            addSemanticGraphRelation(context.state, {
+                source: literal,
+                target,
+                relation: "defines",
+                resolution: "candidate",
+            });
+        }
+    else if (value.status === "object")
+        for (const property of value.properties) {
+            const slot = semanticPropertySlot(context, binding.bindingId, property.name);
+            addSemanticGraphRelation(context.state, {
+                source: target,
+                target: slot,
+                relation: "writes-property",
+                resolution: value.unknownProperties ? "candidate" : "resolved",
+            });
+            projectValue({
+                context,
+                binding,
+                value: property.value,
+                target: slot,
+                role: `property:${property.name}`,
+            });
+        }
+};
+const addLiteralNode = (context, binding, value, role) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "literal",
+    roleKey: `literal:${binding.bindingId}:${role}:${JSON.stringify(value)}`,
+    location: binding.definitions[0]?.location ?? null,
+    label: JSON.stringify(value),
+    functionNodeId: context.bindingNodes.get(binding.bindingId)?.function_node_id ?? null,
+    properties: { value },
+}, context.state));
+/** Create one canonical property slot for a binding/property identity. */
+export const semanticPropertySlot = (context, objectBindingId, name) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "property-slot",
+    roleKey: `property:${objectBindingId}:${name}`,
+    location: null,
+    label: name,
+    functionNodeId: context.bindingNodes.get(objectBindingId)?.function_node_id ?? null,
+    properties: {
+        name,
+        object_binding_id: objectBindingId,
+    },
+}, context.state));

package/dist/application/LazyAnalysisProvider.js

@@ -0,0 +1,77 @@
+/**
+ * Preserve synchronous provider discovery while loading implementation modules
+ * only when a target-bound client first executes.
+ */
+export class LazyAnalysisProvider {
+    #providerIdentity;
+    #capabilityDescriptors;
+    #loadProvider;
+    #provider;
+    constructor(options) {
+        this.#providerIdentity = options.identity;
+        this.#capabilityDescriptors = options.capabilities;
+        this.#loadProvider = options.load;
+    }
+    /** Return generated provider identity without loading its implementation. */
+    identity() {
+        return this.#providerIdentity;
+    }
+    /** Return generated capability metadata without loading its implementation. */
+    capabilities() {
+        return this.#capabilityDescriptors;
+    }
+    /** Create a client whose implementation is loaded on first execution. */
+    createClient(target, profile, context) {
+        return new LazyAnalysisClient(async () => {
+            const provider = await this.#load();
+            return provider.createClient(target, profile, context);
+        });
+    }
+    async #load() {
+        this.#provider ??= this.#loadProvider().catch((cause) => {
+            this.#provider = undefined;
+            throw cause;
+        });
+        return this.#provider;
+    }
+}
+class LazyAnalysisClient {
+    #loadClient;
+    #client;
+    #loading;
+    #closed = false;
+    constructor(loadClient) {
+        this.#loadClient = loadClient;
+    }
+    execute = async (operation, parameters, options) => {
+        const client = await this.#load();
+        return client.execute(operation, parameters, options);
+    };
+    runtimeLineageSnapshots() {
+        return this.#client?.runtimeLineageSnapshots?.() ?? [];
+    }
+    requestActivitySnapshots() {
+        return this.#client?.requestActivitySnapshots?.() ?? [];
+    }
+    async close() {
+        this.#closed = true;
+        if (this.#loading === undefined)
+            return;
+        const client = await this.#loading;
+        await client.close();
+    }
+    async #load() {
+        if (this.#closed)
+            throw new Error("Lazy analysis client is closed");
+        this.#loading ??= this.#loadClient()
+            .then((client) => {
+            this.#client = client;
+            return client;
+        })
+            .catch((cause) => {
+            this.#loading = undefined;
+            throw cause;
+        });
+        return this.#loading;
+    }
+}

package/dist/application/LoopbackReplay.js

@@ -374,11 +374,11 @@ export const startLoopbackReplay = async (scenario, recordEvent = () => undefine
         async close() {
             closePromise ??= (async () => {
                 recorder.stopMachineAdmission();
+                await recorder.drainMachine();
                 for (const client of websocket.clients)
                     client.terminate();
                 await new Promise((resolveClose) => websocket.close(() => resolveClose()));
                 await closeReplayServer(server);
-                await recorder.drainMachine();
             })();
             await closePromise;
         },

package/dist/application/NativeApiInspection.js

@@ -0,0 +1,80 @@
+import { nativeApiInspectionResultSchema, } from "../domain/nativeApiBoundary.js";
+const unavailableBoundary = () => ({
+    available: false,
+    reason: "The selected provider did not expose a structured native API boundary model.",
+    residual_unknowns: [
+        "What are the function's return and parameter boundary types?",
+        "Does this function dispatch through a jump table with recoverable data addresses?",
+    ],
+});
+/** Project one analyzed-function dossier into inspectable native API substeps. */
+export const projectNativeApiInspection = (dossier) => {
+    const boundary = dossier.native_api ?? unavailableBoundary();
+    const unsupportedBranches = boundary.available
+        ? []
+        : ["structured-boundary-types", "jump-table-data-mapping"];
+    const residualUnknowns = boundary.available
+        ? availableResidualUnknowns(boundary)
+        : boundary.residual_unknowns;
+    return nativeApiInspectionResultSchema.parse({
+        schema_version: 1,
+        procedure: {
+            address: dossier.procedure.address,
+            name: dossier.procedure.name,
+        },
+        boundary,
+        substeps: [
+            {
+                operation: "analyze_function",
+                status: "completed",
+                observations: [
+                    "provider function dossier",
+                    "provider pseudocode classification",
+                    "provider control-flow observations",
+                ],
+            },
+            {
+                operation: "project_native_api_boundary",
+                status: boundary.available ? "completed" : "unsupported",
+                observations: boundary.available
+                    ? [
+                        "return and parameter boundary types",
+                        "confidence and inference evidence",
+                        "jump-table dispatch, data, and target addresses",
+                    ]
+                    : [boundary.reason],
+            },
+            {
+                operation: "preserve_residual_unknowns",
+                status: "completed",
+                observations: residualUnknowns.length === 0
+                    ? ["no additional structured-boundary unknowns"]
+                    : residualUnknowns,
+            },
+        ],
+        unsupported_branches: unsupportedBranches,
+        residual_unknowns: residualUnknowns,
+    });
+};
+const availableResidualUnknowns = (boundary) => {
+    const unknowns = [];
+    if (boundary.parameters_truncated)
+        unknowns.push("Which additional parameters were omitted by the native API boundary limit?");
+    if (boundary.jump_tables_truncated)
+        unknowns.push("Which additional jump tables were omitted by the native API boundary limit?");
+    for (const table of boundary.jump_tables) {
+        if (table.data_sources_truncated || table.mappings_truncated)
+            unknowns.push(`Which additional data sources or targets were omitted for the jump table dispatched at ${table.dispatch_address}?`);
+        if (table.data_sources.length === 0)
+            unknowns.push(`What backing data address produced the jump table dispatched at ${table.dispatch_address}?`);
+        if (table.data_sources.some(({ entry_count: count, entry_size_bytes: size }) => count === null || size === null))
+            unknowns.push(`What are the exact entry size and count for candidate jump-table data dispatched at ${table.dispatch_address}?`);
+        if (table.mappings.some(({ case_value: value }) => value === null))
+            unknowns.push(`Which source-level case values correspond to every target dispatched at ${table.dispatch_address}?`);
+    }
+    for (const value of [boundary.return_type, ...boundary.parameters]) {
+        if (value.confidence === "low")
+            unknowns.push(`Can the inferred ${value.role} type ${value.data_type} be confirmed with imported metadata or an ABI probe?`);
+    }
+    return [...new Set(unknowns)];
+};

package/dist/application/ProcessReactiveEffects.js

@@ -7,6 +7,8 @@ const interactionData = (action) => {
             : action.data;
     if (action.type === "resize")
         return `${String(action.columns)}x${String(action.rows)}`;
+    if (action.type === "close_stdin")
+        return "";
     return action.signal;
 };
 const interactionType = (action) => {
@@ -14,6 +16,8 @@ const interactionType = (action) => {
         return "input";
     if (action.type === "resize")
         return "resize";
+    if (action.type === "close_stdin")
+        return "stdin_close";
     return "signal";
 };
 const performTerminalAction = (terminal, renderer, action, atMs) => {
@@ -23,6 +27,8 @@ const performTerminalAction = (terminal, renderer, action, atMs) => {
         terminal.resize(action.columns, action.rows);
         renderer.resize(action.columns, action.rows, atMs);
     }
+    else if (action.type === "close_stdin")
+        terminal.closeInput();
     else
         terminal.kill(action.signal);
 };

package/dist/application/ProcessReactiveHarness.js

@@ -3,6 +3,21 @@ import { ProcessReactiveCoordinator } from "./ProcessReactiveCoordinator.js";
 import { executeProcessReactiveEffects, unsupportedProcessReactiveFeatures, } from "./ProcessReactiveEffects.js";
 import { subscribeProcessReactiveObservations } from "./ProcessReactiveObservations.js";
 import { normalizeProcessSamples, normalizeProcessShimEvent, redactProtocolEvents, } from "./ProcessNormalization.js";
+const reactiveTerminalFor = (terminal) => {
+    if (terminal === undefined)
+        return undefined;
+    return {
+        write: (data) => terminal.write(data),
+        resize: (columns, rows) => terminal.resize(columns, rows),
+        closeInput: () => {
+            const end = Reflect.get(terminal, "end");
+            if (typeof end !== "function")
+                throw new ProcessCaptureError("PTY backend does not expose an stdin-close operation");
+            Reflect.apply(end, terminal, []);
+        },
+        kill: (signal) => terminal.kill(signal),
+    };
+};
 const controlKind = (input) => input.kind === "observation" ? undefined : input.kind;
 /** Reject reactive declarations the current process adapter cannot execute. */
 export const assertSupportedReactiveScenario = (scenario) => {
@@ -27,7 +42,7 @@ export const startProcessReactiveHarness = (options) => {
         scenario: options.scenario.reactive,
         executor: {
             execute: (actions, signal) => executeProcessReactiveEffects({
-                terminal: options.terminal,
+                terminal: () => reactiveTerminalFor(options.terminal()),
                 renderer: options.renderer,
                 checkpoints: options.checkpoints,
                 interactions: options.capture.interactions,

package/dist/application/ProjectPermissionStore.js

@@ -11,6 +11,7 @@ const grantSchema = z.object({
     capability: z.enum([
         "process_capture",
         "browser_observe",
+        "browser_automate",
         "electron_observe",
         "evidence_read",
         "evidence_write",