@unbrained/pm-cli 2026.8.15 → 2026.8.17

package/dist/core/schema/runtime-schema.js

@@ -4,7 +4,7 @@
  * Resolves configurable schema, fields, statuses, and workflows for Runtime Schema.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a9ff482a-f9f9-5e35-88d0-240db815ec08")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="88b9179f-569e-5cd6-b67c-c27431961554")}catch(e){}}();
 import path from "node:path";
 import { pathExists, readFileIfExists, writeFileAtomic, } from "../fs/fs-utils.js";
 import { DEFAULT_STATUS_DEFINITIONS, DEFAULT_WORKFLOW_DEFINITION, } from "../shared/constants.js";
@@ -32,6 +32,119 @@ const RUNTIME_STATUS_ROLE_SET = new Set(RUNTIME_STATUS_ROLE_VALUES);
 const RUNTIME_FIELD_TYPE_SET = new Set(RUNTIME_FIELD_TYPE_VALUES);
 const RUNTIME_FIELD_COMMAND_SET = new Set(RUNTIME_FIELD_COMMAND_VALUES);
 const RUNTIME_UNKNOWN_FIELD_POLICY_SET = new Set(RUNTIME_UNKNOWN_FIELD_POLICY_VALUES);
+const RUNTIME_FIELD_VALUE_TYPE_SET = new Set([
+    "string",
+    "number",
+    "boolean",
+    "array",
+    "object",
+]);
+const MAX_RUNTIME_FIELD_VALUE_SCHEMA_DEPTH = 16;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const RUNTIME_FIELD_VALUE_SCHEMA_SHAPE_VALIDATORS = [
+    (schema) => schema.type === undefined ||
+        (typeof schema.type === "string" &&
+            RUNTIME_FIELD_VALUE_TYPE_SET.has(schema.type)),
+    (schema) => !Object.hasOwn(schema, "const") || isStructuredJsonValue(schema.const),
+    (schema) => schema.enum === undefined ||
+        (Array.isArray(schema.enum) &&
+            schema.enum.every((entry) => isStructuredJsonValue(entry))),
+    (schema) => schema.min_length === undefined ||
+        (Number.isInteger(schema.min_length) &&
+            schema.min_length >= 0),
+    (schema) => schema.min_items === undefined ||
+        (Number.isInteger(schema.min_items) && schema.min_items >= 0),
+    (schema) => schema.format === undefined || schema.format === "date-time",
+    (schema) => schema.required === undefined ||
+        (Array.isArray(schema.required) &&
+            schema.required.every((entry) => typeof entry === "string" && entry.length > 0)),
+    (schema) => schema.additional_properties === undefined ||
+        typeof schema.additional_properties === "boolean",
+    (schema) => schema.properties === undefined ||
+        isPlainObject(schema.properties),
+    (schema) => schema.one_of === undefined ||
+        (Array.isArray(schema.one_of) && schema.one_of.length > 0),
+];
+function isStructuredJsonValue(value, ancestors = new Set()) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return true;
+    }
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value !== "object" || ancestors.has(value))
+        return false;
+    ancestors.add(value);
+    const valid = Array.isArray(value)
+        ? value.every((entry) => isStructuredJsonValue(entry, ancestors))
+        : Object.values(value).every((entry) => isStructuredJsonValue(entry, ancestors));
+    ancestors.delete(value);
+    return valid;
+}
+/** Normalize an untrusted recursive custom-field value schema or reject it. */
+function normalizeRuntimeFieldValueSchema(value, depth = 0, ancestors = new Set()) {
+    if (!isPlainObject(value) ||
+        depth > MAX_RUNTIME_FIELD_VALUE_SCHEMA_DEPTH ||
+        ancestors.has(value)) {
+        return undefined;
+    }
+    ancestors.add(value);
+    const schema = value;
+    const type = schema.type;
+    const enumValues = schema.enum;
+    const oneOf = schema.one_of;
+    const properties = schema.properties;
+    const items = schema.items;
+    const required = schema.required;
+    const minLength = schema.min_length;
+    const minItems = schema.min_items;
+    const format = schema.format;
+    const additionalProperties = schema.additional_properties;
+    if (!RUNTIME_FIELD_VALUE_SCHEMA_SHAPE_VALIDATORS.every((check) => check(schema))) {
+        ancestors.delete(value);
+        return undefined;
+    }
+    const normalizedProperties = properties === undefined
+        ? undefined
+        : Object.fromEntries(Object.entries(properties).map(([key, entry]) => [
+            key,
+            normalizeRuntimeFieldValueSchema(entry, depth + 1, ancestors),
+        ]));
+    const normalizedItems = items === undefined
+        ? undefined
+        : normalizeRuntimeFieldValueSchema(items, depth + 1, ancestors);
+    const normalizedOneOf = oneOf === undefined
+        ? undefined
+        : oneOf.map((entry) => normalizeRuntimeFieldValueSchema(entry, depth + 1, ancestors));
+    const normalizedNestedSchemas = [
+        ...Object.values(normalizedProperties ?? {}),
+        ...(items === undefined ? [] : [normalizedItems]),
+        ...(normalizedOneOf ?? []),
+    ];
+    if (normalizedNestedSchemas.some((entry) => entry === undefined)) {
+        ancestors.delete(value);
+        return undefined;
+    }
+    ancestors.delete(value);
+    return Object.fromEntries(Object.entries({
+        type: type,
+        const: Object.hasOwn(schema, "const") ? schema.const : undefined,
+        enum: enumValues,
+        min_length: minLength,
+        min_items: minItems,
+        format: format,
+        properties: normalizedProperties,
+        required: required === undefined
+            ? undefined
+            : [...new Set(required)],
+        additional_properties: additionalProperties,
+        items: normalizedItems,
+        one_of: normalizedOneOf,
+    }).filter(([, entry]) => entry !== undefined));
+}
 function normalizeStringList(values) {
     const candidates = Array.isArray(values) ? values : [];
     return [
@@ -202,6 +315,12 @@ function normalizeRuntimeFieldDefinition(definition) {
     })();
     const description = definition.description?.trim();
     const requiredTypes = normalizeStringList(definition.required_types);
+    const valueSchema = definition.value_schema === undefined
+        ? undefined
+        : normalizeRuntimeFieldValueSchema(definition.value_schema);
+    if (definition.value_schema !== undefined && valueSchema === undefined) {
+        return null;
+    }
     return {
         key,
         metadata_key: metadataKey,
@@ -210,11 +329,12 @@ function normalizeRuntimeFieldDefinition(definition) {
         description: description && description.length > 0 ? description : undefined,
         type,
         commands,
-        repeatable: definition.repeatable === true || type === "string_array",
+        repeatable: [definition.repeatable === true, type === "string_array"].includes(true),
         required: definition.required === true,
         required_on_create: definition.required_on_create === true,
         required_types: requiredTypes,
         allow_unset: definition.allow_unset !== false,
+        value_schema: valueSchema,
     };
 }
 function normalizeRuntimeStatusDefinitions(statusesSource) {
@@ -277,6 +397,7 @@ function serializeRuntimeFieldDefinition(definition) {
             ? [...definition.required_types]
             : undefined,
         allow_unset: definition.allow_unset === false ? false : undefined,
+        value_schema: definition.value_schema,
     };
 }
 function normalizeUnknownFieldPolicy(policy) {
@@ -691,4 +812,4 @@ export function statusIsTerminal(status, registry) {
     return registry.terminal_statuses.has(normalized);
 }
 //# sourceMappingURL=runtime-schema.js.map
-//# debugId=a9ff482a-f9f9-5e35-88d0-240db815ec08
+//# debugId=88b9179f-569e-5cd6-b67c-c27431961554

package/dist/core/shared/errors.d.ts

@@ -63,6 +63,16 @@ export interface PmCliErrorContext {
     measurement_id?: string;
     /** Assurance measurement source kind involved in a refusal, when known. */
     source_kind?: string;
+    /** Source item whose endpoint metadata violated a relationship contract. */
+    source_id?: string;
+    /** Source item creation time used to evaluate a temporal relationship contract. */
+    source_created_at?: string;
+    /** Target item whose endpoint metadata violated a relationship contract. */
+    target_id?: string;
+    /** Target item creation time used to evaluate a temporal relationship contract. */
+    target_created_at?: string;
+    /** Temporal relationship rule evaluated for the source and target. */
+    temporal_order?: string;
     /** Validate or health check selected by an assurance source, when known. */
     check?: string;
     /** Serialization format involved in a parse failure. */
@@ -87,6 +97,8 @@ export interface PmCliErrorContext {
     nextSteps?: string[];
     /** Exact selectors that could not be matched by a lossless removal. */
     unmatched?: string[];
+    /** Exact verifier findings that caused an integrity-sensitive operation to refuse. */
+    verification_errors?: string[];
     /** Local dependency targets that could not be resolved before mutation. */
     unresolved_targets?: string[];
     /** Available history bounds for a failed point-in-time read or restore target. */

package/dist/core/shared/errors.js

@@ -1,6 +1,6 @@
 /** Implements the exported pm cli error runtime abstraction for core/shared/errors.ts. */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d1a7b5e2-0915-5f00-8b5a-38af814e1ea1")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c863f07f-428b-5b7f-a5f7-23e7f5fa749a")}catch(e){}}();
 export class PmCliError extends Error {
     /** Value that configures or reports exit code for this contract. */
     exitCode;
@@ -18,4 +18,4 @@ export class PmCliError extends Error {
     }
 }
 //# sourceMappingURL=errors.js.map
-//# debugId=d1a7b5e2-0915-5f00-8b5a-38af814e1ea1
+//# debugId=c863f07f-428b-5b7f-a5f7-23e7f5fa749a

package/dist/core/shared/time.d.ts

@@ -2,6 +2,8 @@
 export declare function nowIso(): string;
 /** Implements check whether timestamp literal for the public runtime surface of this module. */
 export declare function isTimestampLiteral(input: string): boolean;
+/** Return whether a string is a calendar-valid RFC 3339 date-time. */
+export declare function isRfc3339DateTime(input: string): boolean;
 /** Implements compare timestamp strings for the public runtime surface of this module. */
 export declare function compareTimestampStrings(left: string, right: string): number;
 /** Timestamp-bearing record accepted by shared inclusive bound filtering. */

package/dist/core/shared/time.js

@@ -4,7 +4,7 @@
  * Provides shared primitives and utilities for Time.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6be1497f-a0d5-518b-bf6a-e549b18fad8a")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7887e752-b1b8-5c5e-9dd8-93b41cb757af")}catch(e){}}();
 import { PmCliError } from "./errors.js";
 import { evictOldestMemoEntries } from "./memo.js";
 import { EXIT_CODE } from "./constants.js";
