@unbrained/pm-cli 2026.8.16 → 2026.8.17

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/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 {
@@ -42,6 +36,50 @@ export declare const PM_RECOVERY_REFERENCE_KINDS: readonly ["suggested_retry", "
 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. */
@@ -101,6 +139,8 @@ 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. */

package/dist/sdk/agent/refusal-reachability.js

@@ -1,6 +1,13 @@
-/** Recovery-reference kinds emitted by structured refusal envelopes. */
+/**
+ * @module sdk/agent/refusal-reachability
+ *
+ * Verifies real-entrypoint observations against refusal states declared by the
+ * generated public error-code catalog.
+ */
 
-!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]="e96813c2-e30f-5000-9935-281c564c19aa")}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]="70af2366-a675-5631-8edb-4ebeef4bb786")}catch(e){}}();
+import { stripTypeScriptTypes } from "node:module";
+/** Recovery-reference kinds emitted by structured refusal envelopes. */
 export const PM_RECOVERY_REFERENCE_KINDS = [
     "suggested_retry",
     "candidate_command",
@@ -11,12 +18,20 @@ export const PM_RECOVERY_REFERENCE_KINDS = [
 ];
 const RECOVERY_REFERENCE_FIELD_CONTRACTS = {
     suggested_retry: { kind: "suggested_retry", semantics: "recovery" },
+    retry_command: { kind: "suggested_retry", semantics: "recovery" },
     candidate_command: { kind: "candidate_command", semantics: "recovery" },
     candidate_commands: { kind: "candidate_command", semantics: "recovery" },
+    fallback_candidates: {
+        kind: "candidate_command",
+        semantics: "recovery",
+        nested_value_field: "command",
+    },
+    next_best_command: { kind: "candidate_command", semantics: "recovery" },
     example: { kind: "example", semantics: "recovery" },
     examples: { kind: "example", semantics: "recovery" },
     next_step: { kind: "next_step", semantics: "recovery" },
     next_steps: { kind: "next_step", semantics: "recovery" },
+    suggested_next_steps: { kind: "next_step", semantics: "recovery" },
     migration_hint: { kind: "migration_hint", semantics: "replacement" },
     migration_hints: { kind: "migration_hint", semantics: "replacement" },
     restore_with: {
@@ -24,6 +39,322 @@ const RECOVERY_REFERENCE_FIELD_CONTRACTS = {
         semantics: "behavior_preserving",
     },
 };
+/** Literal envelope fields recognized as recovery-reference producers. */
+export const PM_RECOVERY_REFERENCE_FIELDS = Object.freeze(Object.keys(RECOVERY_REFERENCE_FIELD_CONTRACTS));
+/** Resolve an own recovery-field contract without trusting object prototypes. */
+function recoveryReferenceContract(field) {
+    if (!Object.hasOwn(RECOVERY_REFERENCE_FIELD_CONTRACTS, field))
+        return undefined;
+    return RECOVERY_REFERENCE_FIELD_CONTRACTS[field];
+}
+const SOURCE_REGEXP_PREFIX_PUNCTUATORS = new Set([
+    ..."=([{,:;!?&|+-*%^~<>",
+    "=>",
+]);
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function skipQuotedSourceToken(source, index) {
+    const quote = source[index];
+    let next = index + 1;
+    let value = "";
+    while (next < source.length && source[next] !== quote) {
+        if (source[next] === "\\")
+            next += 2;
+        else {
+            value += source[next];
+            next += 1;
+        }
+    }
+    if (source[next] === quote)
+        next += 1;
+    return { next, value };
+}
+function canStartRegularExpression(previous) {
+    return (previous === undefined ||
+        (previous.kind === "punctuator" &&
+            SOURCE_REGEXP_PREFIX_PUNCTUATORS.has(previous.value)) ||
+        (previous.kind === "identifier" &&
+            ["return", "case", "throw", "else", "yield"].includes(previous.value)));
+}
+function sourceTriviaEnd(source, index) {
+    if (/\s/u.test(source[index]))
+        return index + 1;
+    if (source.startsWith("//", index)) {
+        const newline = source.indexOf("\n", index + 2);
+        return newline === -1 ? source.length : newline + 1;
+    }
+    if (!source.startsWith("/*", index))
+        return undefined;
+    // stripTypeScriptTypes validates block-comment termination before tokenization.
+    return source.indexOf("*/", index + 2) + 2;
+}
+function regularExpressionEnd(source, index, previous) {
+    if (source[index] !== "/" || !canStartRegularExpression(previous))
+        return undefined;
+    let next = index + 1;
+    let inClass = false;
+    while (next < source.length) {
+        if (source[next] === "\\")
+            next += 2;
+        else if (source[next] === "[") {
+            inClass = true;
+            next += 1;
+        }
+        else if (source[next] === "]") {
+            inClass = false;
+            next += 1;
+        }
+        else if (source[next] === "/" && !inClass) {
+            next += 1;
+            while (/[A-Za-z]/u.test(source.charAt(next)))
+                next += 1;
+            return next;
+        }
+        else
+            next += 1;
+    }
+    return next;
+}
+function readSourceSyntaxToken(source, index) {
+    const character = source[index];
+    if (character === "'" || character === '"' || character === "`") {
+        const quoted = skipQuotedSourceToken(source, index);
+        return character === "`"
+            ? { next: quoted.next }
+            : {
+                next: quoted.next,
+                token: { kind: "string", value: quoted.value, offset: index + 1 },
+            };
+    }
+    if (/[A-Za-z_$]/u.test(character)) {
+        let next = index + 1;
+        while (/[A-Za-z0-9_$]/u.test(source[next] ?? ""))
+            next += 1;
+        return {
+            next,
+            token: {
+                kind: "identifier",
+                value: source.slice(index, next),
+                offset: index,
+            },
+        };
+    }
+    const punctuator = source.startsWith("=>", index) ? "=>" : character;
+    return {
+        next: index + punctuator.length,
+        token: { kind: "punctuator", value: punctuator, offset: index },
+    };
+}
+/** Tokenize executable JavaScript while ignoring comments, templates, and regex bodies. */
+function tokenizeExecutableSource(source) {
+    const tokens = [];
+    let index = 0;
+    while (index < source.length) {
+        const ignoredEnd = sourceTriviaEnd(source, index);
+        if (ignoredEnd !== undefined) {
+            index = ignoredEnd;
+            continue;
+        }
+        const regexEnd = regularExpressionEnd(source, index, tokens.at(-1));
+        if (regexEnd !== undefined) {
+            index = regexEnd;
+            continue;
+        }
+        const read = readSourceSyntaxToken(source, index);
+        if (read.token)
+            tokens.push(read.token);
+        index = read.next;
+    }
+    return tokens;
+}
+const SOURCE_BRACE_FRAME_KINDS = new Set([
+    "object",
+    "block",
+    "pattern",
+]);
+const SOURCE_PATTERN_DECLARATIONS = new Set(["const", "let", "var"]);
+const SOURCE_CLOSING_TOKENS = new Set(["}", ")", "]"]);
+const SOURCE_OBJECT_PRECEDERS = new Set([
+    "=",
+    "(",
+    "[",
+    ",",
+    ":",
+    "?",
+    "return",
+]);
+function objectFrameKind(tokens, index, stack) {
+    const enclosingBrace = [...stack]
+        .reverse()
+        .find((frame) => SOURCE_BRACE_FRAME_KINDS.has(frame.kind));
+    if (enclosingBrace?.kind === "pattern")
+        return "pattern";
+    if (stack.at(-1)?.kind === "paren" && stack.at(-1)?.parameter_list)
+        return "pattern";
+    const previous = tokens[index - 1];
+    if (previous?.kind === "identifier" &&
+        SOURCE_PATTERN_DECLARATIONS.has(previous.value)) {
+        return "pattern";
+    }
+    if (previous?.value === "=>" || previous?.value === ")")
+        return "block";
+    return previous && SOURCE_OBJECT_PRECEDERS.has(previous.value)
+        ? "object"
+        : "block";
+}
+function openingSourceFrame(tokens, index, stack) {
+    const token = tokens[index];
+    if (token.value === "{") {
+        const kind = objectFrameKind(tokens, index, stack);
+        return {
+            kind,
+            ...(kind === "object" ? { member_start: true, candidates: [] } : {}),
+        };
+    }
+    if (token.value === "[")
+        return { kind: "array" };
+    if (token.value !== "(")
+        return undefined;
+    const previous = tokens[index - 1];
+    const beforePrevious = tokens[index - 2];
+    const parameterList = previous?.value === "function" || beforePrevious?.value === "function";
+    return { kind: "paren", ...(parameterList ? { parameter_list: true } : {}) };
+}
+function staticObjectMember(frame, token, next) {
+    if (frame?.kind !== "object" ||
+        !frame.member_start ||
+        (token.kind !== "identifier" && token.kind !== "string") ||
+        next?.value !== ":" ||
+        !/^[A-Za-z][A-Za-z0-9_]*$/u.test(token.value)) {
+        return undefined;
+    }
+    return { field: token.value, offset: token.offset };
+}
+function isPatternLikeObjectClosure(tokens, index) {
+    return ((tokens[index + 1]?.value === ")" && tokens[index + 2]?.value === "=>") ||
+        tokens[index + 1]?.value === "=");
+}
+/** Parse static object-literal members without treating patterns or labels as producers. */
+function scanSourcePropertyTokens(source) {
+    const tokens = tokenizeExecutableSource(stripTypeScriptTypes(source, { mode: "strip" }));
+    const properties = [];
+    const stack = [];
+    for (const [index, token] of tokens.entries()) {
+        const frame = stack.at(-1);
+        const property = staticObjectMember(frame, token, tokens[index + 1]);
+        if (property)
+            frame.candidates.push(property);
+        const opening = openingSourceFrame(tokens, index, stack);
+        if (opening) {
+            stack.push(opening);
+        }
+        else if (SOURCE_CLOSING_TOKENS.has(token.value)) {
+            const closed = stack.pop();
+            if (closed?.kind === "object" &&
+                !isPatternLikeObjectClosure(tokens, index)) {
+                properties.push(...closed.candidates);
+            }
+        }
+        else if (token.value === "," && frame?.kind === "object") {
+            frame.member_start = true;
+        }
+        else if (frame?.kind === "object" && token.value !== ":") {
+            frame.member_start = false;
+        }
+    }
+    return properties;
+}
+function sourceLineStarts(source) {
+    const starts = [0];
+    for (let index = 0; index < source.length; index += 1) {
+        if (source[index] === "\n")
+            starts.push(index + 1);
+    }
+    return starts;
+}
+function sourceLineAtOffset(starts, offset) {
+    let low = 0;
+    let high = starts.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (starts[middle] <= offset)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+/** Census syntax-parsed structured-envelope producers without executing source code. */
+export function censusPmRecoveryReferenceProducers(sources) {
+    const producers = [];
+    const findings = [];
+    for (const source of [...sources].sort((left, right) => compareCodeUnits(left.path, right.path))) {
+        const lineStarts = sourceLineStarts(source.content);
+        let properties;
+        try {
+            properties = scanSourcePropertyTokens(source.content);
+        }
+        catch (error) {
+            findings.push({
+                kind: "invalid_source",
+                subject: source.path,
+                detail: `${source.path} could not be parsed for recovery producers: ${String(error)}.`,
+            });
+            continue;
+        }
+        for (const property of properties) {
+            const field = property.field;
+            const line = sourceLineAtOffset(lineStarts, property.offset);
+            const contract = recoveryReferenceContract(field);
+            if (contract) {
+                producers.push({
+                    path: source.path,
+                    line,
+                    field: field,
+                    kind: contract.kind,
+                });
+            }
+            else if (/(?:retry_command|candidate_command|fallback_candidate|next_best_command|example|next_step|migration_hint|restore_with)/u.test(field) &&
+                !/(?:_total|_truncated)$/u.test(field)) {
+                findings.push({
+                    kind: "unknown_recovery_field",
+                    subject: `${source.path}:${line}:${field}`,
+                    detail: `${field} resembles a recovery reference but has no typed field contract.`,
+                });
+            }
+        }
+    }
+    const producerCountByKind = Object.fromEntries(PM_RECOVERY_REFERENCE_KINDS.map((kind) => [
+        kind,
+        producers.filter((producer) => producer.kind === kind).length,
+    ]));
+    for (const kind of PM_RECOVERY_REFERENCE_KINDS) {
+        if (producerCountByKind[kind] === 0) {
+            findings.push({
+                kind: "missing_kind_producer",
+                subject: kind,
+                detail: `No source producer emits the ${kind} recovery-reference kind.`,
+            });
+        }
+    }
+    producers.sort((left, right) => left.path !== right.path
+        ? compareCodeUnits(left.path, right.path)
+        : left.line !== right.line
+            ? left.line - right.line
+            : compareCodeUnits(left.field, right.field));
+    findings.sort((left, right) => left.subject !== right.subject
+        ? compareCodeUnits(left.subject, right.subject)
+        : compareCodeUnits(left.kind, right.kind));
+    return {
+        ok: findings.length === 0,
+        scanned_file_count: sources.length,
+        producer_count: producers.length,
+        producer_count_by_kind: producerCountByKind,
+        producers,
+        findings,
+    };
+}
 /** Derive typed obligations from every recognized recovery field in an emitted envelope. */
 export function derivePmRecoveryReferenceObligations(probeId, envelope) {
     const obligations = [];
@@ -34,16 +365,27 @@ export function derivePmRecoveryReferenceObligations(probeId, envelope) {
         }
         if (typeof value !== "object" || value === null)
             return;
-        for (const [key, entry] of Object.entries(value).sort(([left], [right]) => left.localeCompare(right))) {
-            const baseContract = RECOVERY_REFERENCE_FIELD_CONTRACTS[key];
+        for (const [key, entry] of Object.entries(value).sort(([left], [right]) => compareCodeUnits(left, right))) {
+            const baseContract = recoveryReferenceContract(key);
             const contract = baseContract?.kind === "migration_hint" &&
                 value.semantics === "behavior_preserving"
                 ? { ...baseContract, semantics: "behavior_preserving" }
                 : baseContract;
-            const entries = Array.isArray(entry) ? entry : [entry];
+            const entries = [entry].flat();
             if (contract !== undefined) {
                 entries.forEach((candidate, index) => {
-                    if (typeof candidate !== "string" || candidate.trim().length === 0)
+                    const nestedValueField = "nested_value_field" in contract &&
+                        typeof contract.nested_value_field === "string"
+                        ? contract.nested_value_field
+                        : undefined;
+                    const resolvedCandidate = nestedValueField &&
+                        typeof candidate === "object" &&
+                        candidate !== null &&
+                        !Array.isArray(candidate)
+                        ? candidate[nestedValueField]
+                        : candidate;
+                    if (typeof resolvedCandidate !== "string" ||
+                        resolvedCandidate.trim().length === 0)
                         return;
                     const coordinate = [...path, key, String(index)]
                         .map((segment) => encodeURIComponent(segment))
@@ -53,7 +395,7 @@ export function derivePmRecoveryReferenceObligations(probeId, envelope) {
                         probe_id: probeId,
                         kind: contract.kind,
                         semantics: contract.semantics,
-                        value: candidate,
+                        value: resolvedCandidate,
                     });
                 });
             }
@@ -225,4 +567,4 @@ export function verifyPmRecoveryReferences(obligations, observations) {
     };
 }
 //# sourceMappingURL=refusal-reachability.js.map
-//# debugId=e96813c2-e30f-5000-9935-281c564c19aa
+//# debugId=70af2366-a675-5631-8edb-4ebeef4bb786

package/dist/sdk/cli-contracts/tool-parameter-tables.js

@@ -4,7 +4,7 @@
  * Defines SDK command-contract metadata for Tool Parameter Tables.
  */
 
-!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]="cb6f6915-307c-58e7-a892-3dff4c7ae399")}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]="4749819e-f2af-5a17-9d32-2e2770c497c3")}catch(e){}}();
 import { PLAN_HARNESS_VALUES, PLAN_MODE_VALUES, PLAN_STEP_LINK_KIND_VALUES, PLAN_STEP_STATUS_VALUES, } from "../../types/index.js";
 import { PM_READ_OUTPUT_SESSION_MAX_SEEN_ITEM_IDS } from "../read-output-session.js";
 import { ASSURANCE_DEFINITION_SCHEMA } from "./schemas/assurance-definition.js";
