rea-agents 1.7.0 → 2.1.0

package/dist/application/ManagedReconstructionService.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { importManagedReconstruction, managedReconstructionImportInputSchema, } from "../domain/managedReconstruction.js";
+import { err, ok } from "../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+const OPERATION = "import_managed_reconstruction";
+/** Authenticate and import managed decompiler reconstruction as Evidence. */
+export const importManagedReconstructionEvidence = (rawInput) => {
+    const parsed = managedReconstructionImportInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+    return importManagedReconstructionEvidenceValidated(parsed.data);
+};
+/** Import reconstruction from input parsed by a trusted adapter. */
+export const importManagedReconstructionEvidenceValidated = (input) => {
+    try {
+        const result = importManagedReconstruction(input);
+        return ok(createManagedReconstructionEvidence(input, result));
+    }
+    catch (cause) {
+        return err(cause instanceof TypeError || cause instanceof z.ZodError
+            ? new AnalysisInputError(OPERATION, { cause })
+            : new AnalysisProtocolError("Managed reconstruction import produced an invalid result", { cause }));
+    }
+};
+const createManagedReconstructionEvidence = (input, result) => createEvidence({
+    path: result.static_observation.artifact_path,
+    sha256: result.static_observation.artifact_sha256,
+    format: "pe",
+}, MANAGED_WORKFLOW_PROVIDER, {
+    predicateType: "rea.managed-reconstruction-import/v1",
+    operation: OPERATION,
+    parameters: {
+        static_members_evidence_id: input.static_members.evidence_id,
+        decompiler: jsonValueSchema.parse(result.decompiler),
+        method_locks: jsonValueSchema.parse(input.methods.map(({ token, signature_sha256, normalized_il_sha256 }) => ({
+            token,
+            signature_sha256,
+            normalized_il_sha256,
+        }))),
+        notes: jsonValueSchema.parse(input.notes),
+    },
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    locations: [
+        {
+            kind: "artifact-path",
+            path: result.static_observation.artifact_path,
+        },
+    ],
+    evidenceLinks: result.evidence_links,
+});

package/dist/application/ManagedRuntimeCorrelationService.js

