rea-agents 0.2.1 → 0.4.0

package/dist/artifacts/ZipArtifactReader.js

@@ -0,0 +1,109 @@
+import { open } from "node:fs/promises";
+import { PassThrough } from "node:stream";
+import { once } from "node:events";
+import { Reader, ZipReader } from "@zip.js/zip.js";
+import { ArtifactReaderFailure, } from "./ArtifactReader.js";
+class NodeFileReader extends Reader {
+    path;
+    #handle;
+    constructor(path) {
+        super(path);
+        this.path = path;
+    }
+    async init() {
+        this.#handle = await open(this.path, "r");
+        this.size = (await this.#handle.stat()).size;
+    }
+    async readUint8Array(index, length) {
+        const handle = this.#handle;
+        if (handle === undefined)
+            throw new Error("ZIP reader is not initialized");
+        const bytes = Buffer.alloc(Math.min(length, this.size - index));
+        const read = await handle.read(bytes, 0, bytes.length, index);
+        return bytes.subarray(0, read.bytesRead);
+    }
+    async closeHandle() {
+        await this.#handle?.close();
+        this.#handle = undefined;
+    }
+}
+/** Lazy Zip64-capable reader with CRC and overlap verification on every read. */
+export class ZipArtifactReader {
+    format;
+    #source;
+    #reader;
+    #entries = new Map();
+    constructor(path, format) {
+        this.format = format;
+        this.#source = new NodeFileReader(path);
+        this.#reader = new ZipReader(this.#source, {
+            checkSignature: true,
+            checkOverlappingEntry: true,
+        });
+    }
+    async *entries(signal) {
+        for await (const entry of this.#reader.getEntriesGenerator()) {
+            abortIfNeeded(signal);
+            this.#entries.set(entry.filename, entry);
+            const symlink = isSymlink(entry);
+            yield {
+                path: entry.filename,
+                kind: entry.directory ? "directory" : symlink ? "symlink" : "file",
+                declaredSize: entry.directory ? null : entry.uncompressedSize,
+                compressedSize: entry.directory ? null : entry.compressedSize,
+                executable: entry.executable,
+                encrypted: entry.encrypted,
+                byteOffset: null,
+                declaredSha256: null,
+                limitations: symlink ? ["Archive symlink target was not read."] : [],
+                adapterKey: entry.filename,
+            };
+        }
+    }
+    open(entry, signal) {
+        abortIfNeeded(signal);
+        const stored = this.#entries.get(entry.adapterKey);
+        if (stored === undefined || stored.directory || isSymlink(stored))
+            return Promise.reject(new ArtifactReaderFailure("format", "ZIP entry is not a regular file"));
+        if (stored.encrypted)
+            return Promise.reject(new ArtifactReaderFailure("unavailable", "Encrypted ZIP entry is unsupported"));
+        return Promise.resolve(extractStream(stored, signal));
+    }
+    async close() {
+        await this.#reader.close().catch(() => undefined);
+        await this.#source.closeHandle();
+    }
+    provenance() {
+        return [];
+    }
+}
+const extractStream = (entry, signal) => {
+    const output = new PassThrough();
+    const writable = new WritableStream({
+        write: async (chunk) => {
+            abortIfNeeded(signal);
+            if (!output.write(Buffer.from(chunk)))
+                await once(output, "drain");
+        },
+        close: () => {
+            output.end();
+        },
+        abort: (reason) => {
+            output.destroy(toError(reason));
+        },
+    });
+    void entry
+        .getData(writable, {
+        checkSignature: true,
+        checkOverlappingEntry: true,
+        onprogress: () => abortIfNeeded(signal),
+    })
+        .catch((cause) => output.destroy(toError(cause)));
+    return output;
+};
+const isSymlink = (entry) => entry.unixMode !== undefined && (entry.unixMode & 0o170000) === 0o120000;
+const abortIfNeeded = (signal) => {
+    if (signal?.aborted === true)
+        throw new ArtifactReaderFailure("cancelled", "ZIP operation cancelled");
+};
+const toError = (cause) => cause instanceof Error ? cause : new Error("ZIP extraction failed");

package/dist/cli.js

@@ -1,10 +1,14 @@
 import { Cli, z } from "incur";
 import { fileURLToPath } from "node:url";
 import { runDoctor } from "./application/Doctor.js";
