@unbrained/pm-cli 2026.8.21 → 2026.8.23

package/dist/mcp/server.js

@@ -5,7 +5,7 @@
  * Runs the MCP server adapter that exposes pm actions and contracts to external agents.
  */
 
-!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]="561c51e0-d7d9-5303-b116-443ad5037943")}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]="740314ae-4228-5187-a939-f438fea48415")}catch(e){}}();
 import { realpathSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
@@ -20,6 +20,7 @@ import { PM_MCP_PROMPT_CONTRACTS, PM_MCP_RESOURCE_CONTRACTS, } from "../sdk/agen
 import { commitItemMutations } from "../sdk/item-transaction.js";
 import { isRuntimeRecord } from "../sdk/runtime-input.js";
 import { attachOutputTokenAccounting } from "../sdk/output-token-accounting.js";
+import { createReproducibleProcessRunner, runWithReproducibleProcessEnvironment, } from "../sdk/reproducibility/process.js";
 import { parseAtomicMutationControls, resolveItemMutationDocument, } from "../sdk/structured-mutations.js";
 import { resolveAuthor, resolvePmRoot } from "../sdk/runtime-primitives.js";
 const PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
@@ -227,17 +228,18 @@ function resultContent(result, warnings, tokenAccounting = false) {
 function errorContent(error) {
     const code = error instanceof PmCliError ? error.exitCode : 1;
     const message = error instanceof Error ? error.message : String(error);
+    const details = error instanceof PmCliError ? error.context : undefined;
     return {
         isError: true,
         content: [
             {
                 type: "text",
-                text: JSON.stringify({ error: message, code }, null, 2),
+                text: JSON.stringify({ error: message, code, details }, null, 2),
             },
         ],
         // Keep `result` present on the error envelope so consumers can read
         // `structuredContent.result` uniformly across success and failure (pm-l40h).
-        structuredContent: { result: null, error: message, code },
+        structuredContent: { result: null, error: message, code, details },
     };
 }
 /** Retain at most 32 own, valid provenance values without cloning unbounded input. */
@@ -403,7 +405,7 @@ function renderWorkflowPrompt(params) {
     };
 }
 /** Implements handle request for the public runtime surface of this module. */
-export async function handleRequest(request) {
+async function handleRequestInReproducibleContext(request) {
     if (!request.id && request.method?.startsWith("notifications/")) {
         return undefined;
     }
@@ -459,19 +461,24 @@ export async function handleRequest(request) {
     }
     throw new PmCliError(`Unsupported MCP method: ${request.method ?? "(missing)"}`, 64);
 }
+/** Dispatch one MCP request under supported process-level reproducibility settings. */
+export async function handleRequest(request) {
+    return runWithReproducibleProcessEnvironment(process.env, () => handleRequestInReproducibleContext(request));
+}
 function writeResponse(id, payload) {
     process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result: payload })}\n`);
 }
 function writeError(id, error) {
     const code = error instanceof PmCliError ? error.exitCode : -32603;
     const message = error instanceof Error ? error.message : String(error);
-    process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })}\n`);
+    const data = error instanceof PmCliError ? error.context : undefined;
+    process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message, data } })}\n`);
 }
 // pm-3puw: parse one JSON-RPC line, dispatch it, and write the response. Kept
 // as a standalone async unit so the stdio loop can enqueue it onto a serial
 // queue (process lines in arrival order) and tests can drive it directly.
 /** Implements process rpc line for the public runtime surface of this module. */
-export async function processRpcLine(line) {
+async function processRpcLineWithHandler(line, requestHandler) {
     if (line.trim().length === 0) {
         return;
     }
@@ -492,7 +499,7 @@ export async function processRpcLine(line) {
     }
     const shouldRespond = Object.prototype.hasOwnProperty.call(request, "id");
     try {
-        const result = await handleRequest(request);
+        const result = await requestHandler(request);
         if (shouldRespond && result !== undefined) {
             writeResponse(request.id, result);
         }
@@ -509,6 +516,10 @@ export async function processRpcLine(line) {
         }
     }
 }
+/** Implements process rpc line for the public runtime surface of this module. */
+export async function processRpcLine(line) {
+    await processRpcLineWithHandler(line, handleRequest);
+}
 /** Implements start mcp server for the public runtime surface of this module. */
 export function startMcpServer() {
     const rl = readline.createInterface({
@@ -520,8 +531,18 @@ export function startMcpServer() {
     // concurrently, so a client that pipelined two mutations on the same item
     // (without awaiting the first response) hit a lock conflict on the second.
     const queue = createSerialQueue();
+    let processLine;
+    try {
+        const runInProcessContext = createReproducibleProcessRunner(process.env);
+        processLine = (line) => runInProcessContext(() => processRpcLineWithHandler(line, handleRequestInReproducibleContext));
+    }
+    catch {
+        // Preserve one typed JSON-RPC error per request when process configuration
+        // is invalid; processRpcLine resolves the same configuration fail-closed.
+        processLine = processRpcLine;
+    }
     rl.on("line", (line) => {
-        void queue.enqueue(() => processRpcLine(line));
+        void queue.enqueue(() => processLine(line));
     });
 }
 // npm bin entries are symlinks (node_modules/.bin/pm-mcp -> dist/mcp/server.js),
@@ -621,4 +642,4 @@ if (isInvokedAsMcpMainModule(process.argv[1], import.meta.url)) {
 }
 /* c8 ignore stop */
 //# sourceMappingURL=server.js.map
-//# debugId=561c51e0-d7d9-5303-b116-443ad5037943
+//# debugId=740314ae-4228-5187-a939-f438fea48415

package/dist/sdk/agent/identity-config.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @module sdk/agent-identity-config
+ *
+ * Pure and versioned mutation planning for legacy author interpretation. The
+ * public summaries deliberately expose counts and revisions, never alias
+ * spellings, so config discovery is useful without leaking historical names.
+ */
+/** Persisted legacy-author interpretation vocabulary. */
+export interface AgentIdentityVocabulary {
+    /** Monotonic interpretation revision. */
+    version: number;
+    /** Exact legacy author spelling to canonical harness namespace. */
+    aliases: Record<string, string>;
+}
+/** Privacy-safe vocabulary projection used by config get/list/export. */
+export interface AgentIdentityVocabularySummary {
+    /** Current interpretation revision. */
+    version: number;
+    /** Number of exact legacy spellings configured. */
+    alias_count: number;
+}
+/** Supported vocabulary mutations. */
+export type AgentIdentityVocabularyOperation = "add" | "remove" | "clear";
+/** One typed vocabulary mutation and optional residual-coverage census. */
+export interface AgentIdentityVocabularyMutationInput {
+    /** Exact operation applied to the vocabulary. */
+    operation: AgentIdentityVocabularyOperation;
+    /** Exact legacy spelling required by add/remove. */
+    legacy_author?: string;
+    /** Canonical lowercase harness namespace required by add. */
+    canonical_harness?: string;
+    /** Optional bounded author census used only to count still-unmapped values. */
+    observed_authors?: readonly string[];
+}
+/** Privacy-safe dry-run or committed mutation preview. */
+export interface AgentIdentityVocabularyMutationPreview {
+    /** Operation that was evaluated. */
+    operation: AgentIdentityVocabularyOperation;
+    /** Whether persistence would change. */
+    changed: boolean;
+    /** Revision before the operation. */
+    version_before: number;
+    /** Revision after the operation, equal when idempotent. */
+    version_after: number;
+    /** Alias count after the operation. */
+    alias_count: number;
+    /** Unique non-canonical authors not covered after the operation. */
+    residual_author_count: number;
+}
+/** Planned vocabulary plus a privacy-safe result preview. */
+export interface AgentIdentityVocabularyMutationPlan {
+    /** Complete value suitable for settings persistence. */
+    vocabulary: AgentIdentityVocabulary;
+    /** Public mutation result with no alias spellings. */
+    preview: AgentIdentityVocabularyMutationPreview;
+}
+/** Return only the revision and count suitable for config discovery surfaces. */
+export declare function summarizeAgentIdentityVocabulary(vocabulary: AgentIdentityVocabulary | undefined): AgentIdentityVocabularySummary;
+/**
+ * Validate and plan one exact mutation. A real change increments the revision
+ * exactly once; identical adds and absent removes are idempotent.
+ */
+export declare function planAgentIdentityVocabularyMutation(current: AgentIdentityVocabulary | undefined, input: AgentIdentityVocabularyMutationInput): AgentIdentityVocabularyMutationPlan;

package/dist/sdk/agent/identity-config.js

@@ -0,0 +1,107 @@
+/**
+ * @module sdk/agent-identity-config
+ *
+ * Pure and versioned mutation planning for legacy author interpretation. The
+ * public summaries deliberately expose counts and revisions, never alias
+ * spellings, so config discovery is useful without leaking historical names.
+ */
+
+!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]="09703f32-9491-5d3a-9f90-f038d9982e17")}catch(e){}}();
+const HARNESS_NAMESPACE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const MAX_AUTHOR_LENGTH = 128;
+const MAX_OBSERVED_AUTHORS = 10_000;
+function requireLegacyAuthor(value) {
+    const author = value?.trim();
+    if (!author || author === "__proto__" || author.length > MAX_AUTHOR_LENGTH) {
+        throw new Error(`A legacy author must contain 1-${MAX_AUTHOR_LENGTH} characters.`);
+    }
+    return author;
+}
+function requireCanonicalHarness(value) {
+    const harness = value?.trim().toLowerCase();
+    if (!harness || !HARNESS_NAMESPACE_PATTERN.test(harness)) {
+        throw new Error("A canonical harness must be a lowercase dash-separated namespace.");
+    }
+    return harness;
+}
+function orderedAliases(aliases) {
+    return Object.fromEntries(Object.entries(aliases).sort(([left], [right]) => left.localeCompare(right)));
+}
+function countResidualAuthors(observed, aliases) {
+    const residual = new Set();
+    for (const raw of (observed ?? []).slice(0, MAX_OBSERVED_AUTHORS)) {
+        const author = raw.trim().slice(0, MAX_AUTHOR_LENGTH);
+        if (author.length === 0 ||
+            author.startsWith("harness:") ||
+            Object.hasOwn(aliases, author)) {
+            continue;
+        }
+        residual.add(author);
+    }
+    return residual.size;
+}
+function applyAddOperation(aliases, input) {
+    const legacyAuthor = requireLegacyAuthor(input.legacy_author);
+    const canonicalHarness = requireCanonicalHarness(input.canonical_harness);
+    if (legacyAuthor === canonicalHarness ||
+        legacyAuthor === `harness:${canonicalHarness}` ||
+        legacyAuthor.startsWith("harness:")) {
+        throw new Error(`The legacy author "${legacyAuthor}" is already canonical and must not be aliased.`);
+    }
+    if (aliases[legacyAuthor] === canonicalHarness)
+        return false;
+    aliases[legacyAuthor] = canonicalHarness;
+    return true;
+}
+function applyVocabularyOperation(aliases, input) {
+    if (input.operation === "add")
+        return applyAddOperation(aliases, input);
+    if (input.operation === "remove") {
+        const legacyAuthor = requireLegacyAuthor(input.legacy_author);
+        if (!Object.hasOwn(aliases, legacyAuthor))
+            return false;
+        delete aliases[legacyAuthor];
+        return true;
+    }
+    if (input.operation === "clear") {
+        const changed = Object.keys(aliases).length > 0;
+        for (const key of Object.keys(aliases))
+            delete aliases[key];
+        return changed;
+    }
+    const exhaustive = input.operation;
+    throw new Error(`Unsupported vocabulary operation: ${String(exhaustive)}`);
+}
+/** Return only the revision and count suitable for config discovery surfaces. */
+export function summarizeAgentIdentityVocabulary(vocabulary) {
+    return {
+        version: vocabulary?.version ?? 1,
+        alias_count: Object.keys(vocabulary?.aliases ?? {}).length,
+    };
+}
+/**
+ * Validate and plan one exact mutation. A real change increments the revision
+ * exactly once; identical adds and absent removes are idempotent.
+ */
+export function planAgentIdentityVocabularyMutation(current, input) {
+    const versionBefore = current?.version ?? 1;
+    const aliases = { ...current?.aliases };
+    const changed = applyVocabularyOperation(aliases, input);
+    const vocabulary = {
+        version: changed ? versionBefore + 1 : versionBefore,
+        aliases: orderedAliases(aliases),
+    };
+    return {
+        vocabulary,
+        preview: {
+            operation: input.operation,
+            changed,
+            version_before: versionBefore,
+            version_after: vocabulary.version,
+            alias_count: Object.keys(vocabulary.aliases).length,
+            residual_author_count: countResidualAuthors(input.observed_authors, vocabulary.aliases),
+        },
+    };
+}
+//# sourceMappingURL=identity-config.js.map
+//# debugId=09703f32-9491-5d3a-9f90-f038d9982e17

package/dist/sdk/agent/refusal-corpus-contracts.d.ts

@@ -0,0 +1,76 @@
+import { type PmCommandPositionalContract } from "../cli-contracts/grammar-contracts.js";
+/** Shared executable shape for a refusal that must not mutate tracker state. */
+export interface PmGrammarRefusalContract {
+    /** Stable probe identity used by ratchets and evidence. */
+    probe_id: string;
+    /** Canonical command path under test. */
+    command: string;
+    /** Exact argv expected to refuse. */
+    refusal_args: readonly string[];
+    /** Exact help argv that must execute successfully after the refusal. */
+    recovery_args: readonly string[];
+    /** Stable problem-envelope code expected from the refusal. */
+    error_code: "invalid_argument_value" | "missing_lifecycle_target" | "missing_required_argument" | "unknown_subcommand";
+}
+/** One required positional omission derived from the grammar declaration. */
+export interface PmRequiredArgumentRefusalContract extends PmGrammarRefusalContract {
+    /** Stable positional name deliberately omitted by the probe. */
+    missing_argument: string;
+    /** Zero-based slot index in the command's declared positional signature. */
+    missing_argument_index: number;
+}
+/** One invalid action probe for a closed positional subcommand family. */
+export interface PmSubcommandRefusalContract extends PmGrammarRefusalContract {
+    /** Invalid action token used to reach the refusal. */
+    rejected_value: string;
+    /** Complete authoritative action domain expected in recovery. */
+    allowed_values: readonly string[];
+}
+/** Runtime evidence for one grammar-derived refusal probe. */
+export interface PmGrammarRefusalObservation {
+    /** Probe identity matching a declared contract. */
+    probe_id: string;
+    /** Machine-readable code emitted by the refusal. */
+    error_code: string;
+    /** Process exit code emitted by the refusal. */
+    exit_code: number;
+    /** Allowed values emitted for a closed action family. */
+    allowed_values: readonly string[];
+    /** Whether the advertised help recovery exited successfully. */
+    recovery_succeeded: boolean;
+    /** Whether any tracker state changed while executing the refusal. */
+    refusal_mutated_state: boolean;
+    /** Repository-relative tracker paths changed by the refusal, when measured. */
+    mutated_paths?: readonly string[];
+}
+/** Stable reason a grammar-derived refusal failed closure. */
+export type PmGrammarRefusalFindingCode = "refusal_allowed_values_mismatch" | "refusal_error_code_mismatch" | "refusal_exit_code_mismatch" | "refusal_mutated_state" | "refusal_probe_missing" | "refusal_recovery_failed" | "unexpected_refusal_probe";
+/** One actionable grammar-derived refusal closure failure. */
+export interface PmGrammarRefusalFinding {
+    /** Stable machine-readable failure category. */
+    code: PmGrammarRefusalFindingCode;
+    /** Probe associated with the finding. */
+    probe_id: string;
+    /** Human-readable failure detail. */
+    detail: string;
+}
+/** Aggregate closure receipt for the grammar-derived refusal corpus. */
+export interface PmGrammarRefusalClosureReport {
+    /** Whether every declared probe refused safely and recovered. */
+    ok: boolean;
+    /** Number of declared probes. */
+    probe_count: number;
+    /** Number of probes without findings. */
+    closed_probe_count: number;
+    /** Stable actionable failures. */
+    findings: PmGrammarRefusalFinding[];
+}
+/**
+ * Return one omission probe for every required slot in the declared grammar.
+ * Earlier positionals receive deterministic, non-mutating placeholder values.
+ */
+export declare function listPmRequiredArgumentRefusalContracts(contracts?: readonly PmCommandPositionalContract[]): PmRequiredArgumentRefusalContract[];
+/** Return one invalid-action probe for every required positional action family. */
+export declare function listPmSubcommandRefusalContracts(contracts?: readonly PmCommandPositionalContract[]): PmSubcommandRefusalContract[];
+/** Score exact code, exit, domain, state-safety, and recovery closure. */
+export declare function scorePmGrammarRefusalClosure(contracts: readonly (PmRequiredArgumentRefusalContract | PmSubcommandRefusalContract)[], observations: readonly PmGrammarRefusalObservation[]): PmGrammarRefusalClosureReport;

package/dist/sdk/agent/refusal-corpus-contracts.js

@@ -0,0 +1,194 @@
+/**
+ * @module sdk/agent/refusal-corpus-contracts
+ *
+ * Derives executable refusal probes from the public CLI grammar. The corpus is
+ * fail-closed: adding a required positional slot or action-dispatching command
+ * automatically adds a probe, while an action family without an authoritative
+ * value domain throws during contract construction.
+ */
+
+!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]="2e90ea29-2708-5af8-b390-599be97718e7")}catch(e){}}();
+import { PLAN_SUBCOMMANDS } from "../lifecycle/plan.js";
+import { PROFILE_SUBCOMMANDS } from "../profile.js";
+import { SCHEMA_SUBCOMMANDS } from "../schema.js";
+import { GRAPH_SUBCOMMAND_VALUES, MERGE_SUBCOMMAND_VALUES, } from "../cli-contracts/enum-contracts.js";
+import { PM_COMMAND_DESTINATION_CONTRACTS, PM_COMMAND_POSITIONAL_CONTRACTS, PM_POSITIONAL_ACTION_CONTRACTS, } from "../cli-contracts/grammar-contracts.js";
+import { resolveSubcommandFlagContractsForCommand } from "../cli-contracts/flag-contracts.js";
+const REJECTED_ACTION = "not-a-declared-action";
+function positionalPlaceholder(command, slot) {
+    if (command.startsWith("assurance ") && slot.name === "kind") {
+        return "measurement";
+    }
+    switch (slot.value_kind) {
+        case "integer":
+            return "1";
+        case "item_id":
+            return "pm-domain";
+        case "action":
+            throw new Error(`Cannot synthesize a preceding action value for positional slot ${slot.name}.`);
+        default:
+            return "example";
+    }
+}
+function probeSlug(value) {
+    return value.replaceAll(/[^a-z0-9]+/gu, "-").replaceAll(/^-|-$/gu, "");
+}
+/**
+ * Return one omission probe for every required slot in the declared grammar.
+ * Earlier positionals receive deterministic, non-mutating placeholder values.
+ */
+export function listPmRequiredArgumentRefusalContracts(contracts = PM_COMMAND_POSITIONAL_CONTRACTS.filter((contract) => PM_COMMAND_DESTINATION_CONTRACTS.some((destination) => destination.command === contract.command &&
+    destination.disposition !== "package_owned"))) {
+    return contracts
+        .flatMap((contract) => contract.slots.flatMap((slot, index) => {
+        if (!slot.required)
+            return [];
+        const commandArguments = contract.command.split(" ");
+        const requiredFlagArguments = resolveSubcommandFlagContractsForCommand(contract.command).flatMap((flagContract) => flagContract.required
+            ? [
+                flagContract.flag,
+                ...(flagContract.value_name ? ["example"] : []),
+            ]
+            : []);
+        const isVirtualAction = PM_POSITIONAL_ACTION_CONTRACTS.some((actionContract) => actionContract.command === contract.command);
+        return [
+            {
+                probe_id: `required-argument-${probeSlug(contract.command)}-${probeSlug(slot.name)}`,
+                command: contract.command,
+                refusal_args: [
+                    ...commandArguments,
+                    ...contract.slots
+                        .slice(0, index)
+                        .map((priorSlot) => positionalPlaceholder(contract.command, priorSlot)),
+                    ...requiredFlagArguments,
+                ],
+                recovery_args: [...commandArguments, "--help"],
+                error_code: isVirtualAction && !contract.command.startsWith("assurance ")
+                    ? "invalid_argument_value"
+                    : /^extension (?:activate|adopt|deactivate|uninstall)$/u.test(contract.command)
+                        ? "missing_lifecycle_target"
+                        : "missing_required_argument",
+                missing_argument: slot.name,
+                missing_argument_index: index,
+            },
+        ];
+    }))
+        .sort((left, right) => left.probe_id.localeCompare(right.probe_id));
+}
+function positionalActionValues(command) {
+    switch (command) {
+        case "assurance":
+        case "workspace snapshot":
+            return PM_POSITIONAL_ACTION_CONTRACTS.filter(({ parent }) => parent === command).map(({ action }) => action);
+        case "graph":
+            return GRAPH_SUBCOMMAND_VALUES;
+        case "merge":
+            return MERGE_SUBCOMMAND_VALUES;
+        case "plan":
+            return PLAN_SUBCOMMANDS;
+        case "profile":
+            return PROFILE_SUBCOMMANDS;
+        case "schema":
+            return SCHEMA_SUBCOMMANDS;
+        default:
+            throw new Error(`Required positional action family ${command} has no authoritative value domain.`);
+    }
+}
+/** Return one invalid-action probe for every required positional action family. */
+export function listPmSubcommandRefusalContracts(contracts = PM_COMMAND_POSITIONAL_CONTRACTS) {
+    return contracts
+        .filter(({ slots }) => slots[0]?.required === true && slots[0].value_kind === "action")
+        .map(({ command }) => {
+        const commandArguments = command.split(" ");
+        return {
+            probe_id: `unknown-subcommand-${probeSlug(command)}`,
+            command,
+            refusal_args: [...commandArguments, REJECTED_ACTION],
+            recovery_args: [...commandArguments, "--help"],
+            error_code: "unknown_subcommand",
+            rejected_value: REJECTED_ACTION,
+            allowed_values: [...positionalActionValues(command)].sort(),
+        };
+    })
+        .sort((left, right) => left.probe_id.localeCompare(right.probe_id));
+}
+function sameValues(left, right) {
+    const sortedRight = [...right].sort();
+    return (left.length === right.length &&
+        [...left].sort().every((value, index) => value === sortedRight[index]));
+}
+function scoreGrammarRefusalObservation(contract, observation) {
+    if (!observation) {
+        return [
+            {
+                code: "refusal_probe_missing",
+                probe_id: contract.probe_id,
+                detail: `${contract.probe_id} has no runtime observation.`,
+            },
+        ];
+    }
+    const findings = [];
+    if (observation.error_code !== contract.error_code) {
+        findings.push({
+            code: "refusal_error_code_mismatch",
+            probe_id: contract.probe_id,
+            detail: `${contract.probe_id} emitted ${observation.error_code || "<none>"}; expected ${contract.error_code}.`,
+        });
+    }
+    if (observation.exit_code !== 2) {
+        findings.push({
+            code: "refusal_exit_code_mismatch",
+            probe_id: contract.probe_id,
+            detail: `${contract.probe_id} exited ${observation.exit_code}; expected usage exit 2.`,
+        });
+    }
+    if ("allowed_values" in contract &&
+        !sameValues(observation.allowed_values, contract.allowed_values)) {
+        findings.push({
+            code: "refusal_allowed_values_mismatch",
+            probe_id: contract.probe_id,
+            detail: `${contract.probe_id} did not expose its complete action domain.`,
+        });
+    }
+    if (!observation.recovery_succeeded) {
+        findings.push({
+            code: "refusal_recovery_failed",
+            probe_id: contract.probe_id,
+            detail: `${contract.probe_id} help recovery did not succeed.`,
+        });
+    }
+    if (observation.refusal_mutated_state) {
+        findings.push({
+            code: "refusal_mutated_state",
+            probe_id: contract.probe_id,
+            detail: `${contract.probe_id} changed tracker state while refusing input${observation.mutated_paths?.length ? `: ${observation.mutated_paths.join(", ")}` : "."}`,
+        });
+    }
+    return findings;
+}
+/** Score exact code, exit, domain, state-safety, and recovery closure. */
+export function scorePmGrammarRefusalClosure(contracts, observations) {
+    const contractsById = new Map(contracts.map((contract) => [contract.probe_id, contract]));
+    const observationsById = new Map(observations.map((observation) => [observation.probe_id, observation]));
+    const findings = [
+        ...contracts.flatMap((contract) => scoreGrammarRefusalObservation(contract, observationsById.get(contract.probe_id))),
+        ...observations
+            .filter((observation) => !contractsById.has(observation.probe_id))
+            .map((observation) => ({
+            code: "unexpected_refusal_probe",
+            probe_id: observation.probe_id,
+            detail: `${observation.probe_id} has no declared grammar refusal contract.`,
+        })),
+    ];
+    findings.sort((left, right) => left.probe_id.localeCompare(right.probe_id) ||
+        left.code.localeCompare(right.code));
+    const failedProbeIds = new Set(findings.map(({ probe_id: probeId }) => probeId));
+    return {
+        ok: findings.length === 0,
+        probe_count: contracts.length,
+        closed_probe_count: contracts.filter(({ probe_id: probeId }) => !failedProbeIds.has(probeId)).length,
+        findings,
+    };
+}
+//# sourceMappingURL=refusal-corpus-contracts.js.map
+//# debugId=2e90ea29-2708-5af8-b390-599be97718e7

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

@@ -37,7 +37,7 @@ export type PmRecoveryReferenceKind = (typeof PM_RECOVERY_REFERENCE_KINDS)[numbe
 /** 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" | "example" | "candidate_command" | "next_step" | "retry_command")[];
+export declare const PM_RECOVERY_REFERENCE_FIELDS: readonly ("suggested_retry" | "next_best_command" | "candidate_commands" | "next_steps" | "examples" | "restore_with" | "migration_hint" | "migration_hints" | "fallback_candidates" | "suggested_next_steps" | "example" | "candidate_command" | "next_step" | "retry_command")[];
 /** One source file supplied to the producer-census analyzer. */
 export interface PmRecoveryProducerSource {
     /** Repository-relative source path. */

package/dist/sdk/authoring.d.ts

@@ -15,4 +15,4 @@ export { planProfileApplication, type ProfileApplicationPlan, type ProfileChange
 export { EXTENSION_CAPABILITY_REGISTRATION_SURFACES, collectUsedExtensionCapabilities, reconcileExtensionCapabilityUsage, type CollectUsedExtensionCapabilitiesOptions, type ExtensionCapabilityUsageReconciliation, } from "../core/extensions/capability-usage.js";
 export { renderExtensionSurfaceMarkdown, type ExtensionSurfaceMarkdownOptions, } from "../core/extensions/activation-summary-markdown.js";
 export { createExtensionContributionInventory, normalizeExtensionContributionInventory, } from "../core/extensions/contribution-inventory.js";
-export type { AfterCommandAffectedItem, AfterCommandHook, AfterCommandHookContext, BeforeCommandHook, BeforeCommandHookContext, BeforeMutationHook, BeforeMutationHookContext, BeforeMutationHookDecision, CommandDefinition, ExtensionCommandArgumentDefinition, CommandHandler, CommandHandlerContext, CommandHandlerResult, ExtensionCommandSdk, CommandOverride, CommandOverrideContext, ExtensionServiceName, Exporter, ExporterArtifactOutputContract, ExporterRegistrationOptions, ExtensionActivationResult, ExtensionApi, ExtensionCommandRegistry, ExtensionDeactivationFailure, ExtensionDeactivationOptions, ExtensionDeactivationResult, ExtensionDiagnostic, ExtensionContributionInventory, ExtensionDiscoveryResult, ExtensionHookRegistry, ExtensionSelfIdentity, ExtensionLoadResult, ExtensionManifest, ExtensionManifestEngines, ExtensionMutationGuardSdk, ExtensionGovernancePolicy, ExtensionPolicyOverride, ExtensionProvenanceMetadata, ExtensionRuntimePermissionDeclaration, ExtensionSearchMode, ExtensionParserRegistry, ExtensionPreflightRegistry, ExtensionRegistrationRegistry, ExtensionRendererRegistry, ExtensionServiceRegistry, FlagValueType, FlagDefinition, ImportExportContext, ImportExportRegistrationOptions, Importer, OnIndexHook, OnIndexHookContext, OnReadHook, OnReadHookContext, OnWriteHook, OnWriteHookContext, OutputRendererFormat, ParserOverride, ParserOverrideContext, ParserOverrideDelta, PreflightOverride, PreflightOverrideContext, PreflightOverrideDelta, PreflightRuntimeDecision, RegisteredExtensionExporter, RegisteredExporterArtifactOutputContract, RegisteredExtensionFlagDefinitions, RegisteredExtensionHook, RegisteredExtensionImporter, RegisteredExtensionProjectProfile, RegisteredExtensionSchemaMigrationDefinition, RegisteredExtensionSearchProvider, RegisteredExtensionServiceOverride, RegisteredExtensionVectorStoreAdapter, RendererOverride, RendererOverrideContext, SchemaFieldDefinition, SchemaItemTypeCommandOptionPolicyDefinition, SchemaItemTypeOptionDefinition, SchemaItemTypeDefinition, SchemaMigrationDefinition, SchemaMigrationRunContext, SchemaMigrationRunner, SearchProviderEmbedBatchContext, SearchProviderEmbedContext, SearchProviderDefinition, SearchProviderHit, SearchProviderQueryContext, SearchProviderQueryResult, ServiceOverride, ServiceOverrideContext, ServiceOverrideDecision, VectorStoreAdapterDefinition, VectorStoreDeleteContext, VectorStoreQueryContext, VectorStoreQueryHit, VectorStoreUpsertContext, VectorStoreUpsertPoint, } from "../core/extensions/loader.js";
+export type { AfterCommandAffectedItem, AfterCommandHook, AfterCommandHookContext, BeforeCommandHook, BeforeCommandHookContext, BeforeMutationHook, BeforeMutationHookContext, BeforeMutationHookDecision, CommandDefinition, ExtensionCommandArgumentDefinition, CommandHandler, CommandHandlerContext, CommandHandlerResult, ExtensionCommandSdk, CommandOverride, CommandOverrideContext, ExtensionServiceName, Exporter, ExporterArtifactOutputContract, ExporterRegistrationOptions, ExtensionActivationResult, ExtensionApi, ExtensionCommandRegistry, ExtensionDeactivationFailure, ExtensionDeactivationOptions, ExtensionDeactivationResult, ExtensionDiagnostic, ExtensionContributionInventory, ExtensionDiscoveryResult, ExtensionHookRegistry, ExtensionSelfIdentity, ExtensionLoadResult, ExtensionManifest, ExtensionManifestEngines, ExtensionMutationGuardSdk, ExtensionGovernancePolicy, ExtensionPolicyOverride, ExtensionProvenanceMetadata, ExtensionRuntimePermissionDeclaration, ExtensionSearchMode, ExtensionParserRegistry, ExtensionPreflightRegistry, ExtensionRegistrationRegistry, ExtensionRendererRegistry, ExtensionServiceRegistry, FlagValueType, FlagDefinition, ImportExportContext, ImportExportRegistrationOptions, Importer, OnIndexHook, OnIndexHookContext, OnReadHook, OnReadHookContext, OnWriteHook, OnWriteHookContext, OutputRendererFormat, ParserOverride, ParserOverrideContext, ParserOverrideDelta, PreflightOverride, PreflightOverrideContext, PreflightOverrideDelta, PreflightRuntimeDecision, RegisteredExtensionExporter, RegisteredExporterArtifactOutputContract, RegisteredExtensionFlagDefinitions, RegisteredExtensionHook, RegisteredExtensionImporter, RegisteredExtensionProjectProfile, RegisteredExtensionSchemaMigrationDefinition, RegisteredExtensionSearchProvider, RegisteredExtensionServiceOverride, RegisteredExtensionVectorStoreAdapter, RendererOverride, RendererOverrideContext, SchemaFieldDefinition, SchemaItemTypeCommandOptionPolicyDefinition, SchemaItemTypeOptionDefinition, SchemaItemTypeDefinition, SchemaMigrationDefinition, SchemaMigrationRunContext, SchemaMigrationRunner, SearchProviderEmbedBatchContext, SearchProviderEmbedContext, SearchProviderDefinition, SearchProviderHit, SearchProviderQueryContext, SearchProviderQueryResult, ServiceOverride, ServiceOverrideContext, ServiceOverrideDecision, ServiceOverrideOwnership, VectorStoreAdapterDefinition, VectorStoreDeleteContext, VectorStoreQueryContext, VectorStoreQueryHit, VectorStoreUpsertContext, VectorStoreUpsertPoint, } from "../core/extensions/loader.js";

package/dist/sdk/authoring.js

@@ -4,7 +4,7 @@
  * Provides the focused extension and package authoring surface.
  */
 
-!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]="6260572c-1496-58ef-9377-0825f4183bc6")}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]="bca95ba2-258c-5be2-8428-dcb8dbc87ef0")}catch(e){}}();
 export * from "./compose.js";
 export * from "./define.js";
 export * from "./extension-contracts.js";
@@ -18,4 +18,4 @@ export { EXTENSION_CAPABILITY_REGISTRATION_SURFACES, collectUsedExtensionCapabil
 export { renderExtensionSurfaceMarkdown, } from "../core/extensions/activation-summary-markdown.js";
 export { createExtensionContributionInventory, normalizeExtensionContributionInventory, } from "../core/extensions/contribution-inventory.js";
 //# sourceMappingURL=authoring.js.map
-//# debugId=6260572c-1496-58ef-9377-0825f4183bc6
+//# debugId=bca95ba2-258c-5be2-8428-dcb8dbc87ef0