@@ -0,0 +1,103 @@
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { createEvidence, parseEvidence, } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { managedRuntimeCorrelationInputSchema, planManagedRuntimeCorrelation, } from "../domain/managedRuntimeCorrelation.js";
+import { err, ok } from "../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { digestJson } from "./JavaScriptReplayPlanning.js";
+const OPERATION = "plan_managed_runtime_correlation";
+/** Create a separately authorized, non-executing managed runtime plan Evidence. */
+export const planManagedRuntimeCorrelationEvidence = async (dependencies, rawInput) => {
+    const parsed = managedRuntimeCorrelationInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+    return planManagedRuntimeCorrelationEvidenceValidated(dependencies, parsed.data);
+};
+/** Plan runtime correlation from input parsed by a trusted adapter. */
+export const planManagedRuntimeCorrelationEvidenceValidated = async (dependencies, input) => {
+    if (!dependencies.policy.enabled)
+        return err(new AnalysisCapabilityUnavailableError(MANAGED_WORKFLOW_PROVIDER.id, OPERATION, "managed runtime correlation is disabled; configure exact roots and runtime executable before enabling it"));
+    if (dependencies.authority === undefined)
+        return err(new AnalysisCapabilityUnavailableError(MANAGED_WORKFLOW_PROVIDER.id, OPERATION, "managed runtime permission policy is not configured"));
+    let staticEvidence;
+    let artifactPath;
+    try {
+        staticEvidence = parseEvidence(input.static_members);
+        artifactPath = artifactPathFor(staticEvidence);
+    }
+    catch (cause) {
+        return err(new AnalysisInputError(OPERATION, { cause }));
+    }
+    const authorized = await dependencies.authority.explain({
+        capability: "managed_runtime",
+        roots: [artifactPath],
+        executables: [dependencies.policy.executablePath],
+        environment_names: [],
+        network: "none",
+        mount: false,
+        operation_identity: operationIdentity(input, staticEvidence),
+    }, "read", { restartRequired: true });
+    if (!authorized.ok)
+        return err(authorized.error instanceof PermissionRequiredError
+            ? authorized.error
+            : new AnalysisProtocolError(authorized.error.message, {
+                cause: authorized.error,
+            }));
+    try {
+        const result = planManagedRuntimeCorrelation(input, dependencies.policy.executablePath, authorized.value.grant_id);
+        return ok(createEvidence({
+            path: result.static_observation.artifact_path,
+            sha256: result.static_observation.artifact_sha256,
+            format: "pe",
+        }, MANAGED_WORKFLOW_PROVIDER, {
+            predicateType: "rea.managed-runtime-correlation-plan/v1",
+            operation: OPERATION,
+            parameters: {
+                static_members_evidence_id: staticEvidence.evidence_id,
+                method: jsonValueSchema.parse(input.method),
+                requested_effect: input.requested_effect,
+                host: jsonValueSchema.parse(input.host),
+                bounds: jsonValueSchema.parse(input.bounds),
+            },
+            result: jsonValueSchema.parse(result),
+            rawResult: null,
+            confidence: "derived",
+            authority: "analyst-inference",
+            environment: null,
+            limitations: result.limitations,
+            locations: [
+                {
+                    kind: "artifact-path",
+                    path: result.static_observation.artifact_path,
+                },
+            ],
+            evidenceLinks: result.evidence_links,
+        }));
+    }
+    catch (cause) {
+        return err(cause instanceof TypeError
+            ? new AnalysisInputError(OPERATION, { cause })
+            : new AnalysisProtocolError("Managed runtime correlation planning produced an invalid result", { cause }));
+    }
+};
+const artifactPathFor = (evidence) => {
+    const result = evidence.normalized_result;
+    if (typeof result === "object" &&
+        result !== null &&
+        "artifact" in result &&
+        typeof result.artifact === "object" &&
+        result.artifact !== null &&
+        "path" in result.artifact &&
+        typeof result.artifact.path === "string")
+        return result.artifact.path;
+    throw new AnalysisInputError(OPERATION, {
+        cause: new TypeError("Managed member Evidence does not expose an artifact path"),
+    });
+};
+const operationIdentity = (input, evidence) => `${OPERATION}:${digestJson({
+    evidence_id: evidence.evidence_id,
+    method: input.method,
+    requested_effect: input.requested_effect,
+    host: input.host,
+    bounds: input.bounds,
+})}`;

package/dist/application/NodeRuntimeCharacterizationService.js