@@ -664,6 +664,7 @@ export const PM_TOOL_ACTION_SCOPED_PARAMETER_PROPERTIES = {
                 "apply",
                 "derive",
                 "promote",
+                "risk",
             ],
         },
         preset: {
@@ -1893,8 +1894,8 @@ export const PM_TOOL_PARAMETER_METADATA = {
 export const PM_TOOL_ACTION_SCOPED_PARAMETER_METADATA = {
     assurance: {
         subcommand: {
-            description: "Assurance operation: list, show, put, remove, run, verdicts, presets, apply, derive, or promote.",
-            examples: ["list", "run", "derive", "promote"],
+            description: "Assurance operation: list, show, put, remove, run, verdicts, presets, apply, derive, promote, or risk.",
+            examples: ["list", "run", "derive", "promote", "risk"],
         },
         kind: {
             description: "Assurance declaration kind for registry operations: measurement, assertion, or gate.",
@@ -2066,4 +2067,4 @@ export const PM_TOOL_ACTION_SCOPED_PARAMETER_METADATA = {
     },
 };
 //# sourceMappingURL=tool-parameter-tables.js.map
-//# debugId=cb6f6915-307c-58e7-a892-3dff4c7ae399
+//# debugId=4749819e-f2af-5a17-9d32-2e2770c497c3

package/dist/sdk/compose.d.ts

@@ -460,7 +460,7 @@ export interface ExtensionManifestCompatibilityManifest {
  * load, while `*_unchecked`/`*_exceeded_warn` are advisory (the extension still
  * loads).
  */
-export type ExtensionManifestCompatibilityCode = "pm_min_version_invalid" | "pm_min_version_unchecked" | "pm_min_version_unmet" | "pm_max_version_invalid" | "pm_max_version_unchecked" | "pm_max_version_exceeded" | "pm_max_version_exceeded_warn";
+export type ExtensionManifestCompatibilityCode = "pm_min_version_invalid" | "pm_min_version_unchecked" | "pm_min_version_unmet" | "pm_max_version_invalid" | "pm_max_version_unchecked" | "pm_max_version_exceeded" | "pm_max_version_exceeded_warn" | "manifest_unknown_key" | "no_version_bounds_declared";
 /**
  * A single version-bound issue {@link checkExtensionManifestCompatibility} found
  * when evaluating a manifest against a target pm version.
@@ -471,13 +471,17 @@ export interface ExtensionManifestCompatibilityFinding {
     /** `error` when the bound blocks the load against the target version, `warning` when it is advisory. */
     severity: "error" | "warning";
     /** Which manifest bound produced the finding. */
-    constraint: PmVersionBoundKind;
+    constraint: PmVersionBoundKind | "manifest";
     /** The declared bound value, verbatim. */
     required: string;
     /** The target pm version the bound was evaluated against. */
     current: string;
     /** Human-readable explanation of the outcome and its effect on loading. */
     message: string;
+    /** JSON-style manifest location responsible for a schema-level finding. */
+    path?: string;
+    /** Canonical manifest key that replaces a recognized legacy or mistaken spelling. */
+    suggested_key?: "pm_min_version" | "pm_max_version";
 }
 /**
  * The structured result of {@link checkExtensionManifestCompatibility}.

package/dist/sdk/compose.js

@@ -1,10 +1,11 @@
 
-!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]="fb438c6a-1927-54c3-98dd-dd7423df6722")}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]="705476d3-74b8-540d-b646-956e24f703d4")}catch(e){}}();
 import { normalizeKnownExtensionCapability, resolveLegacyExtensionCapabilityAlias, } from "../core/extensions/extension-capability-aliases.js";
 import { normalizeCommandName } from "../core/extensions/extension-runtime-helpers.js";
 import { RESERVED_ITEM_FIELD_NAMES } from "../core/extensions/item-fields.js";
 import { describeExtensionLongFlagFailure, findExtensionFlagTokenFailure, } from "../core/extensions/flag-definition-validation.js";
 import { evaluatePmMaxVersionBound, evaluatePmMinVersionBound, } from "../core/extensions/version-compat.js";
+import { inspectExtensionManifestSchema } from "../core/extensions/manifest-schema.js";
 /**
  * Typed identity helper for extension module exports.
  *
@@ -903,7 +904,7 @@ function toCompatibilityFinding(evaluation, pmVersion) {
         return null;
     }
     const code = `${evaluation.kind}_${evaluation.status}`;
-    let message;
+    let message = "";
     switch (code) {
         case "pm_min_version_invalid":
             message = `pm_min_version "${evaluation.required}" is not a valid version; the extension is treated as incompatible and the loader skips it.`;
@@ -962,6 +963,35 @@ export function checkExtensionManifestCompatibility(manifest, target) {
     const minEvaluation = evaluatePmMinVersionBound(manifest.pm_min_version, target.pmVersion);
     const maxEvaluation = evaluatePmMaxVersionBound(manifest.pm_max_version, target.pmVersion, target.pmMaxVersionExceededMode ?? "block");
     const findings = [];
+    const schema = inspectExtensionManifestSchema(manifest);
+    for (const key of schema.unknownKeys) {
+        findings.push({
+            code: "manifest_unknown_key",
+            severity: "warning",
+            constraint: "manifest",
+            required: key,
+            current: target.pmVersion,
+            path: key,
+            ...(key === "compatibility"
+                ? { suggested_key: "pm_min_version" }
+                : {}),
+            message: key === "compatibility"
+                ? 'Manifest key "compatibility" is ignored; declare the canonical pm_min_version and optional pm_max_version fields instead.'
+                : `Manifest key "${key}" is not part of the extension manifest contract and will be ignored.`,
+        });
+    }
+    if (schema.missingVersionBounds) {
+        findings.push({
+            code: "no_version_bounds_declared",
+            severity: "warning",
+            constraint: "manifest",
+            required: "pm_min_version",
+            current: target.pmVersion,
+            path: "$",
+            suggested_key: "pm_min_version",
+            message: "No canonical pm version bounds are declared; add pm_min_version so compatibility intent is explicit.",
+        });
+    }
     const minFinding = toCompatibilityFinding(minEvaluation, target.pmVersion);
     if (minFinding !== null) {
         findings.push(minFinding);
@@ -1071,4 +1101,4 @@ export function preflightExtension(blueprint, options = {}) {
     };
 }
 //# sourceMappingURL=compose.js.map
-//# debugId=fb438c6a-1927-54c3-98dd-dd7423df6722
+//# debugId=705476d3-74b8-540d-b646-956e24f703d4