rea-agents 6.4.0 → 6.5.0

package/dist/application/flutter/FlutterBuildAnalysisService.js

@@ -0,0 +1,13 @@
+import { flutterRequestSchema, } from "../../domain/flutter/flutterBuildAnalysis.js";
+import { executeProviderOperation } from "../ProviderOperationExecution.js";
+/** Shared CLI/MCP admission, execution, and Evidence composition for Flutter. */
+export class FlutterBuildAnalysisService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Run one caller-selected Flutter request and retain target identity inline. */
+    execute(operation, input, options) {
+        return executeProviderOperation(operation, input, options, flutterRequestSchema, this.provider, "observed");
+    }
+}

package/dist/application/frida/FridaInstrumentationPort.js

@@ -0,0 +1,8 @@
+import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js";
+export class FridaScriptLoadCancelledError extends AnalysisCancelledError {
+    script;
+    constructor(script, options) {
+        super("load_frida_script", options);
+        this.script = script;
+    }
+}

package/dist/application/frida/FridaInstrumentationService.js

@@ -0,0 +1,310 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { setTimeout as delay } from "node:timers/promises";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
+import { AnalysisAccessDeniedError, AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
+import { err, ok } from "../../domain/result.js";
+import { FridaScriptLoadCancelledError } from "./FridaInstrumentationPort.js";
+const unreadableScriptFile = async (source) => {
+    if (source.sourceKind !== "file")
+        return undefined;
+    let reason;
+    let cause;
+    try {
+        if (!(await stat(source.path)).isFile())
+            reason = "it is not a regular file";
+        else {
+            await access(source.path, constants.R_OK);
+            return undefined;
+        }
+    }
+    catch (failure) {
+        cause = failure;
+        const code = failure instanceof Error && "code" in failure ? failure.code : undefined;
+        if (code === "EACCES" || code === "EPERM")
+            return new AnalysisAccessDeniedError("instrument_with_frida", source.path, code, { cause });
+        reason =
+            code === "ENOENT" ? "no file exists there" : String(code ?? failure);
+    }
+    return new AnalysisInputError("instrument_with_frida", cause === undefined ? undefined : { cause }, [
+        {
+            path: ["path"],
+            reason: "invalid_value",
+            message: `Cannot read Frida script file ${source.path}: ${reason}.`,
+        },
+    ]);
+};
+/**
+ * Reject an unreadable script file before any attach or spawn effect;
+ * cancellation before or during the check still wins.
+ */
+const rejectBeforeStart = async (source, signal) => {
+    const cancelled = () => new AnalysisCancelledError("instrument_with_frida", signal?.reason === undefined ? {} : { cause: signal.reason });
+    if (signal?.aborted)
+        return cancelled();
+    const unreadable = await unreadableScriptFile(source);
+    return signal?.aborted ? cancelled() : unreadable;
+};
+/** Shared CLI/MCP workflows for Frida's device and instrumentation operations. */
+export class FridaInstrumentationService {
+    #provider;
+    constructor(provider) {
+        this.#provider = provider;
+    }
+    listDevices(remote) {
+        return this.#provider.listDevices(remote);
+    }
+    listProcesses(selector) {
+        return this.#provider.listProcesses(selector);
+    }
+    async startSession(input, signal) {
+        return this.#startSession(input, signal, "start_frida_session");
+    }
+    async #startSession(input, signal, operation) {
+        if (signal?.aborted)
+            return err(new AnalysisCancelledError(operation, signal.reason === undefined ? {} : { cause: signal.reason }));
+        const started = await this.#provider.startSession(input);
+        if (!started.ok || !signal?.aborted)
+            return started;
+        return this.#cancelSession(operation, started.value, input, signal.reason);
+    }
+    async #cancelSession(operation, session, input, cause, loaded) {
+        const status = this.#provider.status(session.sessionId);
+        const observation = status ?? {
+            ...session,
+            targetResumeObserved: false,
+            scripts: [],
+            messages: loaded?.messages ?? [],
+            messagesTruncated: loaded?.messagesTruncated ?? false,
+        };
+        const closed = await this.#provider.closeSession(session.sessionId);
+        const statusAfterCleanup = this.#provider.status(session.sessionId);
+        const partialObservation = fridaEvidence(operation, {
+            ...sessionStatusOutput(observation),
+            ...(loaded === undefined
+                ? {}
+                : {
+                    source_kind: loaded.sourceKind,
+                    source_path: loaded.sourcePath,
+                    source_sha256: loaded.sourceSha256,
+                }),
+            cleanup_error: closed.ok ? null : closed.error.message,
+            target_state_before_cleanup: observation.state,
+            target_resume_observed: observation.targetResumeObserved ||
+                (observation.mode === "spawn" && observation.state === "running") ||
+                (closed.ok && closed.value.targetResumeObserved) ||
+                (observation.mode === "spawn" &&
+                    observation.state !== "running" &&
+                    statusAfterCleanup?.state === "running"),
+            instrumentation_cleanup: closed.ok
+                ? "released"
+                : "incomplete_or_unknown",
+            target_liveness_after_cleanup: "unknown",
+        }, fridaParameters(session.sessionId, input, session.deviceId));
+        return err(new AnalysisCancelledError(operation, {
+            ...(cause === undefined ? {} : { cause }),
+            partialObservation,
+            ...(closed.ok
+                ? {}
+                : {
+                    cleanup: {
+                        reason: closed.error.message,
+                        resources: [session.sessionId],
+                    },
+                }),
+        }));
+    }
+    async loadScript(sessionId, source, signal) {
+        if (signal?.aborted)
+            return err(new AnalysisCancelledError("load_frida_script", {
+                cause: signal.reason,
+            }));
+        const loaded = await this.#provider.loadScript(sessionId, source, signal);
+        if (!loaded.ok && loaded.error instanceof FridaScriptLoadCancelledError)
+            return err(cancelledScriptEvidence(sessionId, loaded.error));
+        return loaded.ok
+            ? ok(fridaEvidence("load_frida_script", scriptOutput(loaded.value), {
+                session_id: sessionId,
+            }))
+            : loaded;
+    }
+    resumeSession(sessionId, signal) {
+        return this.#provider.resumeSession(sessionId, signal);
+    }
+    unloadScript(sessionId, scriptId, signal) {
+        return this.#provider.unloadScript(sessionId, scriptId, signal);
+    }
+    status(sessionId) {
+        return this.#provider.status(sessionId);
+    }
+    statusEvidence(sessionId) {
+        const status = this.#provider.status(sessionId);
+        return status === undefined
+            ? undefined
+            : fridaEvidence("frida_session_status", sessionStatusOutput(status), {
+                session_id: sessionId,
+            });
+    }
+    async instrument(input, signal) {
+        const rejected = await rejectBeforeStart(input.source, signal);
+        if (rejected !== undefined)
+            return err(rejected);
+        const started = await this.#startSession(input, signal, "instrument_with_frida");
+        if (!started.ok)
+            return started;
+        if (signal?.aborted)
+            return this.#cancelSession("instrument_with_frida", started.value, input, signal.reason);
+        const loaded = await this.#provider.loadScript(started.value.sessionId, input.source, signal);
+        let scriptObservation;
+        if (loaded.ok)
+            scriptObservation = loaded.value;
+        else if (loaded.error instanceof FridaScriptLoadCancelledError)
+            scriptObservation = loaded.error.script;
+        if (signal?.aborted)
+            return this.#cancelSession("instrument_with_frida", started.value, input, signal.reason, scriptObservation);
+        if (!loaded.ok) {
+            const closed = await this.#provider.closeSession(started.value.sessionId);
+            return closed.ok
+                ? err(withRecoveredFridaCleanup(loaded.error))
+                : err(withCleanupFailure(loaded.error, closed.error.message, started.value.sessionId));
+        }
+        if (started.value.mode === "spawn") {
+            const resumed = await this.#provider.resumeSession(started.value.sessionId, signal);
+            if (signal?.aborted)
+                return this.#cancelSession("instrument_with_frida", started.value, input, signal.reason, loaded.value);
+            if (!resumed.ok) {
+                const closed = await this.#provider.closeSession(started.value.sessionId);
+                return closed.ok
+                    ? resumed
+                    : err(withCleanupFailure(resumed.error, closed.error.message, started.value.sessionId));
+            }
+        }
+        try {
+            await delay(input.durationMs, undefined, { signal });
+        }
+        catch (cause) {
+            return this.#cancelSession("instrument_with_frida", started.value, input, cause, loaded.value);
+        }
+        if (signal?.aborted)
+            return this.#cancelSession("instrument_with_frida", started.value, input, signal.reason, loaded.value);
+        const status = this.#provider.status(started.value.sessionId);
+        const observation = status ?? {
+            ...started.value,
+            targetResumeObserved: false,
+            scripts: [],
+            messages: loaded.value.messages,
+            messagesTruncated: loaded.value.messagesTruncated,
+        };
+        const closed = await this.#provider.closeSession(started.value.sessionId);
+        const cleanupError = closed.ok ? null : closed.error.message;
+        const evidence = fridaEvidence("instrument_with_frida", {
+            ...sessionStatusOutput(observation),
+            source_kind: loaded.value.sourceKind,
+            source_path: loaded.value.sourcePath,
+            source_sha256: loaded.value.sourceSha256,
+            cleanup_error: cleanupError,
+        }, fridaParameters(started.value.sessionId, input, started.value.deviceId));
+        return ok({
+            evidence,
+            cleanupError,
+        });
+    }
+    closeSession(sessionId) {
+        return this.#provider.closeSession(sessionId);
+    }
+    closeAll() {
+        return this.#provider.closeAll();
+    }
+}
+const fridaEvidence = (operation, result, parameters) => createEvidence(undefined, { id: "frida", name: "Frida", version: null }, {
+    predicateType: "rea.frida.instrumentation-observation",
+    operation,
+    parameters: jsonObjectSchema.parse(parameters),
+    result: jsonValueSchema.parse(result),
+    confidence: "observed",
+    authority: "external-service",
+    environment: null,
+    limitations: [
+        "The target operating system and architecture were not reported by this observation.",
+    ],
+});
+const fridaParameters = (sessionId, input, deviceId) => ({
+    session_id: sessionId,
+    device_id: deviceId,
+    ...(input.remote === undefined
+        ? {}
+        : {
+            remote: {
+                address: input.remote.address,
+                ...(input.remote.origin === undefined
+                    ? {}
+                    : { origin: input.remote.origin }),
+                ...(input.remote.keepaliveInterval === undefined
+                    ? {}
+                    : { keepalive_interval: input.remote.keepaliveInterval }),
+            },
+        }),
+    mode: input.mode,
+    ...(input.mode === "attach"
+        ? { pid: input.pid }
+        : {
+            program: input.program,
+            ...(input.argv === undefined ? {} : { argv: input.argv }),
+        }),
+});
+const withCleanupFailure = (original, cleanupReason, sessionId) => new AnalysisCapabilityUnavailableError("frida", "instrument_with_frida", `${original.message}; cleanup failed: ${cleanupReason}`, {
+    cause: original,
+    cleanup: {
+        reason: cleanupReason,
+        resources: [sessionId],
+    },
+});
+/** Preserve the original Frida failure after its owner confirms cleanup. */
+export const withRecoveredFridaCleanup = (error) => error instanceof AnalysisCapabilityUnavailableError && error.cleanupIncomplete
+    ? new AnalysisCapabilityUnavailableError(error.providerId, error.operation, error.reason, {
+        cause: error.cause,
+        ...(error.capturedOutput === undefined
+            ? {}
+            : { capturedOutput: error.capturedOutput }),
+        ...(error.partialObservation === undefined
+            ? {}
+            : { partialObservation: error.partialObservation }),
+        ...(error.userMessage === undefined
+            ? {}
+            : { userMessage: error.userMessage }),
+    })
+    : error;
+const scriptOutput = (script) => ({
+    script_id: script.scriptId,
+    source_kind: script.sourceKind,
+    source_path: script.sourcePath,
+    source_sha256: script.sourceSha256,
+    messages: script.messages,
+    messages_truncated: script.messagesTruncated,
+});
+const sessionStatusOutput = (status) => ({
+    session_id: status.sessionId,
+    device_id: status.deviceId,
+    state: status.state,
+    target: status.target,
+    pid: status.pid,
+    mode: status.mode,
+    scripts: status.scripts.map((script) => ({
+        script_id: script.scriptId,
+        name: script.name,
+    })),
+    messages: status.messages,
+    messages_truncated: status.messagesTruncated,
+});
+const cancelledScriptEvidence = (sessionId, error) => new AnalysisCancelledError(error.operation, {
+    cause: error.cause,
+    cleanup: error.cleanup,
+    partialObservation: fridaEvidence(error.operation, {
+        ...scriptOutput(error.script),
+        cleanup_error: error.cleanup?.reason ?? null,
+        script_cleanup: error.cleanupIncomplete
+            ? "incomplete_or_unknown"
+            : "released",
+    }, { session_id: sessionId }),
+});