-import { runDirectAnalysis } from "./application/DirectAnalysis.js";
+import { runDirectAnalysis, runProviderAnalysis, } from "./application/DirectAnalysis.js";
 import { runSetup } from "./application/Setup.js";
+import { runUninstall } from "./application/Uninstall.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
 import { createLogger, parseLogLevel } from "./logger.js";
+import { parseConfig } from "./config.js";
+import { exportEvidenceBundleCommand, importEvidenceBundleCommand, } from "./application/EvidenceBundleCommands.js";
+import { importReferenceSource } from "./application/ReferenceSourceImport.js";
 /**
  * Build the one-shot Incur CLI without starting Hopper at import time.
  * Analysis commands acquire and close their own sessions; bare `mcp` and
@@ -15,18 +19,18 @@ export const createCli = () => {
         ? "silent"
         : parseLogLevel(process.env.REA_LOG_LEVEL));
     const cli = Cli.create(PRODUCT_IDENTITY.cliBinary, {
-        version: "0.1.0",
-        description: "Reverse engineer apps from your terminal or coding agent.",
+        version: process.env.REA_PACKAGE_VERSION ?? "0.0.0-development",
+        description: "Reverse engineer anything from your terminal or coding agent.",
         mcp: {
             command: PRODUCT_IDENTITY.mcpCommand,
-            instructions: "Ask which app and feature the user wants to understand, then open the app and investigate it.",
+            instructions: "Ask what software, artifact, protocol, or behavior the user wants to understand, then choose the available investigation capabilities that can produce evidence.",
         },
         sync: {
             cwd: fileURLToPath(new URL("..", import.meta.url)),
             include: ["skills/*"],
             suggestions: [
-                "understand how an app feature works",
-                "decompile part of an app",
+                "understand how a software feature works",
+                "investigate an artifact or observed behavior",
                 "check my REA setup",
             ],
         },
@@ -49,6 +53,17 @@ export const createCli = () => {
         }),
         run: ({ options }) => logCliCommand(logger, "doctor", () => runDoctor(options.target)),
     });
+    cli.command("uninstall", {
+        description: "Remove REA-owned agent configuration and skill files",
+        options: z.object({
+            purgeData: z
+                .boolean()
+                .default(false)
+                .describe("Also remove REA caches and state"),
+        }),
+        alias: { purgeData: "purge-data" },
+        run: ({ options }) => logCliCommand(logger, "uninstall", () => runUninstall(options.purgeData)),
+    });
     cli.command("analyze", {
         description: "Get an overview of an app",
         args: z.object({
@@ -64,8 +79,140 @@ export const createCli = () => {
         }),
         run: ({ args }) => logCliCommand(logger, "decompile", () => runDirectAnalysis(args.path, "procedure_pseudo_code", { procedure: args.address }, logger)),
     });
+    registerNativeCommands(cli, logger);
+    registerArtifactCommands(cli, logger);
+    registerEvidenceCommands(cli, logger);
+    registerReferenceSourceCommand(cli, logger);
     return cli;
 };
+const registerReferenceSourceCommand = (cli, logger) => {
+    cli.command("import-reference-source", {
+        description: "Import a bounded source tree as historical reference only",
+        args: z.object({
+            root: z
+                .string()
+                .describe("Source root allowed by REA_REFERENCE_ROOTS_JSON"),
+        }),
+        run: ({ args }) => logCliCommand(logger, "import-reference-source", async () => {
+            const config = parseConfig(process.env);
+            if (!config.ok)
+                return { error: config.error._tag, message: config.error.message };
+            const imported = await importReferenceSource({
+                root: args.root,
+                caller: "rea-cli",
+                policy: config.value.referenceSourcePolicy,
+                importer: PRODUCT_IDENTITY.packageName,
+                importerVersion: null,
+            });
+            return imported.ok
+                ? imported.value
+                : { error: imported.error.code, message: imported.error.message };
+        }),
+    });
+};
+const registerArtifactCommands = (cli, logger) => {
+    cli.command("inventory-artifact", {
+        description: "Build a bounded deterministic artifact graph",
+        args: z.object({
+            path: z.string().describe("Application or package path"),
+        }),
+        options: z.object({
+            offset: z.number().int().min(0).default(0),
+            limit: z.number().int().min(1).max(500).default(100),
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "inventory-artifact", () => runProviderAnalysis(args.path, "inventory_artifact", {
+            node_offset: options.offset,
+            node_limit: options.limit,
+            occurrence_offset: options.offset,
+            occurrence_limit: options.limit,
+            edge_offset: options.offset,
+            edge_limit: options.limit,
+        }, logger)),
+    });
+    cli.command("extract-artifact", {
+        description: "Extract explicitly selected artifact occurrences safely",
+        args: z.object({
+            path: z.string().describe("Application or package path"),
+            outputRoot: z.string().describe("Absent absolute output root"),
+            occurrenceIds: z
+                .array(z.string().regex(/^occ_[a-f0-9]{64}$/u))
+                .min(1)
+                .max(500),
+        }),
+        alias: { outputRoot: "output-root", occurrenceIds: "occurrence-ids" },
+        run: ({ args }) => logCliCommand(logger, "extract-artifact", () => runProviderAnalysis(args.path, "extract_artifact", {
+            approved: true,
+            output_root: args.outputRoot,
+            occurrence_ids: args.occurrenceIds,
+        }, logger)),
+    });
+};
+const registerNativeCommands = (cli, logger) => {
+    for (const [command, tool] of [
+        ["inspect-macho", "inspect_macho"],
+        ["inspect-signature", "inspect_signature"],
+        ["list-architectures", "list_architectures"],
+    ]) {
+        cli.command(command, {
+            description: `Run ${tool} without launching Hopper`,
+            args: z.object({ path: z.string().describe("Mach-O or app path") }),
+            run: ({ args }) => logCliCommand(logger, command, () => runProviderAnalysis(args.path, tool, {}, logger)),
+        });
+    }
+    cli.command("inspect-plist", {
+        description: "Parse app plist metadata without launching Hopper",
+        args: z.object({ path: z.string().describe("App or Mach-O path") }),
+        options: z.object({
+            relativePath: z.string().default("Contents/Info.plist"),
+        }),
+        alias: { relativePath: "relative-path" },
+        run: ({ args, options }) => logCliCommand(logger, "inspect-plist", () => runProviderAnalysis(args.path, "inspect_plist", { relative_path: options.relativePath }, logger)),
+    });
+    cli.command("demangle-swift", {
+        description: "Demangle a bounded Swift symbol batch without Hopper",
+        args: z.object({
+            path: z.string().describe("Artifact path used for evidence identity"),
+            symbols: z.array(z.string().min(1)).min(1).max(500),
+        }),
+        run: ({ args }) => logCliCommand(logger, "demangle-swift", () => runProviderAnalysis(args.path, "demangle_swift", { symbols: args.symbols }, logger)),
+    });
+};
+const registerEvidenceCommands = (cli, logger) => {
+    cli.command("evidence-import", {
+        description: "Validate and import a bounded local Evidence v2 bundle",
+        args: z.object({
+            path: z.string().describe("Evidence bundle JSON path"),
+        }),
+        run: ({ args }) => logCliCommand(logger, "evidence-import", async () => {
+            const config = parseConfig(process.env);
+            if (!config.ok)
+                return { error: config.error._tag, message: config.error.message };
+            const imported = await importEvidenceBundleCommand(args.path, config.value.evidenceFilePolicy);
+            return imported.ok
+                ? imported.value
+                : { error: imported.error._tag, message: imported.error.message };
+        }),
+    });
+    cli.command("evidence-export", {
+        description: "Validate and atomically export canonical Evidence v2 JSON",
+        args: z.object({
+            source: z.string().describe("Existing evidence bundle JSON path"),
+            output: z.string().describe("Canonical output JSON path"),
+        }),
+        options: z.object({
+            overwrite: z.boolean().default(false).describe("Replace output file"),
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "evidence-export", async () => {
+            const config = parseConfig(process.env);
+            if (!config.ok)
+                return { error: config.error._tag, message: config.error.message };
+            const exported = await exportEvidenceBundleCommand(args.source, args.output, options.overwrite, config.value.evidenceFilePolicy);
+            return exported.ok
+                ? exported.value
+                : { error: exported.error._tag, message: exported.error.message };
+        }),
+    });
+};
 const logCliCommand = async (logger, command, execute) => {
     const startedAt = performance.now();
     try {

package/dist/config.js

@@ -2,6 +2,9 @@ import { z } from "zod";
 import { ConfigurationError } from "./domain/errors.js";
 import { err, ok } from "./domain/result.js";
 const DEFAULT_HOPPER_LAUNCHER_PATH = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
+const defaultHopperLauncherPath = () => process.platform === "linux"
+    ? "/opt/hopper/bin/Hopper"
+    : DEFAULT_HOPPER_LAUNCHER_PATH;
 const environmentSchema = z.object({
     HOPPER_LAUNCHER_PATH: z.string().min(1).optional(),
     HOPPER_TARGET_PATH: z.string().min(1).optional(),
@@ -11,9 +14,15 @@ const environmentSchema = z.object({
         .enum(["trace", "debug", "info", "warn", "error", "fatal", "silent"])
         .default("info"),
     REA_PROCESS_CAPTURE_ENABLED: z.enum(["true", "false"]).default("false"),
+    REA_PROCESS_ALLOW_EXTERNAL_NETWORK: z
+        .enum(["true", "false"])
+        .default("false"),
     REA_PROCESS_EXECUTABLE_ROOTS_JSON: z.string().default("[]"),
     REA_PROCESS_WORKING_ROOTS_JSON: z.string().default("[]"),
     REA_PROCESS_ALLOWED_ENV_JSON: z.string().default("[]"),
+    REA_EVIDENCE_ROOTS_JSON: z.string().default("[]"),
+    REA_REFERENCE_ROOTS_JSON: z.string().default("[]"),
+    REA_REFERENCE_SECRET_PATTERNS_JSON: z.string().default("[]"),
 });
 const parseStringArray = (encoded, name) => {
     try {
@@ -69,9 +78,18 @@ export const parseConfig = (environment) => {
     const allowedEnvironment = parseStringArray(parsedEnvironment.data.REA_PROCESS_ALLOWED_ENV_JSON, "REA_PROCESS_ALLOWED_ENV_JSON");
     if (!allowedEnvironment.ok)
         return allowedEnvironment;
+    const evidenceRoots = parseStringArray(parsedEnvironment.data.REA_EVIDENCE_ROOTS_JSON, "REA_EVIDENCE_ROOTS_JSON");
+    if (!evidenceRoots.ok)
+        return evidenceRoots;
+    const referenceRoots = parseStringArray(parsedEnvironment.data.REA_REFERENCE_ROOTS_JSON, "REA_REFERENCE_ROOTS_JSON");
+    if (!referenceRoots.ok)
+        return referenceRoots;
+    const secretPatterns = parseStringArray(parsedEnvironment.data.REA_REFERENCE_SECRET_PATTERNS_JSON, "REA_REFERENCE_SECRET_PATTERNS_JSON");
+    if (!secretPatterns.ok)
+        return secretPatterns;
     return ok({
         hopperLauncherPath: parsedEnvironment.data.HOPPER_LAUNCHER_PATH ??
-            DEFAULT_HOPPER_LAUNCHER_PATH,
+            defaultHopperLauncherPath(),
         hopperTargetPath: parsedEnvironment.data.HOPPER_TARGET_PATH,
         hopperTargetKind: parsedEnvironment.data.HOPPER_TARGET_KIND,
         hopperLoaderArgs: parsedArgs.data,
@@ -81,6 +99,22 @@ export const parseConfig = (environment) => {
             executableRoots: executableRoots.value,
             workingRoots: workingRoots.value,
             allowedEnvironment: allowedEnvironment.value,
+            allowExternalNetwork: parsedEnvironment.data.REA_PROCESS_ALLOW_EXTERNAL_NETWORK === "true",
+        },
+        evidenceFilePolicy: {
+            roots: evidenceRoots.value,
+            maxBytes: 64 * 1024 * 1024,
+            maxDepth: 64,
+            maxStringLength: 1024 * 1024,
+            maxNodes: 1_000_000,
+        },
+        referenceSourcePolicy: {
+            roots: referenceRoots.value,
+            secretPatterns: secretPatterns.value,
+            maxBytes: 16 * 1024 * 1024,
+            maxEntries: 10_000,
+            maxDepth: 32,
+            maxPathBytes: 4_096,
         },
     });
 };

package/dist/contracts/artifactComparisonExample.js

@@ -0,0 +1,95 @@
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const inventory = (digit) => {
+    const sha = digit.repeat(64);
+    const artifactId = `art_${sha}`;
+    const occurrenceId = `occ_${sha}`;
+    return jsonValueSchema.parse({
+        manifest: {
+            schema_version: 1,
+            manifest_id: `agm_${sha}`,
+            root_artifact_id: artifactId,
+            root_sha256: sha,
+            root_format: "file",
+            graph_sha256: sha,
+            node_count: 1,
+            occurrence_count: 1,
+            edge_count: 0,
+        },
+        nodes: {
+            items: [
+                {
+                    artifact_id: artifactId,
+                    kind: "resource",
+                    format: "file",
+                    sha256: sha,
+                    size: 1,
+                    media_type: null,
+                    architecture: null,
+                    executable: false,
+                    content_state: "materialized",
+                    limitations: [],
+                },
+            ],
+            offset: 0,
+            limit: 100,
+            total: 1,
+            next_offset: null,
+        },
+        occurrences: {
+            items: [
+                {
+                    occurrence_id: occurrenceId,
+                    artifact_id: artifactId,
+                    parent_occurrence_id: null,
+                    logical_path: ".",
+                    entry_kind: "file",
+                    declared_size: 1,
+                    compressed_size: null,
+                    executable: false,
+                    encrypted: false,
+                    hash_status: "verified",
+                    source_location: null,
+                    limitations: [],
+                },
+            ],
+            offset: 0,
+            limit: 100,
+            total: 1,
+            next_offset: null,
+        },
+        edges: { items: [], offset: 0, limit: 100, total: 0, next_offset: null },
+        limits: {
+            max_entries: 100,
+            max_total_bytes: 1024,
+            max_entry_bytes: 1024,
+            max_compression_ratio: 10,
+            max_depth: 10,
+            max_path_bytes: 256,
+        },
+        provenance: [],
+        limitations: [],
+    });
+};
+const provider = {
+    id: "rea-artifact",
+    name: "REA artifact graph",
+    version: "1",
+};
+/** Canonical complete inputs used to advertise artifact comparison. */
+export const ARTIFACT_COMPARISON_EXAMPLE = {
+    left: createEvidence(undefined, provider, {
+        operation: "inventory_artifact",
+        parameters: {},
+        result: inventory("0"),
+        confidence: "observed",
+        authority: "shipped-artifact",
+    }),
+    right: createEvidence(undefined, provider, {
+        operation: "inventory_artifact",
+        parameters: {},
+        result: inventory("1"),
+        confidence: "observed",
+        authority: "shipped-artifact",
+    }),
+};