@@ -15,6 +15,7 @@ const COMPACT_DATE = /^(\d{4})(\d{2})(\d{2})$/;
 const COMPACT_DATETIME = /^(\d{4})(\d{2})(\d{2})(?:[T\s]?)(\d{2})(\d{2})(\d{2})?([.,]\d{1,3})?(Z|[+-]\d{2}:?\d{2})?$/i;
 const HYPHEN_TIME = /^(\d{4}-\d{2}-\d{2})[T\s](\d{2})-(\d{2})(?:-(\d{2}))?([.,]\d{1,3})?(Z|[+-]\d{2}:?\d{2})?$/i;
 const COMPACT_TIME = /^(\d{4}-\d{2}-\d{2})[T\s](\d{2})(\d{2})(\d{2})?([.,]\d{1,3})?(Z|[+-]\d{2}:?\d{2})?$/i;
+const RFC_3339_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|[+-](\d{2}):(\d{2}))$/i;
 /** Implements now iso for the public runtime surface of this module. */
 export function nowIso() {
     return nextReproducibleTimestamp() ?? new Date().toISOString();
@@ -23,6 +24,30 @@ export function nowIso() {
 export function isTimestampLiteral(input) {
     return Number.isFinite(Date.parse(input));
 }
+/** Return whether a string is a calendar-valid RFC 3339 date-time. */
+export function isRfc3339DateTime(input) {
+    const match = RFC_3339_DATE_TIME.exec(input);
+    if (!match || !Number.isFinite(Date.parse(input)))
+        return false;
+    const [, yearRaw, monthRaw, dayRaw, hourRaw, minuteRaw, secondRaw, offsetHourRaw, offsetMinuteRaw,] = match;
+    const [year, month, day, hour, minute, second] = [
+        yearRaw,
+        monthRaw,
+        dayRaw,
+        hourRaw,
+        minuteRaw,
+        secondRaw,
+    ].map(Number);
+    return (month >= 1 &&
+        month <= 12 &&
+        day >= 1 &&
+        day <= daysInUtcMonth(year, month - 1) &&
+        hour <= 23 &&
+        minute <= 59 &&
+        second <= 59 &&
+        (offsetHourRaw === undefined || Number(offsetHourRaw) <= 23) &&
+        (offsetMinuteRaw === undefined || Number(offsetMinuteRaw) <= 59));
+}
 /**
  * Memoized `Date.parse` for {@link compareTimestampStrings}. Sort comparators call it
  * O(n log n) times over a corpus whose timestamp strings repeat heavily, and
@@ -273,4 +298,4 @@ export const _testOnly = {
     isWhitespaceCharacter,
 };
 //# sourceMappingURL=time.js.map
-//# debugId=6be1497f-a0d5-518b-bf6a-e549b18fad8a
+//# debugId=7887e752-b1b8-5c5e-9dd8-93b41cb757af

package/dist/core/store/item-store.js

@@ -4,7 +4,7 @@
  * Reads and writes tracker storage with format-aware helpers for Item Store.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="f43e1170-e797-5a0c-b02e-d31e002ab275")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d24d61bf-7db8-5f35-8dbc-5ef93ec8220b")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { getActiveExtensionRegistrations, projectAfterCommandItemSnapshot, recordAfterCommandAffectedItem, runActiveOnReadHooks, runActiveBeforeMutationHooks, runActiveOnWriteHooks, runActiveServiceOverride, } from "../extensions/index.js";
@@ -69,6 +69,15 @@ function trackerRootNotDirectoryError(pmRoot) {
         ],
     });
 }
+function trackerRootUnreadableError(pmRoot) {
+    return new PmCliError(`Tracker root is not readable at ${pmRoot}.`, EXIT_CODE.GENERIC_FAILURE, {
+        code: "tracker_root_unreadable",
+        reason: "unreadable",
+        nextSteps: [
+            "Grant read and directory-search permission to the tracker root, then retry the SDK read.",
+        ],
+    });
+}
 async function assertMissingMetadataRootAncestors(pmRoot) {
     const filesystemRoot = path.parse(path.resolve(pmRoot)).root;
     let ancestor = path.dirname(path.resolve(pmRoot));
@@ -114,11 +123,28 @@ async function assertItemMetadataRoot(pmRoot) {
         if (isErrno(error, "ENOTDIR")) {
             throw trackerRootNotDirectoryError(pmRoot);
         }
+        if (isErrno(error, "EACCES") || isErrno(error, "EPERM")) {
+            throw trackerRootUnreadableError(pmRoot);
+        }
         throw error;
     }
     if (!stats.isDirectory()) {
         throw trackerRootNotDirectoryError(pmRoot);
     }
+    if (process.platform !== "win32" &&
+        ((stats.mode & 0o444) === 0 || (stats.mode & 0o111) === 0)) {
+        throw trackerRootUnreadableError(pmRoot);
+    }
+    try {
+        const directory = await fs.opendir(pmRoot);
+        await directory.close();
+    }
+    catch (error) {
+        if (isErrno(error, "EACCES") || isErrno(error, "EPERM")) {
+            throw trackerRootUnreadableError(pmRoot);
+        }
+        throw error;
+    }
 }
 /** Implements locate item for the public runtime surface of this module. */
 export async function locateItem(pmRoot, rawId, idPrefix = "pm-", preferredFormat, typeToFolder = TYPE_TO_FOLDER) {
@@ -684,4 +710,4 @@ export async function deleteItem(params) {
     }
 }
 //# sourceMappingURL=item-store.js.map
-//# debugId=f43e1170-e797-5a0c-b02e-d31e002ab275
+//# debugId=d24d61bf-7db8-5f35-8dbc-5ef93ec8220b

package/dist/sdk/agent/refusal-reachability.d.ts

@@ -1,9 +1,3 @@
-/**
- * @module sdk/agent/refusal-reachability
- *
- * Verifies real-entrypoint observations against refusal states declared by the
- * generated public error-code catalog.
- */
 import type { PmErrorCodeContract, PmErrorCodeClass } from "../error-code-catalog.js";
 /** One recorded result from driving a real public entrypoint into a refusal. */
 export interface PmRefusalProbeObservation {
@@ -37,9 +31,55 @@ export interface PmRefusalReachabilityReport {
     findings: PmRefusalReachabilityFinding[];
 }
 /** Recovery-reference kinds emitted by structured refusal envelopes. */
-export declare const PM_RECOVERY_REFERENCE_KINDS: readonly ["suggested_retry", "candidate_command", "example", "next_step"];
+export declare const PM_RECOVERY_REFERENCE_KINDS: readonly ["suggested_retry", "candidate_command", "example", "next_step", "migration_hint", "restore_with"];
 /** Recovery-reference kind emitted by a refusal. */
 export type PmRecoveryReferenceKind = (typeof PM_RECOVERY_REFERENCE_KINDS)[number];
+/** Behavioral promise attached to a recovery reference. */
+export type PmRecoveryReferenceSemantics = "recovery" | "replacement" | "behavior_preserving";
+/** Literal envelope fields recognized as recovery-reference producers. */
+export declare const PM_RECOVERY_REFERENCE_FIELDS: readonly ("restore_with" | "migration_hint" | "migration_hints" | "suggested_retry" | "next_best_command" | "fallback_candidates" | "examples" | "next_steps" | "suggested_next_steps" | "candidate_commands" | "candidate_command" | "example" | "next_step" | "retry_command")[];
+/** One source file supplied to the producer-census analyzer. */
+export interface PmRecoveryProducerSource {
+    /** Repository-relative source path. */
+    path: string;
+    /** Complete source text. */
+    content: string;
+}
+/** One literal recovery field emitted from a source location. */
+export interface PmRecoveryProducerLocation {
+    /** Repository-relative producer source path. */
+    path: string;
+    /** One-based source line. */
+    line: number;
+    /** Literal structured-envelope field. */
+    field: (typeof PM_RECOVERY_REFERENCE_FIELDS)[number];
+    /** Normalized recovery kind. */
+    kind: PmRecoveryReferenceKind;
+}
+/** Producer-census failure that requires a new field contract or producer. */
+export interface PmRecoveryProducerCensusFinding {
+    /** Stable finding kind. */
+    kind: "invalid_source" | "missing_kind_producer" | "unknown_recovery_field";
+    /** Source path or normalized kind. */
+    subject: string;
+    /** Actionable explanation. */
+    detail: string;
+}
+/** Complete literal producer-table census for recovery references. */
+export interface PmRecoveryProducerCensusReport {
+    /** Whether every recovery kind has a producer and no unknown fields exist. */
+    ok: boolean;
+    /** Source files inspected. */
+    scanned_file_count: number;
+    /** Literal producer locations. */
+    producer_count: number;
+    /** Stable counts by normalized recovery kind. */
+    producer_count_by_kind: Record<PmRecoveryReferenceKind, number>;
+    /** Stable producer locations. */
+    producers: PmRecoveryProducerLocation[];
+    /** Missing-kind or unknown-field findings. */
+    findings: PmRecoveryProducerCensusFinding[];
+}
 /** One derived promise that another invocation or command path is reachable. */
 export interface PmRecoveryReferenceObligation {
     /** Stable reference identifier derived from its emitting envelope. */
@@ -48,6 +88,8 @@ export interface PmRecoveryReferenceObligation {
     probe_id: string;
     /** Typed recovery vocabulary rather than prose inference. */
     kind: PmRecoveryReferenceKind;
+    /** Whether the reference recovers, replaces, or preserves the original behavior. */
+    semantics: PmRecoveryReferenceSemantics;
     /** Exact emitted command or recovery text. */
     value: string;
 }
@@ -59,6 +101,8 @@ export interface PmRecoveryReferenceObservation {
     reachable: boolean;
     /** How the promise was discharged. */
     proof: "executed" | "declared_command_path" | "linked_execution";
+    /** Semantics actually demonstrated by the proof. */
+    semantics: PmRecoveryReferenceSemantics;
 }
 /** Coverage totals for one emitted recovery-reference kind. */
 export interface PmRecoveryReferenceKindCoverage {
@@ -74,7 +118,7 @@ export interface PmRecoveryReferenceKindCoverage {
 /** One recovery-reference coverage failure. */
 export interface PmRecoveryReferenceFinding {
     /** Stable finding kind for assurance and CI. */
-    kind: "duplicate_obligation" | "duplicate_observation" | "missing_observation" | "unreachable_reference" | "undeclared_observation";
+    kind: "duplicate_obligation" | "duplicate_observation" | "missing_observation" | "unreachable_reference" | "wrong_semantics" | "undeclared_observation";
     /** Obligation or observation identifier. */
     reference_id: string;
     /** Human-readable mismatch summary. */
@@ -95,6 +139,10 @@ export interface PmRecoveryReferenceReport {
     /** Stable, sorted conformance findings. */
     findings: PmRecoveryReferenceFinding[];
 }
+/** Census syntax-parsed structured-envelope producers without executing source code. */
+export declare function censusPmRecoveryReferenceProducers(sources: readonly PmRecoveryProducerSource[]): PmRecoveryProducerCensusReport;
+/** Derive typed obligations from every recognized recovery field in an emitted envelope. */
+export declare function derivePmRecoveryReferenceObligations(probeId: string, envelope: unknown): PmRecoveryReferenceObligation[];
 /** Compare declared refusal states with real-entrypoint observations. */
 export declare function verifyPmRefusalReachability(catalog: readonly PmErrorCodeContract[], observations: readonly PmRefusalProbeObservation[]): PmRefusalReachabilityReport;
 /** Verify executable and declared-path proof for emitted recovery references. */