@@ -0,0 +1,196 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { nodeCharacterizationExecutionInputSchema, nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationInputSchema, nodeCharacterizationPreparationOutputSchema, } from "../domain/nodeRuntimeCharacterization.js";
+import { AnalysisInputError, AnalysisProtocolError, ReplayPlanStaleError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { controlledReplayOutputSchema } from "../domain/javascriptReplay.js";
+import { createRuntimeCharacterizationPlan, } from "../domain/runtimeCharacterization.js";
+import { err, ok } from "../domain/result.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { InstrumentedJavaScriptReplayHost } from "./InstrumentedJavaScriptReplayHost.js";
+import { runControlledReplayValidated, } from "./JavaScriptReplayService.js";
+const PREPARE_OPERATION = "prepare_node_characterization";
+const EXECUTE_OPERATION = "execute_node_characterization";
+const PROVIDER = {
+    id: "rea-node-characterization",
+    name: "REA Node runtime characterization",
+    version: "1",
+};
+/** Prepare exact Node/JavaScript characterization without executing target code. */
+export const prepareNodeCharacterization = async (dependencies, rawInput, options = {}) => {
+    const parsed = nodeCharacterizationPreparationInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(PREPARE_OPERATION, { cause: parsed.error }));
+    const prepared = await prepareValidated(dependencies, parsed.data, options);
+    return prepared.ok
+        ? ok(jsonValueSchema.parse(nodeCharacterizationPreparationOutputSchema.parse(prepared.value)))
+        : prepared;
+};
+/** Execute only a freshly recomputed and separately approved characterization plan. */
+export const executeNodeCharacterization = async (dependencies, rawInput, options = {}) => {
+    const parsed = nodeCharacterizationExecutionInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(EXECUTE_OPERATION, { cause: parsed.error }));
+    const prepared = await prepareValidated(dependencies, parsed.data.preparation, options);
+    if (!prepared.ok)
+        return prepared;
+    if (prepared.value.plan.plan_sha256 !== parsed.data.approved_plan_sha256)
+        return err(new ReplayPlanStaleError(parsed.data.approved_plan_sha256, prepared.value.plan.plan_sha256));
+    const plannedReplay = controlledReplayOutputSchema.parse(prepared.value.replay);
+    if (plannedReplay.phase !== "plan" || plannedReplay.plan === null)
+        return err(new AnalysisProtocolError("Node characterization preparation did not produce a replay plan"));
+    const host = new InstrumentedJavaScriptReplayHost(dependencies.host, parsed.data.preparation.instrumentation);
+    const executed = await runControlledReplayValidated({ ...dependencies, host }, {
+        ...parsed.data.preparation.replay,
+        mode: "execute",
+        approved: true,
+        plan_digest: plannedReplay.plan.plan_digest,
+    }, options);
+    if (!executed.ok)
+        return executed;
+    if (host.instrumentation === null)
+        return err(new AnalysisProtocolError("Node characterization execution omitted instrumentation evidence"));
+    return ok(jsonValueSchema.parse(nodeCharacterizationExecutionOutputSchema.parse({
+        schema_version: 1,
+        phase: "execution",
+        plan: prepared.value.plan,
+        transformation: host.instrumentation.manifest,
+        transformation_evidence: prepared.value.transformation_evidence,
+        evidence: createCharacterizationEvidence(prepared.value, controlledReplayOutputSchema.parse(executed.value)),
+        replay: controlledReplayOutputSchema.parse(executed.value),
+    })));
+};
+const prepareValidated = async (dependencies, input, options) => {
+    const host = new InstrumentedJavaScriptReplayHost(dependencies.host, input.instrumentation);
+    const replay = await runControlledReplayValidated({ ...dependencies, host }, input.replay, options);
+    if (!replay.ok)
+        return replay;
+    const output = controlledReplayOutputSchema.parse(replay.value);
+    if (output.phase !== "plan" ||
+        output.plan === null ||
+        host.instrumentation === null)
+        return err(new AnalysisProtocolError("Node characterization preparation omitted committed plan evidence"));
+    const module = output.plan.left.modules.find(({ alias }) => alias === input.selected_alias);
+    if (module === undefined)
+        return err(new AnalysisProtocolError("Node characterization replay plan omitted selected module"));
+    const plan = createCharacterizationPlan(input, host.instrumentation, output.plan);
+    return ok({
+        schema_version: 1,
+        phase: "preparation",
+        plan,
+        transformation: host.instrumentation.manifest,
+        transformation_evidence: createTransformationEvidence(input, host.instrumentation),
+        replay: output,
+    });
+};
+const createTransformationEvidence = (input, instrumentation) => createEvidence({
+    path: input.instrumentation.artifact_path,
+    sha256: input.instrumentation.artifact_sha256,
+    format: "javascript-bundle",
+}, PROVIDER, {
+    predicateType: "rea.javascript-export-transformation/v1",
+    operation: PREPARE_OPERATION,
+    parameters: {
+        selected_alias: input.selected_alias,
+        selected_sha256: input.instrumentation.selection.selected_sha256,
+    },
+    result: jsonValueSchema.parse(instrumentation.manifest),
+    confidence: "derived",
+    authority: "shipped-artifact",
+    locations: [
+        {
+            kind: "file-offset-range",
+            start: input.instrumentation.selection.byte_start,
+            end: input.instrumentation.selection.byte_end,
+        },
+    ],
+    limitations: [
+        "The transformation is deterministic derived evidence; execution authority is established only by a separately approved characterization run.",
+    ],
+});
+const createCharacterizationEvidence = (prepared, replay) => {
+    if (replay.phase !== "execute" || replay.evidence === null)
+        throw new AnalysisProtocolError("Node characterization execution omitted replay Evidence");
+    return createEvidence({
+        path: prepared.plan.artifact.path,
+        sha256: prepared.plan.artifact.sha256,
+        format: "javascript-bundle",
+    }, PROVIDER, {
+        predicateType: "rea.runtime-characterization/v1",
+        operation: EXECUTE_OPERATION,
+        parameters: {
+            plan_sha256: prepared.plan.plan_sha256,
+            replay_evidence_id: replay.evidence.evidence_id,
+        },
+        result: jsonValueSchema.parse({
+            plan: prepared.plan,
+            transformation_evidence_id: prepared.transformation_evidence.evidence_id,
+            replay_evidence_id: replay.evidence.evidence_id,
+            execution: replay.evidence.normalized_result,
+        }),
+        confidence: "observed",
+        authority: "controlled-replay",
+        environment: replay.evidence.environment,
+        limitations: [
+            "This Evidence proves only the finite approved characterization plan and transformed controlled-replay authority, not unmodified shipped-runtime equivalence.",
+            ...replay.evidence.limitations,
+        ],
+        evidenceLinks: [
+            prepared.transformation_evidence.evidence_id,
+            replay.evidence.evidence_id,
+        ],
+    });
+};
+const createCharacterizationPlan = (input, instrumentation, replayPlan) => createRuntimeCharacterizationPlan({
+    schema_version: 1,
+    preparation_sha256: digestPreparation(instrumentation.manifest.instrumented_sha256, replayPlan.plan_digest),
+    artifact: {
+        path: input.instrumentation.artifact_path,
+        sha256: input.instrumentation.artifact_sha256,
+        byte_length: instrumentation.manifest.original_byte_length,
+    },
+    runtime: {
+        family: "ecmascript",
+        provider_id: "node-javascript",
+        executable_path: replayPlan.runtime.executable.path,
+        executable_sha256: replayPlan.runtime.executable.sha256,
+        version: replayPlan.runtime.executable.version,
+        profile_sha256: replayPlan.policy_sha256,
+    },
+    callable: {
+        callable_id: `callable/${input.instrumentation.selection.selected_sha256}`,
+        module_id: stableModuleId(input.selected_alias),
+        export_name: input.instrumentation.selection.export_name,
+        semantic_evidence_id: null,
+        selector_sha256: input.instrumentation.selection.selected_sha256,
+    },
+    working_directory: "/work",
+    isolated_home: "/work",
+    expected_effect: input.expected_effect,
+    allowed_boundaries: [],
+    limits: {
+        max_calls: replayPlan.cases.length,
+        max_processes: 0,
+        max_files: 0,
+        max_bytes: replayPlan.limits.output_bytes,
+        max_handles: replayPlan.limits.tasks,
+        timeout_ms: replayPlan.limits.wall_time_ms,
+        idle_timeout_ms: replayPlan.limits.wall_time_ms,
+    },
+    determinism: {
+        clock: "fixed",
+        randomness: "seeded",
+        identifiers: "deterministic",
+        seed: replayPlan.determinism.random_seed,
+    },
+    authority: {
+        preparation_approved: true,
+        execution_approved: false,
+        network: "none",
+        provider_owned_process_only: true,
+    },
+});
+const digestPreparation = (instrumentedSha256, replayPlanDigest) => createHash("sha256")
+    .update(`rea.node-characterization-preparation/v1\0${instrumentedSha256}\0${replayPlanDigest}`)
+    .digest("hex");
+const stableModuleId = (alias) => `module/${createHash("sha256").update(alias).digest("hex")}`;

