rea-agents 2.3.0 → 2.4.0

package/dist/contracts/toolOutputSchemaPrimitives.js

@@ -27,6 +27,8 @@ export const targetFormatSchema = z.enum([
     "zip",
     "ipa",
     "apk",
+    "msix",
+    "appx",
     "asar",
     "dmg",
     "pkg",
@@ -44,6 +46,7 @@ const providerCapability = z.object({
     operation: z.string(),
     available: z.boolean(),
     reason: z.string().nullable(),
+    availability_code: z.enum(PROVIDER_REJECTION_CODES).nullable(),
     input_contract_version: z.number().int().min(1),
     output_contract_version: z.number().int().min(1),
     pagination: z.enum(["none", "offset", "cursor"]),

package/dist/domain/analysisSnapshot.js

@@ -15,6 +15,8 @@ const formatSchema = z.enum([
     "zip",
     "ipa",
     "apk",
+    "msix",
+    "appx",
     "asar",
     "dmg",
     "pkg",

package/dist/domain/artifactGraph.js

@@ -45,6 +45,8 @@ const artifactFormatSchema = z.enum([
     "analysis-database",
     "ipa",
     "apk",
+    "msix",
+    "appx",
     "plist",
     "entitlements",
     "directory",

package/dist/domain/binaryTarget.js

@@ -6,6 +6,7 @@ import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { BinaryTargetError } from "./errors.js";
 import { err, ok } from "./result.js";
+import { zipPackageFormatForPath } from "./zipPackageFormat.js";
 const execFileAsync = promisify(execFile);
 /**
  * Resolve and classify a readable local target before a provider is selected.
@@ -71,11 +72,7 @@ const detectArtifactFormat = async (path, handle) => {
         magic[1] === 0x4b &&
         [0x03, 0x05, 0x07].includes(magic[2] ?? -1) &&
         [0x04, 0x06, 0x08].includes(magic[3] ?? -1)) {
-        return lower.endsWith(".ipa")
-            ? "ipa"
-            : lower.endsWith(".apk")
-                ? "apk"
-                : "zip";
+        return zipPackageFormatForPath(lower) ?? "zip";
     }
     const named = namedArtifactFormat(lower);
     if (named !== undefined)
@@ -104,7 +101,7 @@ const namedArtifactFormat = (lowerPath) => {
         return "source-map";
     return /\.(?:m?js|cjs)$/u.test(lowerPath) ? "javascript" : undefined;
 };
-const isArchiveFormat = (format) => ["zip", "ipa", "apk", "asar", "dmg", "pkg"].includes(format);
+const isArchiveFormat = (format) => ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(format);
 const sha256Handle = async (handle) => {
     const hash = createHash("sha256");
     const chunk = Buffer.allocUnsafe(64 * 1024);

package/dist/domain/evidence.js

@@ -22,6 +22,8 @@ const subjectSchema = z.object({
         "zip",
         "ipa",
         "apk",
+        "msix",
+        "appx",
         "asar",
         "dmg",
         "pkg",

package/dist/domain/processCapture.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { jsonValueSchema } from "./jsonValue.js";
 import { LEGACY_PROCESS_CAPTURE_MESSAGE, normalizationSchema, } from "./processScenario.js";
+import { PROCESS_REACTIVE_LIMITS } from "./processReactiveScenario.js";
 export * from "./processScenario.js";
 /** Capture collection whose members participate in global observation order. */
 export const PROCESS_CAPTURE_EVENT_COLLECTIONS = [
@@ -145,6 +146,69 @@ export const processCaptureSchema = z.object({
         sensitive_aliases: z.array(z.string().min(1).max(64)).max(32),
     }))
         .default([]),
+    reactive_run: z
+        .object({
+        status: z.enum(["running", "finished"]),
+        outcome: z
+            .enum([
+            "passed",
+            "predicate_timeout",
+            "scenario_deadline",
+            "ambiguous_match",
+            "action_rejected",
+            "target_lost",
+            "capture_incomplete",
+            "cancelled",
+            "cleanup_failed",
+        ])
+            .nullable(),
+        active_state: z.string().min(1).max(64),
+        controls: z
+            .array(z.object({
+            sequence: z.number().int().nonnegative(),
+            kind: z.enum([
+                "state_deadline",
+                "scenario_deadline",
+                "target_lost",
+                "cancelled",
+                "cleanup_failed",
+            ]),
+            after_capture_order: z.number().int().min(-1),
+        }))
+            .default([]),
+        transitions: z
+            .array(z.object({
+            sequence: z.number().int().nonnegative(),
+            transition_id: z.string().min(1).max(64),
+            state_before: z.string().min(1).max(64),
+            state_after: z.string().min(1).max(64).nullable(),
+            outcome: z
+                .enum([
+                "passed",
+                "predicate_timeout",
+                "scenario_deadline",
+                "ambiguous_match",
+                "action_rejected",
+                "target_lost",
+                "capture_incomplete",
+                "cancelled",
+                "cleanup_failed",
+            ])
+                .nullable(),
+            trigger_event_ids: z
+                .array(z.string().min(1))
+                .max(PROCESS_REACTIVE_LIMITS.predicates),
+            action_event_ids: z
+                .array(z.string().min(1))
+                .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),
+            action_types: z
+                .array(z.enum(["send_input", "resize", "send_signal", "checkpoint"]))
+                .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),
+        }))
+            .max(PROCESS_REACTIVE_LIMITS.transitions),
+    })
+        .nullable()
+        .default(null),
     event_journal: z
         .array(z.object({
         capture_order: z.number().int().nonnegative(),

package/dist/domain/processCaptureReactiveValidation.js

@@ -0,0 +1,175 @@
+import canonicalize from "canonicalize";
+import { projectProcessObservation, } from "./processObservation.js";
+import { commitProcessReactiveProposal, createProcessReactiveSnapshot, reduceProcessReactiveScenario, } from "./processReactiveRuntime.js";
+import { processReactiveScenarioSchema, } from "./processReactiveScenario.js";
+const admittedCollection = (collection) => [
+    "frames",
+    "interaction_events",
+    "process_samples",
+    "filesystem_checkpoints",
+    "shim_events",
+    "protocol_events",
+].includes(collection);
+const reactiveObservations = (capture) => (capture.event_journal ?? []).flatMap((location) => {
+    if (!admittedCollection(location.collection))
+        return [];
+    const observation = projectProcessObservation(capture, location);
+    return observation === null ? [] : [observation];
+});
+const validateTransitionDeclaration = (transition, next, context) => {
+    const { index, scenario, require } = context;
+    const path = `reactive_run.transitions[${String(index)}]`;
+    const declared = scenario.states
+        .find(({ id }) => id === transition.state_before)
+        ?.on.find(({ id }) => id === transition.transition_id);
+    require(declared !==
+        undefined, path, "reactive transition is not declared by its recorded source state");
+    if (declared !== undefined) {
+        const stateAfter = declared.target.kind === "goto" ? declared.target.state : null;
+        const outcome = declared.target.kind === "finish" ? declared.target.outcome : null;
+        require(transition.state_after === stateAfter &&
+            transition.outcome ===
+                outcome, path, "reactive transition target or outcome differs from the committed graph");
+        require(canonicalize(transition.action_types) ===
+            canonicalize(declared.actions.map(({ type }) => type)), `${path}.action_types`, "reactive transition actions differ from the committed graph");
+    }
+    require(transition.sequence ===
+        index, `${path}.sequence`, "reactive transition sequence must be contiguous from zero");
+    if (next !== undefined)
+        require(transition.state_after ===
+            next.state_before, `reactive_run.transitions[${String(index + 1)}].state_before`, "reactive transition states must be contiguous");
+};
+const validateTransitionDeclarations = (run, scenario, require) => {
+    require(run.transitions[0]?.state_before === scenario.initial_state ||
+        run.transitions.length ===
+            0, "reactive_run.transitions[0].state_before", "reactive transition journal must start at the declared initial state");
+    for (const [index, transition] of run.transitions.entries())
+        validateTransitionDeclaration(transition, run.transitions[index + 1], {
+            index,
+            scenario,
+            require,
+        });
+};
+const commitRecordedEffects = (options) => commitProcessReactiveProposal(options.scenario, options.proposal, options.recordedFailure === undefined
+    ? options.proposal.effects.map((_, index) => {
+        const eventId = options.expected?.action_event_ids[index];
+        const observation = eventId === undefined
+            ? undefined
+            : options.observations.get(eventId);
+        return observation === undefined
+            ? { status: "rejected" }
+            : { status: "succeeded", observation };
+    })
+    : [
+        options.recordedFailure === "target_lost"
+            ? { status: "target_lost" }
+            : { status: "rejected" },
+    ], { committedSensitiveInputs: true });
+const replayTransitions = (scenario, run, observations, require) => {
+    const observationsById = new Map(observations.map((observation) => [observation.event_id, observation]));
+    let snapshot = createProcessReactiveSnapshot(scenario);
+    let transitionIndex = 0;
+    const advance = (input) => {
+        let decision = reduceProcessReactiveScenario(scenario, snapshot, input);
+        if (decision.kind === "proposal") {
+            const proposal = decision;
+            decision = commitRecordedEffects({
+                scenario,
+                proposal: decision,
+                expected: run.transitions[transitionIndex],
+                observations: observationsById,
+                recordedFailure: run.transitions[transitionIndex] === undefined &&
+                    decision.effects.length > 0 &&
+                    (run.outcome === "action_rejected" || run.outcome === "target_lost")
+                    ? run.outcome
+                    : undefined,
+            });
+            require(decision.kind !== "finished" ||
+                decision.outcome !== "action_rejected" ||
+                run.outcome ===
+                    "action_rejected", `reactive_run.transitions[${String(transitionIndex)}].action_event_ids`, `recorded action observations do not match proposed effects: ${canonicalize({
+                effects: proposal.effects,
+                observations: run.transitions[transitionIndex]?.action_event_ids.map((eventId) => observationsById.get(eventId)),
+            })}`);
+        }
+        if (decision.kind === "transition") {
+            const expected = run.transitions[transitionIndex];
+            require(expected !== undefined &&
+                canonicalize(decision.record) ===
+                    canonicalize(expected), `reactive_run.transitions[${String(transitionIndex)}]`, "reactive transition differs from deterministic journal replay");
+            transitionIndex += 1;
+        }
+        snapshot = decision.snapshot;
+    };
+    const advanceControl = (control, index) => {
+        require(snapshot.status !== "finished" ||
+            control.kind ===
+                "cleanup_failed", `reactive_run.controls[${String(index)}]`, "reactive control cannot follow a finished run");
+        advance(control.kind === "state_deadline"
+            ? {
+                kind: control.kind,
+                state_id: snapshot.active_state,
+                state_entry_capture_order: snapshot.state_entry_capture_order,
+            }
+            : { kind: control.kind });
+    };
+    let controlIndex = 0;
+    for (const observation of observations) {
+        while ((run.controls[controlIndex]?.after_capture_order ??
+            Number.MAX_SAFE_INTEGER) < observation.capture_order) {
+            const control = run.controls[controlIndex];
+            advanceControl(control, controlIndex);
+            controlIndex += 1;
+        }
+        advance({ kind: "observation", observation });
+    }
+    for (; controlIndex < run.controls.length; controlIndex += 1) {
+        const control = run.controls[controlIndex];
+        advanceControl(control, controlIndex);
+    }
+    require(transitionIndex ===
+        run.transitions
+            .length, "reactive_run.transitions", `reactive transition journal is not reproduced by deterministic replay (replayed ${String(transitionIndex)} of ${String(run.transitions.length)}; outcome ${snapshot.outcome})`);
+    return snapshot;
+};
+const validateControls = (run, observations, require) => {
+    const admittedOrders = new Set([
+        -1,
+        ...observations.map(({ capture_order }) => capture_order),
+    ]);
+    for (const [index, control] of run.controls.entries()) {
+        require(control.sequence ===
+            index, `reactive_run.controls[${String(index)}].sequence`, "reactive control sequence must be contiguous");
+        require(admittedOrders.has(control.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoff must identify the last admitted observation");
+        require(index === 0 ||
+            control.after_capture_order >=
+                run.controls[index - 1]
+                    .after_capture_order, `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoffs must be ordered");
+    }
+};
+/** Validate one capture's reactive journal by replaying the production reducer. */
+export const validateProcessCaptureReactiveRun = (capture, require) => {
+    const declared = capture.manifest.scenario["reactive"];
+    const run = capture.reactive_run;
+    const declaredReactive = declared !== undefined && declared !== null;
+    require(declaredReactive ===
+        (run !==
+            null), "reactive_run", "reactive result presence must match the committed scenario");
+    if (run === null)
+        return;
+    const parsed = processReactiveScenarioSchema.safeParse(declared);
+    require(parsed.success, "manifest.scenario.reactive", "committed reactive scenario does not satisfy its declared schema");
+    if (!parsed.success)
+        return;
+    require(run.status === "finished" &&
+        run.outcome !==
+            null, "reactive_run.outcome", "completed capture requires a finished reactive outcome");
+    validateTransitionDeclarations(run, parsed.data, require);
+    const observations = reactiveObservations(capture);
+    validateControls(run, observations, require);
+    const snapshot = replayTransitions(parsed.data, run, observations, require);
+    require(snapshot.outcome ===
+        run.outcome, "reactive_run.outcome", "reactive outcome differs from deterministic journal replay");
+    require(snapshot.active_state ===
+        run.active_state, "reactive_run.active_state", "reactive active state differs from deterministic journal replay");
+};

package/dist/domain/processCaptureValidation.js

@@ -1,3 +1,4 @@
+import { validateProcessCaptureReactiveRun } from "./processCaptureReactiveValidation.js";
 import { replayMachineSchema } from "./replayMachine.js";
 import { digestProcessCommitment } from "./processScenario.js";
 const orderedTimestamps = (values) => values.every((value, index) => index === 0 || value.at_ms >= values[index - 1].at_ms);
@@ -209,5 +210,6 @@ export const validateProcessCapture = (capture) => {
     validateLifecycle(capture, require);
     validateShimEvents(capture, require);
     validateReplayEvents(capture, require);
+    validateProcessCaptureReactiveRun(capture, require);
     return issues;
 };

package/dist/domain/processObservation.js

@@ -60,13 +60,22 @@ const atMilliseconds = (value) => {
         }
     return null;
 };
-const subjectFor = (source, value) => {
+/** Derive the stable capture-local identity for one normalized observation. */
+export const processObservationSubject = (source, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return null;
-    if (source === "process" && typeof value["pid"] === "number")
-        return `process:${String(value["pid"])}`;
-    if (source === "filesystem" && typeof value["name"] === "string")
-        return `checkpoint:${value["name"]}`;
+    if (source === "process" && "pid" in value && typeof value.pid === "number")
+        return `process:${String(value.pid)}`;
+    if (source === "filesystem" &&
+        "name" in value &&
+        typeof value.name === "string")
+        return `checkpoint:${value.name}`;
+    if (source === "shim" &&
+        "command" in value &&
+        typeof value.command === "string")
+        return "route_index" in value && typeof value.route_index === "number"
+            ? `shim:${value.command}:route:${String(value.route_index)}`
+            : `shim:${value.command}:unmatched`;
     return null;
 };
 const projectedRecord = (capture, location) => {
@@ -133,7 +142,7 @@ const projectedRecord = (capture, location) => {
     return {
         source: projected.source,
         captured_at_ms: atMilliseconds(payload),
-        subject_id: subjectFor(projected.source, payload),
+        subject_id: processObservationSubject(projected.source, payload),
         payload,
     };
 };

package/dist/domain/processReactiveRuntime.js

@@ -2,6 +2,22 @@ import { matchProcessReactiveTrigger } from "./processReactiveMatching.js";
 import { PROCESS_REACTIVE_LIMITS, } from "./processReactiveScenario.js";
 export { commitProcessReactiveProposal } from "./processReactiveTransition.js";
 const counterValue = (counters, id) => counters.find((counter) => counter.id === id)?.count ?? 0;
+const observeInput = (snapshot, observation) => {
+    const duplicate = snapshot.observations.find(({ event_id }) => event_id === observation.event_id);
+    if (duplicate !== undefined)
+        return { kind: "invalid" };
+    const prior = snapshot.observations.at(-1);
+    if ((prior !== undefined && observation.capture_order <= prior.capture_order) ||
+        snapshot.observations.length >= PROCESS_REACTIVE_LIMITS.retainedObservations)
+        return { kind: "invalid" };
+    return {
+        kind: "new",
+        snapshot: {
+            ...snapshot,
+            observations: [...snapshot.observations, observation],
+        },
+    };
+};
 /** Create the initial immutable reducer state for one validated scenario. */
 export const createProcessReactiveSnapshot = (scenario) => ({
     status: "running",
@@ -35,6 +51,8 @@ const reduceControlInput = (snapshot, input) => {
             : { kind: "waiting", snapshot, evaluations: [] };
     if (input.kind === "scenario_deadline")
         return finishedDecision(snapshot, "scenario_deadline");
+    if (input.kind === "target_lost")
+        return finishedDecision(snapshot, "target_lost");
     return finishedDecision(snapshot, "cancelled");
 };
 /** Advance one validated scenario using only an observation or explicit deadline. */
@@ -44,17 +62,10 @@ export const reduceProcessReactiveScenario = (scenario, snapshot, input) => {
         return controlDecision;
     if (input.kind !== "observation")
         return finishedDecision(snapshot, "capture_incomplete");
-    const prior = snapshot.observations.at(-1);
-    if ((prior !== undefined &&
-        input.observation.capture_order <= prior.capture_order) ||
-        snapshot.observations.some(({ event_id }) => event_id === input.observation.event_id))
-        return finishedDecision(snapshot, "capture_incomplete");
-    if (snapshot.observations.length >= PROCESS_REACTIVE_LIMITS.retainedObservations)
+    const admitted = observeInput(snapshot, input.observation);
+    if (admitted.kind === "invalid")
         return finishedDecision(snapshot, "capture_incomplete");
-    const observed = {
-        ...snapshot,
-        observations: [...snapshot.observations, input.observation],
-    };
+    const observed = admitted.snapshot;
     const state = scenario.states.find(({ id }) => id === observed.active_state);
     if (state === undefined)
         return finishedDecision(observed, "target_lost");

package/dist/domain/processReactiveTransition.js

@@ -75,7 +75,7 @@ const applyProcessReactiveTransition = (input) => {
             record,
         };
 };
-const effectObservationMatchesAction = (action, observation) => {
+const effectObservationMatchesAction = (action, observation, committedSensitiveInputs) => {
     const payload = typeof observation.payload === "object" &&
         observation.payload !== null &&
         !Array.isArray(observation.payload)
@@ -98,14 +98,16 @@ const effectObservationMatchesAction = (action, observation) => {
     if (action.type === "send_input")
         return (payload["type"] === "input" &&
             payload["data"] ===
-                (action.sensitive
-                    ? `<redacted-input:${String(Buffer.byteLength(action.data))}-bytes>`
-                    : action.data));
+                expectedInputEvidence(action.data, action.sensitive, committedSensitiveInputs));
     if (action.type === "resize")
         return (payload["type"] === "resize" &&
             payload["data"] === `${String(action.columns)}x${String(action.rows)}`);
     return payload["type"] === "signal" && payload["data"] === action.signal;
 };
+const expectedInputEvidence = (data, sensitive, committedSensitiveInput) => !sensitive ||
+    (committedSensitiveInput && /^<redacted-input:\d+-bytes>$/.test(data))
+    ? data
+    : `<redacted-input:${String(Buffer.byteLength(data))}-bytes>`;
 const failedProposal = (proposed, outcome) => ({
     kind: "finished",
     outcome,
@@ -113,7 +115,7 @@ const failedProposal = (proposed, outcome) => ({
     snapshot: { ...proposed.snapshot, status: "finished", outcome },
 });
 /** Commit a proposal only after the host reports every effect as successful. */
-export const commitProcessReactiveProposal = (scenario, proposed, results) => {
+export const commitProcessReactiveProposal = (scenario, proposed, results, options = {}) => {
     if (results.some(({ status }) => status === "target_lost"))
         return failedProposal(proposed, "target_lost");
     const state = scenario.states.find(({ id }) => id === proposed.snapshot.active_state);
@@ -137,7 +139,7 @@ export const commitProcessReactiveProposal = (scenario, proposed, results) => {
         const action = transition.actions[index];
         const effectObservation = result.observation;
         if (action === undefined ||
-            !effectObservationMatchesAction(action, effectObservation) ||
+            !effectObservationMatchesAction(action, effectObservation, options.committedSensitiveInputs ?? false) ||
             !Number.isSafeInteger(effectObservation.capture_order) ||
             effectObservation.capture_order <= previousOrder ||
             knownEventIds.has(effectObservation.event_id))

package/dist/domain/processScenario.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { resolve } from "node:path";
 import canonicalize from "canonicalize";
 import { z } from "zod";
+import { processReactiveScenarioSchema, } from "./processReactiveScenario.js";
 import { replayMachineSchema } from "./replayMachine.js";
 const positiveBudget = z.number().int().positive();
 const timedEventBase = { at_ms: z.number().int().nonnegative() };
@@ -44,6 +45,23 @@ export const digestProcessCommitment = (value) => {
         throw new TypeError("Process capture commitment is not canonical JSON");
     return createHash("sha256").update(serialized).digest("hex");
 };
+const reactiveScenarioCommitment = (scenario) => scenario === null
+    ? null
+    : {
+        ...scenario,
+        states: scenario.states.map((state) => ({
+            ...state,
+            on: state.on.map((transition) => ({
+                ...transition,
+                actions: transition.actions.map((action) => action.type === "send_input" && action.sensitive
+                    ? {
+                        ...action,
+                        data: `<redacted-input:${String(Buffer.byteLength(action.data))}-bytes>`,
+                    }
+                    : action),
+            })),
+        })),
+    };
 /** Build the secret-safe scenario projection committed by Process Capture v4. */
 export const processScenarioCommitment = (scenario, executableSha256) => ({
     ...scenario,
@@ -51,6 +69,7 @@ export const processScenarioCommitment = (scenario, executableSha256) => ({
         name,
         scenario.secret_aliases.includes(name) ? "<redacted-secret>" : value,
     ])),
+    reactive: reactiveScenarioCommitment(scenario.reactive),
     unknown_registry_approved: scenario.unknown_registry_approved === true,
     executable_sha256: executableSha256 ?? null,
 });
@@ -71,6 +90,7 @@ export const processComparisonContract = (scenario) => ({
     normalization: scenario.normalization,
     command_shims: scenario.command_shims,
     replay: scenario.replay,
+    reactive: reactiveScenarioCommitment(scenario.reactive),
 });
 /**
  * Boundary schema for one explicitly approved, bounded process experiment.
@@ -258,6 +278,7 @@ export const processScenarioSchema = z
         websocket_messages: [],
         websocket_connections: [],
     }),
+    reactive: processReactiveScenarioSchema.nullable().default(null),
 })
     .strict()
     .superRefine((scenario, context) => {

package/dist/domain/zipPackageFormat.js

@@ -0,0 +1,20 @@
+/**
+ * Classify a ZIP-backed package by its complete lower-cased path suffix.
+ *
+ * This is deliberately extension-only. Callers must separately verify ZIP
+ * magic before trusting the classification for a root input.
+ */
+export const zipPackageFormatForPath = (path) => {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".zip"))
+        return "zip";
+    if (lower.endsWith(".ipa"))
+        return "ipa";
+    if (lower.endsWith(".apk") || lower.endsWith(".aab"))
+        return "apk";
+    if (lower.endsWith(".msix") || lower.endsWith(".msixbundle"))
+        return "msix";
+    if (lower.endsWith(".appx") || lower.endsWith(".appxbundle"))
+        return "appx";
+    return undefined;
+};

package/dist/generatedPackageMetadata.js

@@ -1,7 +1,7 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "rea-agents",
-    version: "2.3.0", // x-release-please-version
+    version: "2.4.0", // x-release-please-version
     serverSdkVersion: "2.0.0-beta.4",
     clientSdkVersion: "2.0.0-beta.4",
     coreSdkVersion: "2.0.0-beta.4",

package/dist/native/NativeMacOSProvider.js

@@ -35,6 +35,7 @@ export class NativeMacOSProvider {
                 ? { available: true, reason: null }
                 : {
                     available: false,
+                    availabilityCode: "unsupported_host",
                     reason: "Native macOS utilities require macOS.",
                 };
             return Object.freeze({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rea-agents",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Reverse engineer anything from your terminal or agent with one CLI and MCP server.",
   "license": "MIT",
   "repository": {

package/skills/reverse-engineer-anything/SKILL.md

@@ -4,7 +4,7 @@ description: Reverse engineer native, managed, Electron/JavaScript, packaged, an
 metadata:
   version: "23"
   tool_count: 98
-  catalog_digest: "71de8a7174176823fd82c2666130233b5a1b4a1613583270d268774775b410bc"
+  catalog_digest: "aa413204625f3aeb62732d0f732b9b8b24832eea4520214b1e6bd204e599bcd6"
 ---
 
 # REA
@@ -22,7 +22,8 @@ Choose the first tool from the target the user supplied. Do not call
 
 - ASAR or extracted JavaScript/Electron tree:
   `analyze_javascript_application`.
-- Archive, application package, ZIP/APK/IPA, or DMG: `inventory_artifact`.
+- Archive, application package, ZIP/APK/IPA/MSIX/AppX, or DMG:
+  `inventory_artifact`.
 - Managed PE/CLI assembly: `inspect_managed_artifact`.
 - User-owned browser page already open: `list_browser_targets`.
 - User-owned Electron runtime already open: `list_electron_targets`.

package/skills/reverse-engineer-anything/references/native-and-artifacts.md

@@ -24,8 +24,8 @@ parser and must not become an implicit setup dependency.
 ## Packages and extraction
 
 Call `inventory_artifact` before extraction for application bundles, archives,
-ZIP/APK/IPA, ASAR, or DMG inputs. Continue deterministic occurrence pages from
-the returned offset only when needed. Cite graph manifest IDs.
+ZIP/APK/IPA/MSIX/AppX, ASAR, or DMG inputs. Continue deterministic occurrence
+pages from the returned offset only when needed. Cite graph manifest IDs.
 
 `extract_artifact` requires explicit approval, an absent absolute output root,
 and selected occurrence IDs. Never extract every entry implicitly. Symlinks and