package/dist/contracts/artifactToolContracts.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { artifactOutputSchemas } from "./toolOutputSchemas.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const pageInput = {
+    node_offset: z.number().int().min(0).default(0),
+    node_limit: z.number().int().min(1).max(500).default(100),
+    occurrence_offset: z.number().int().min(0).default(0),
+    occurrence_limit: z.number().int().min(1).max(500).default(100),
+    edge_offset: z.number().int().min(0).default(0),
+    edge_limit: z.number().int().min(1).max(500).default(100),
+};
+const traversalLimitsInput = {
+    max_entries: z.number().int().min(1).max(1_000_000).default(10_000),
+    max_total_bytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(Number.MAX_SAFE_INTEGER)
+        .default(1_073_741_824),
+    max_entry_bytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(Number.MAX_SAFE_INTEGER)
+        .default(268_435_456),
+    max_compression_ratio: z.number().min(1).max(100_000).default(1_000),
+    max_depth: z.number().int().min(0).max(100).default(20),
+    max_path_bytes: z.number().int().min(1).max(65_535).default(4_096),
+};
+/** Exact caller boundary for deterministic artifact inventory. */
+export const artifactInventoryInputSchema = z.object({
+    ...pageInput,
+    ...traversalLimitsInput,
+});
+/** Exact caller boundary for approved artifact extraction. */
+export const artifactExtractionInputSchema = z.object({
+    approved: z.literal(true),
+    output_root: z.string().min(1).max(4_096),
+    occurrence_ids: z
+        .array(z.string().regex(/^occ_[a-f0-9]{64}$/u))
+        .min(1)
+        .max(500),
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(500).default(100),
+    ...traversalLimitsInput,
+});
+const exampleInputSchema = z.record(z.string(), jsonValueSchema);
+const examples = {
+    inventory_artifact: {},
+    extract_artifact: {
+        approved: true,
+        output_root: "/tmp/rea-extracted",
+        occurrence_ids: [`occ_${"0".repeat(64)}`],
+    },
+};
+const artifact = (name, description, inputSchema, mutatesFilesystem) => {
+    const outputSchema = artifactOutputSchemas[name];
+    if (outputSchema === undefined)
+        throw new Error(`Missing artifact output schema for ${name}`);
+    return {
+        name,
+        description,
+        kind: "artifact-provider",
+        inputSchema,
+        outputSchema,
+        annotations: {
+            readOnlyHint: !mutatesFilesystem,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        examples: [
+            {
+                title: `Example ${name.replaceAll("_", " ")} request`,
+                input: exampleInputSchema.parse(examples[name] ?? {}),
+            },
+        ],
+    };
+};
+/** Artifact-graph inventory and explicitly approved safe extraction contracts. */
+export const ARTIFACT_TOOL_CONTRACTS = [
+    artifact("inventory_artifact", "Inventory the active application or package as a deterministic, content-addressed artifact graph. Returns bounded node and edge pages without extracting or mounting by default.", artifactInventoryInputSchema, false),
+    artifact("extract_artifact", "Extract selected graph artifacts beneath an explicit output root. Requires approval, rejects traversal and symlink escapes, never overwrites, enforces bomb limits, and verifies cleanup.", artifactExtractionInputSchema, true),
+];

package/dist/contracts/enhancedInputs.js

@@ -56,6 +56,10 @@ export const enhancedInputSchemas = {
         case_sensitive: z.boolean().default(false),
         limit: z.number().int().min(1).max(100).default(20),
         max_operations: z.number().int().min(1).max(100).default(20),
+        unknown_registry_approved: z
+            .literal(true)
+            .optional()
+            .describe("Explicit approval to record bounded residuals durably"),
     }),
 };
 /** Runtime parser for dispatching only the eight closed enhanced names. */