package/dist/application/PermissionAuthority.js

@@ -73,31 +73,52 @@ const errorReason = (error) => isNotFound(error) ? "not_found" : "io";
 /** Stateful owner for permission evaluation, consumption, reload, and revoke. */
 export class PermissionAuthority {
     policy;
-    constructor(policy) {
+    configuredAuthority;
+    constructor(policy, configuredAuthority) {
         this.policy = policy;
+        this.configuredAuthority = configuredAuthority;
+    }
+    /** Create a connection-owned overlay for once and session grants. */
+    createConnectionAuthority() {
+        return new PermissionAuthority(createPermissionPolicy([]), this.configuredAuthority ?? this);
     }
     /** Canonicalize and authorize one exact operation before its side effect. */
     async authorize(request, access, options = {}) {
-        const evaluated = await this.explain(request, access, options);
+        const evaluated = await this.evaluateRequest(request, access, options);
         if (!evaluated.ok)
             return evaluated;
-        const decision = evaluated.value;
-        this.policy = consumePermission(this.policy, decision);
-        return ok(decision);
+        const { decision, owner, request: canonicalRequest } = evaluated.value;
+        owner.policy = consumePermission(owner.policy, decision);
+        return ok({ ...decision, request: canonicalRequest });
     }
     /** Dry-run the exact shared evaluation without consuming a once grant. */
     async explain(request, access, options = {}) {
+        const evaluated = await this.evaluateRequest(request, access, options);
+        return evaluated.ok
+            ? ok({
+                ...evaluated.value.decision,
+                request: evaluated.value.request,
+            })
+            : evaluated;
+    }
+    async evaluateRequest(request, access, options) {
         const canonical = await canonicalizePermissionRequest(request, access);
         if (!canonical.ok)
             return canonical;
-        const decision = evaluatePermission(this.policy, canonical.value);
-        if (!decision.allowed)
-            return err(new PermissionRequiredError(canonical.value, decision.missing, ceilingFor(this.policy, canonical.value.capability), options.elicitationSupported ?? false, options.restartRequired ?? false));
-        return ok(decision);
+        const evaluated = this.evaluateCanonical(canonical.value, options);
+        return evaluated.ok
+            ? ok({ ...evaluated.value, request: canonical.value })
+            : evaluated;
     }
     /** Add authority beneath the administrator ceiling. */
     grant(grant) {
-        const result = grantPermission(this.policy, grant);
+        const policy = this.configuredAuthority === undefined
+            ? this.policy
+            : {
+                ...this.policy,
+                ceilings: this.configuredAuthority.effectivePolicy().ceilings,
+            };
+        const result = grantPermission(policy, grant);
         if (result.ok)
             this.policy = result.value;
         return result;
@@ -110,44 +131,61 @@ export class PermissionAuthority {
     clearSessionGrants() {
         this.policy = clearSessionPermissions(this.policy);
     }
-    /** Atomically replace optional persisted project grants. */
-    async replaceProjectGrants(grants) {
-        let candidate = {
-            ...this.policy,
-            grants: this.policy.grants.filter(({ lifetime }) => lifetime !== "project"),
+    effectivePolicy() {
+        if (this.configuredAuthority === undefined)
+            return this.policy;
+        const configured = this.configuredAuthority.effectivePolicy();
+        return {
+            ceilings: configured.ceilings,
+            grants: [...configured.grants, ...this.policy.grants],
+            revoked_grant_ids: new Set([
+                ...configured.revoked_grant_ids,
+                ...this.policy.revoked_grant_ids,
+            ]),
+            consumed_grant_ids: new Set([
+                ...configured.consumed_grant_ids,
+                ...this.policy.consumed_grant_ids,
+            ]),
         };
-        for (const grant of grants) {
-            const canonical = await canonicalizeGrant(grant);
-            if (!canonical.ok)
-                return canonical;
-            const added = grantPermission(candidate, canonical.value);
-            if (!added.ok)
-                return err(new PermissionPathError(grant.grant_id, "io", {
-                    cause: added.error,
-                }));
-            candidate = added.value;
+    }
+    evaluateCanonical(request, options) {
+        const configured = this.configuredAuthority;
+        if (configured !== undefined) {
+            const configuredDecision = evaluatePermission(configured.effectivePolicy(), request);
+            if (configuredDecision.allowed)
+                return ok({ decision: configuredDecision, owner: configured });
         }
-        this.policy = candidate;
-        return ok(null);
+        const localPolicy = configured === undefined
+            ? this.policy
+            : { ...this.policy, ceilings: configured.effectivePolicy().ceilings };
+        const localDecision = evaluatePermission(localPolicy, request);
+        if (localDecision.allowed)
+            return ok({ decision: localDecision, owner: this });
+        const effective = this.effectivePolicy();
+        const denied = evaluatePermission(effective, request);
+        if (denied.allowed)
+            return ok({ decision: denied, owner: this });
+        return err(new PermissionRequiredError(request, denied.missing, ceilingFor(effective, request.capability), options.elicitationSupported ?? false, options.restartRequired ?? false));
+    }
+    /** Atomically replace optional persisted project grants. */
+    async replaceProjectGrants(grants) {
+        return this.replaceGrants(grants, "project");
     }
     /** Replace grants derived from the currently loaded administrator ceiling. */
     async replaceAdministratorGrants(grants) {
-        let candidate = {
+        return this.replaceGrants(grants, "administrator");
+    }
+    async replaceGrants(grants, lifetime) {
+        const canonical = await canonicalizeGrants(grants);
+        if (!canonical.ok)
+            return canonical;
+        const replaced = addGrantsToPolicy({
             ...this.policy,
-            grants: this.policy.grants.filter(({ lifetime }) => lifetime !== "administrator"),
-        };
-        for (const grant of grants) {
-            const canonical = await canonicalizeGrant(grant);
-            if (!canonical.ok)
-                return canonical;
-            const added = grantPermission(candidate, canonical.value);
-            if (!added.ok)
-                return err(new PermissionPathError(grant.grant_id, "io", {
-                    cause: added.error,
-                }));
-            candidate = added.value;
-        }
-        this.policy = candidate;
+            grants: this.policy.grants.filter((grant) => grant.lifetime !== lifetime),
+        }, canonical.value);
+        if (!replaced.ok)
+            return replaced;
+        this.policy = replaced.value;
         return ok(null);
     }
     /** Atomically replace reloadable ceilings and persisted grants. */
@@ -155,29 +193,20 @@ export class PermissionAuthority {
         const ceilings = await canonicalizePermissionCeilings(configuration.ceilings);
         if (!ceilings.ok)
             return ceilings;
-        const grants = [];
-        for (const grant of [
+        const grants = await canonicalizeGrants([
             ...configuration.administratorGrants,
             ...configuration.projectGrants,
-        ]) {
-            const canonical = await canonicalizeGrant(grant);
-            if (!canonical.ok)
-                return canonical;
-            grants.push(canonical.value);
-        }
-        let candidate = {
+        ]);
+        if (!grants.ok)
+            return grants;
+        const candidate = {
             ...reloadPermissionCeilings(this.policy, ceilings.value),
             grants: this.policy.grants.filter(({ lifetime }) => lifetime !== "administrator" && lifetime !== "project"),
         };
-        for (const grant of grants) {
-            const added = grantPermission(candidate, grant);
-            if (!added.ok)
-                return err(new PermissionPathError(grant.grant_id, "io", {
-                    cause: added.error,
-                }));
-            candidate = added.value;
-        }
-        this.policy = candidate;
+        const replaced = addGrantsToPolicy(candidate, grants.value);
+        if (!replaced.ok)
+            return replaced;
+        this.policy = replaced.value;
         return ok(null);
     }
     /** Replace ceilings without restarting the MCP process. */
@@ -194,17 +223,31 @@ export const createPermissionAuthority = async (ceilings, grants = []) => {
     const canonical = await canonicalizePermissionCeilings(ceilings);
     if (!canonical.ok)
         return canonical;
-    let policy = createPermissionPolicy(canonical.value);
+    const canonicalGrants = await canonicalizeGrants(grants);
+    if (!canonicalGrants.ok)
+        return canonicalGrants;
+    const policy = addGrantsToPolicy(createPermissionPolicy(canonical.value), canonicalGrants.value);
+    return policy.ok ? ok(new PermissionAuthority(policy.value)) : policy;
+};
+const canonicalizeGrants = async (grants) => {
+    const canonical = [];
     for (const grant of grants) {
         const canonicalGrant = await canonicalizeGrant(grant);
         if (!canonicalGrant.ok)
             return canonicalGrant;
-        const added = grantPermission(policy, canonicalGrant.value);
+        canonical.push(canonicalGrant.value);
+    }
+    return ok(canonical);
+};
+const addGrantsToPolicy = (initial, grants) => {
+    let policy = initial;
+    for (const grant of grants) {
+        const added = grantPermission(policy, grant);
         if (!added.ok)
             return err(new PermissionPathError(grant.grant_id, "io", { cause: added.error }));
         policy = added.value;
     }
-    return ok(new PermissionAuthority(policy));
+    return ok(policy);
 };
 const canonicalizeGrant = async (grant) => {
     const scope = await canonicalizeScope(grant, "read");

package/dist/application/ProcessCaptureCapability.js

@@ -1,8 +1,8 @@
 import { tmpdir } from "node:os";
-import { spawn } from "node-pty";
 /** Probe the actual native PTY seam instead of inferring support from the OS name. */
 export const probeProcessCaptureCapability = async () => {
     try {
+        const { spawn } = await import("@lydell/node-pty");
         const terminal = spawn(process.platform === "win32" ? "cmd.exe" : "/bin/sh", process.platform === "win32" ? ["/c", "exit", "0"] : ["-c", "exit 0"], {
             cwd: tmpdir(),
             env: { HOME: tmpdir(), TERM: "xterm-256color" },

package/dist/application/ProcessCapturePermission.js

@@ -0,0 +1,13 @@
+/** Build the exact permission request shared by process-capture adapters. */
+export const processCapturePermissionRequest = (scenario) => ({
+    capability: "process_capture",
+    roots: [scenario.working_directory, ...scenario.filesystem_roots],
+    executables: [scenario.executable],
+    environment_names: [
+        ...Object.keys(scenario.environment),
+        ...scenario.inherit_environment,
+    ],
+    network: scenario.network_access === "host" ? "external" : "none",
+    mount: false,
+    operation_identity: `capture_process_scenario:${scenario.executable}`,
+});

package/dist/application/ProcessCli.js

@@ -5,6 +5,7 @@ import { createEvidence, parseEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { compareProcessCaptures, LEGACY_PROCESS_CAPTURE_MESSAGE, 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;
@@ -25,18 +26,7 @@ export const captureProcessScenarioFile = async (path) => {
         const authority = await loadConfiguredPermissionAuthority(config.value);
         if (!authority.ok)
             return cliAnalysisError(authority.error);
-        const authorized = await authority.value.authorize({
-            capability: "process_capture",
-            roots: [scenario.working_directory, ...scenario.filesystem_roots],
-            executables: [scenario.executable],
-            environment_names: [
-                ...Object.keys(scenario.environment),
-                ...scenario.inherit_environment,
-            ],
-            network: scenario.network_access === "host" ? "external" : "none",
-            mount: false,
-            operation_identity: `capture_process_scenario:${scenario.executable}`,
-        }, "read");
+        const authorized = await authority.value.authorize(processCapturePermissionRequest(scenario), "read");
         if (!authorized.ok)
             return cliAnalysisError(authorized.error instanceof PermissionRequiredError
                 ? authorized.error

package/dist/application/ProcessHarness.js

@@ -1,4 +1,3 @@
-import { spawn } from "node-pty";
 import { validateProcessCapture } from "../domain/processCapture.js";
 import { err, ok } from "../domain/result.js";
 import { ProcessCaptureError, processCaptureCancelled, } from "./ProcessCaptureError.js";
@@ -111,6 +110,7 @@ const startCaptureRuntime = async (options) => {
     let shimReplay;
     let terminal;
     try {
+        const { spawn } = await import("@lydell/node-pty");
         replay = await startLoopbackReplay(scenario);
         const startedAt = new Date();
         const started = Date.now();