package/dist/application/frida/fridaInputErrors.js

@@ -0,0 +1,17 @@
+import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
+/** A session ID that names no open Frida session owned by this process. */
+export const unknownFridaSession = (operation, sessionId) => new AnalysisInputError(operation, undefined, [
+    {
+        path: ["session_id"],
+        reason: "invalid_value",
+        message: `No open Frida session ${sessionId}; start one with start_frida_session.`,
+    },
+]);
+/** A script ID that names no loaded script in the selected session. */
+export const unknownFridaScript = (operation, scriptId) => new AnalysisInputError(operation, undefined, [
+    {
+        path: ["script_id"],
+        reason: "invalid_value",
+        message: `No loaded Frida script ${scriptId} in this session.`,
+    },
+]);

package/dist/application/go/GoBinaryPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/go/GoBinaryService.js

@@ -0,0 +1,80 @@
+import { isAbsolute } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { BINARY_ARCHITECTURES } from "../../domain/binaryTargetTypes.js";
+import { goBinarySchema, inspectGoBinaryInputSchema, } from "../../domain/go/goBinary.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+const OPERATION = "inspect_go_binary";
+const architectureForSubject = (architecture) => {
+    switch (architecture) {
+        case "386":
+            return "x86";
+        case "amd64":
+            return "x86_64";
+        default:
+            return BINARY_ARCHITECTURES.find((supported) => supported === architecture);
+    }
+};
+/** Shared exact input validation and artifact-bound Evidence for CLI and MCP. */
+export class GoBinaryService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    close() {
+        return this.provider.close?.() ?? Promise.resolve();
+    }
+    /** Inspect one explicitly selected file without acquiring a binary session. */
+    async inspect(rawInput, options) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const input = inspectGoBinaryInputSchema.safeParse(rawInput);
+        if (!input.success)
+            return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
+                cause: input.error,
+            }));
+        if (!isAbsolute(input.data.path))
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                {
+                    path: ["path"],
+                    reason: "invalid_format",
+                    message: "Expected an absolute filesystem path on this host.",
+                },
+            ]));
+        const inspected = await this.provider.inspect(input.data, options);
+        if (!inspected.ok)
+            return inspected;
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const report = goBinarySchema.safeParse(inspected.value);
+        if (!report.success || report.data.artifact.path !== input.data.path)
+            return err(new AnalysisOutputError(OPERATION, "Go build-information reader returned malformed metadata or changed the selected artifact identity."));
+        const value = report.data;
+        const architecture = architectureForSubject(value.architecture);
+        return ok(createEvidence({
+            path: value.artifact.path,
+            sha256: value.artifact.sha256,
+            format: value.format === "macho" ? "mach-o" : value.format,
+            ...(architecture === undefined ? {} : { architecture }),
+        }, this.provider.identity, {
+            operation: OPERATION,
+            parameters: input.data,
+            result: value,
+            confidence: "observed",
+            limitations: value.limitations,
+            locations: [
+                { kind: "artifact-path", path: value.artifact.path },
+                ...(value.build_info === null
+                    ? []
+                    : [
+                        {
+                            kind: "file-offset-range",
+                            start: value.build_info.header_offset,
+                            end: value.build_info.header_offset + 32,
+                        },
+                    ]),
+            ],
+        }));
+    }
+}