package/dist/contracts/functionComparisonExample.js

@@ -0,0 +1,57 @@
+import { enhancedInputSchemas } from "./enhancedInputs.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const bounded = (items) => ({
+    items,
+    total: items.length,
+    returned: items.length,
+    truncated: false,
+    next_offset: null,
+});
+const dossier = (text) => jsonValueSchema.parse({
+    procedure: {
+        address: "0x1000",
+        name: "main",
+        signature: "int main(void)",
+        locals: [],
+    },
+    pseudocode: {
+        text,
+        total_chars: [...text].length,
+        returned_chars: [...text].length,
+        truncated: false,
+        next_offset: null,
+    },
+    assembly: bounded([]),
+    comments: bounded([]),
+    callers: bounded([]),
+    callees: bounded([]),
+    incoming_references: bounded([]),
+    outgoing_references: bounded([]),
+    referenced_strings: bounded([]),
+    referenced_names: bounded([]),
+    basic_blocks: bounded([{ start: "0x1000", end: "0x1001", successors: [] }]),
+    instruction_scan: { scanned: 1, truncated: false },
+});
+const observe = (digit, text) => createEvidence({
+    path: `/tmp/function-${digit}`,
+    sha256: digit.repeat(64),
+    format: "mach-o",
+}, {
+    id: "rea-workflow",
+    name: "REA composed investigation workflow",
+    version: "1",
+}, {
+    operation: "analyze_function",
+    parameters: enhancedInputSchemas.analyze_function.parse({
+        procedure: "main",
+    }),
+    result: dossier(text),
+    confidence: "derived",
+    authority: "shipped-artifact",
+});
+/** Canonical explicit function pair used in public contract examples. */
+export const FUNCTION_COMPARISON_EXAMPLE = {
+    left: observe("0", "return 0;"),
+    right: observe("1", "return 1;"),
+};