package/dist/application/harmony/HarmonyApplicationService.js

@@ -0,0 +1,17 @@
+import { harmonyApplicationProjectionInputSchema, projectHarmonyApplication, } from "../../domain/harmony/harmonyApplication.js";
+import { HARMONY_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
+import { projectInventoryEvidence } from "../InventoryProjectionEvidence.js";
+const OPERATION = "project_harmony_application_graph";
+/** Project authenticated HarmonyOS package inventory Evidence into application evidence. */
+export const projectHarmonyApplicationEvidence = (rawInput) => {
+    return projectInventoryEvidence({
+        rawInput,
+        schema: harmonyApplicationProjectionInputSchema,
+        project: projectHarmonyApplication,
+        operation: OPERATION,
+        predicateType: "rea.harmony-application-graph",
+        provider: HARMONY_APPLICATION_PROVIDER,
+        subjectFormat: (first) => first.subject?.format ?? "unknown",
+        protocolError: "HarmonyOS application projection produced an invalid result",
+    });
+};

package/dist/application/investigation/EvidenceLedger.js

@@ -1,10 +1,12 @@
 import canonicalize from "canonicalize";
 import { createEvidenceBundle, createImmutableEvidenceBundle, describeEvidenceBundleFailure, parseEvidenceBundle, validateResidualUnknownAddition, } from "../../domain/evidenceBundle.js";
+import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
 import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
 import { UnknownRegistryError } from "../../domain/unknownRegistryError.js";
-import { immutableEvidence, parseEvidence, } from "../../domain/evidence.js";
+import { immutableEvidence } from "../../domain/evidence.js";
 import { createResidualUnknown, updateResidualUnknown, } from "../../domain/residualUnknown.js";
 import { err, ok } from "../../domain/result.js";
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 /** Session-owned set of immutable evidence records. */
 export class EvidenceLedger {
     #records = new Map();
@@ -42,9 +44,15 @@ export class EvidenceLedger {
             bundle = parseEvidenceBundle(input);
         }
         catch (cause) {
+            const failure = describeEvidenceBundleFailure(input, cause);
+            if (failure.kind === "single-record")
+                return err(new AnalysisInputError("import_evidence_bundle", {
+                    cause,
+                    userMessage: failure.message,
+                }));
             return err(new EvidenceIntegrityError("Evidence bundle validation failed", {
                 cause,
-                userMessage: describeEvidenceBundleFailure(input, cause),
+                userMessage: failure.message,
             }));
         }
         // A record-only bundle cannot change the already-valid unknown graph. The
@@ -144,7 +152,7 @@ export class EvidenceLedger {
     recordUnknown(input, mutationEvidence) {
         let parsedMutation;
         try {
-            parsedMutation = parseEvidence(mutationEvidence);
+            parsedMutation = immutableEvidence(mutationEvidence);
         }
         catch (cause) {
             return err(new EvidenceIntegrityError("Unknown mutation evidence is invalid", {
@@ -167,8 +175,8 @@ export class EvidenceLedger {
         let evidence;
         let mutation;
         try {
-            evidence = parseEvidence(evidenceInput);
-            mutation = parseEvidence(mutationInput);
+            evidence = immutableEvidence(evidenceInput);
+            mutation = immutableEvidence(mutationInput);
         }
         catch (cause) {
             return err(new EvidenceIntegrityError("Atomic Evidence validation failed", {
@@ -219,13 +227,31 @@ export class EvidenceLedger {
     }
     /** Query current heads in stable ID order. */
     listUnknowns(filters = {}) {
-        return [...this.#unknownHeads.values()]
-            .filter((unknown) => (filters.status === undefined || unknown.status === filters.status) &&
-            (filters.severity === undefined ||
-                unknown.severity === filters.severity) &&
-            (filters.domain === undefined || unknown.domain === filters.domain))
-            .sort((left, right) => left.unknown_id.localeCompare(right.unknown_id))
-            .map((unknown) => structuredClone(unknown));
+        return this.listUnknownsPage(filters).items;
+    }
+    /** Select a stable page of current heads before detaching record payloads. */
+    listUnknownsPage(query = {}) {
+        const offset = query.offset ?? 0;
+        const matching = [...this.#unknownHeads.values()]
+            .filter((unknown) => (query.status === undefined || unknown.status === query.status) &&
+            (query.severity === undefined ||
+                unknown.severity === query.severity) &&
+            (query.domain === undefined || unknown.domain === query.domain))
+            .sort((left, right) => compareUnicodeCodePoints(left.unknown_id, right.unknown_id));
+        const start = Math.min(offset, matching.length);
+        const end = query.limit === undefined
+            ? undefined
+            : start + Math.min(query.limit, matching.length - start);
+        const page = matching.slice(start, end);
+        const nextOffset = offset <= matching.length && start + page.length < matching.length
+            ? start + page.length
+            : null;
+        return {
+            items: page.map((unknown) => structuredClone(unknown)),
+            total: matching.length,
+            offset,
+            next_offset: nextOffset,
+        };
     }
     /** Return current resolution validity; imported invalid states are rejected. */
     verifyUnknownResolution(unknownId) {
@@ -247,7 +273,7 @@ export class EvidenceLedger {
     #appendUnknown(unknown, mutationEvidenceInput) {
         let mutationEvidence;
         try {
-            mutationEvidence = parseEvidence(mutationEvidenceInput);
+            mutationEvidence = immutableEvidence(mutationEvidenceInput);
         }
         catch (cause) {
             return err(new EvidenceIntegrityError("Unknown mutation evidence is invalid", {
@@ -294,7 +320,7 @@ export class EvidenceLedger {
     }
     #validateCandidate(records, unknowns) {
         try {
-            parseEvidenceBundle(createEvidenceBundle([...records.values()], [...unknowns.values()]));
+            createImmutableEvidenceBundle([...records.values()], [...unknowns.values()]);
         }
         catch (cause) {
             return err(new UnknownRegistryError("integrity", { cause }));

package/dist/application/investigation/InvestigationRecords.js

@@ -1,6 +1,5 @@
-import { createEvidence } from "../../domain/evidence.js";
 import { EvidenceLedger } from "./EvidenceLedger.js";
-import { UNKNOWN_REGISTRY_PROVIDER, unknownEvidenceLinks, unknownMutationEvidence, } from "./UnknownEvidence.js";
+import { unknownMutationEvidence } from "./UnknownEvidence.js";
 /** One investigation's validated record owner, independent of binary execution. */
 export class InvestigationRecords {
     #evidence = new EvidenceLedger();
@@ -38,38 +37,30 @@ export class InvestigationRecords {
     }
     /** Record an Unknown with an explicitly supplied Evidence subject, if any. */
     recordUnknown(input, target) {
-        const recorded = this.#evidence.recordUnknown(input, unknownMutationEvidence(target, input));
-        return recorded;
+        return this.#evidence.recordUnknown(input, unknownMutationEvidence(target, { operation: "record_unknown", input }));
     }
     /** Commit derived Evidence and its Unknown atomically without an implicit subject. */
     recordEvidenceWithUnknown(evidence, input) {
-        const recorded = this.#evidence.recordWithUnknown(evidence, input, unknownMutationEvidence(undefined, input));
-        return recorded;
+        return this.#evidence.recordWithUnknown(evidence, input, unknownMutationEvidence(undefined, {
+            operation: "record_unknown",
+            input,
+        }));
     }
     /** Update an optimistic revision with an explicitly supplied Evidence subject. */
     updateUnknown(input, target) {
-        const evidence = createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
-            predicateType: "rea.residual-unknown-mutation",
+        const evidence = unknownMutationEvidence(target, {
             operation: "update_unknown",
-            parameters: {
-                unknown_id: input.unknown_id,
-                expected_revision: input.expected_revision,
-            },
-            result: { action: "update", status: input.status },
-            confidence: "derived",
-            authority: "analyst-inference",
-            evidenceLinks: unknownEvidenceLinks(input),
-            limitations: [
-                "Registry mutation evidence records analyst intent, not proof of the answer.",
-            ],
+            input,
         });
-        const updated = this.#evidence.updateUnknown(input, evidence);
-        return updated;
+        return this.#evidence.updateUnknown(input, evidence);
     }
     /** Return detached current Unknown revisions matching the selected filters. */
     listUnknowns(filters = {}) {
         return this.#evidence.listUnknowns(filters);
     }
+    listUnknownsPage(query = {}) {
+        return this.#evidence.listUnknownsPage(query);
+    }
     /** Verify registry consistency without asserting the answer is true. */
     verifyUnknownResolution(unknownId) {
         return this.#evidence.verifyUnknownResolution(unknownId);