@unbrained/pm-cli 2026.8.22 → 2026.8.23

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/cli-contracts/agent-output-contracts.js

@@ -6,7 +6,7 @@
  * output policy without coupling package authors to pm's renderer.
  */
 
-!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]="b3f5a4bc-d853-530e-8f5e-d682d8b93c9d")}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]="1d338971-5a60-5b4e-b4c8-0705c8e8c98c")}catch(e){}}();
 import { PM_CORE_COMMAND_NAMES } from "./enum-contracts.js";
 /** Stable degradation stages applied when an output exceeds its token budget. */
 export const PM_OUTPUT_DEGRADATION_STEPS = [
@@ -218,8 +218,10 @@ function compactDiagnosticRecovery(value) {
         "retry_after_ms",
     ]) {
         const candidate = value[key];
-        if (Array.isArray(candidate))
-            compact[key] = candidate.slice(0, 3);
+        if (Array.isArray(candidate)) {
+            compact[key] =
+                key === "suggested_retry_args" ? candidate : candidate.slice(0, 3);
+        }
         else if (candidate !== undefined)
             compact[key] = candidate;
     }
@@ -473,4 +475,4 @@ export function projectPmDiagnosticText(output, correctiveAction, options = {})
     };
 }
 //# sourceMappingURL=agent-output-contracts.js.map
-//# debugId=b3f5a4bc-d853-530e-8f5e-d682d8b93c9d
+//# debugId=1d338971-5a60-5b4e-b4c8-0705c8e8c98c

package/dist/sdk/cli-contracts/enum-contracts.d.ts

@@ -28,6 +28,10 @@ export declare const PM_CORE_COMMAND_NAMES: readonly ["init", "config", "extensi
 export declare const GRAPH_SUBCOMMAND_VALUES: readonly ["ancestors", "descendants", "predecessors", "successors", "paths", "impact", "analyze", "audit", "communities", "redundancy", "dominators", "slack", "centrality", "articulation", "plan", "index"];
 /** Restricts graph subcommand values accepted by command, SDK, and MCP contracts. */
 export type GraphSubcommand = (typeof GRAPH_SUBCOMMAND_VALUES)[number];
+/** Supported values accepted by the merge subcommand contract across CLI and SDK surfaces. */
+export declare const MERGE_SUBCOMMAND_VALUES: readonly ["install", "reconcile", "report", "driver"];
+/** Restricts merge subcommand values accepted by command and SDK contracts. */
+export type MergeSubcommand = (typeof MERGE_SUBCOMMAND_VALUES)[number];
 /** Nested lifecycle verbs flattened by SDK and MCP package actions. */
 export declare const PM_EXTENSION_PACKAGE_ACTION_SUBCOMMANDS: readonly ["init", "install", "uninstall", "explore", "manage", "describe", "reload", "doctor", "catalog", "adopt", "adopt-all", "activate", "deactivate"];
 /** Noun-first item lifecycle verbs flattened for SDK and MCP dispatch. */

package/dist/sdk/cli-contracts/enum-contracts.js

@@ -4,7 +4,7 @@
  * Defines SDK command-contract metadata for Enum Contracts.
  */
 
-!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]="8b8b6b8e-5061-5da4-a369-eca379c0090b")}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]="3935bae8-0a40-59ea-aca6-64e238d1f318")}catch(e){}}();
 import { KNOWN_EXTENSION_CAPABILITIES, KNOWN_EXTENSION_POLICY_MODES, KNOWN_EXTENSION_POLICY_SURFACES, KNOWN_EXTENSION_SANDBOX_PROFILES, KNOWN_EXTENSION_SERVICE_NAMES, KNOWN_EXTENSION_TRUST_MODES, } from "../../core/extensions/extension-types.js";
 import { PM_COMMAND_ALIAS_CONTRACTS } from "./command-aliases.js";
 /** Public contract for pm extension capability contracts, shared by SDK and presentation-layer consumers. */
@@ -124,6 +124,13 @@ export const GRAPH_SUBCOMMAND_VALUES = [
     "plan",
     "index",
 ];
+/** Supported values accepted by the merge subcommand contract across CLI and SDK surfaces. */
+export const MERGE_SUBCOMMAND_VALUES = [
+    "install",
+    "reconcile",
+    "report",
+    "driver",
+];
 /** Nested lifecycle verbs flattened by SDK and MCP package actions. */
 export const PM_EXTENSION_PACKAGE_ACTION_SUBCOMMANDS = [
     "init",
@@ -208,4 +215,4 @@ export function isPmExtensionPolicySurfaceContract(value) {
     return PM_EXTENSION_POLICY_SURFACE_CONTRACTS.includes(value);
 }
 //# sourceMappingURL=enum-contracts.js.map
-//# debugId=8b8b6b8e-5061-5da4-a369-eca379c0090b
+//# debugId=3935bae8-0a40-59ea-aca6-64e238d1f318

package/dist/sdk/cli-contracts/flag-contracts.js

@@ -7,7 +7,7 @@
  * flag surface stays single-sourced across the CLI, SDK, and MCP boundaries.
  */
 
-!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]="e302f519-aa51-503b-bd1a-f3155338f133")}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]="6664bc8f-e5da-5593-a2df-ac45f1cef09e")}catch(e){}}();
 import { normalizeUniqueStringList } from "./string-lists.js";
 import { RESERVED_EXTENSION_HOST_FLAGS } from "../../core/extensions/reserved-host-flags.js";
 import { PM_POSITIONAL_ACTION_CONTRACTS, } from "./grammar-contracts.js";
@@ -894,6 +894,10 @@ export const TEST_FLAG_CONTRACTS = [
     { flag: "--shared-host-safe" },
     { flag: "--pm-context" },
     { flag: "--override-linked-pm-context" },
+    { flag: "--workspace-context" },
+    { flag: "--override-linked-workspace-context" },
+    { flag: "--allow-untrusted-linked-tests" },
+    { flag: "--acknowledge-linked-tests" },
     { flag: "--fail-on-context-mismatch" },
     { flag: "--fail-on-skipped" },
     { flag: "--fail-on-empty-test-run" },
@@ -920,6 +924,9 @@ export const TEST_ALL_FLAG_CONTRACTS = [
     { flag: "--shared-host-safe" },
     { flag: "--pm-context" },
     { flag: "--override-linked-pm-context" },
+    { flag: "--workspace-context" },
+    { flag: "--override-linked-workspace-context" },
+    { flag: "--allow-untrusted-linked-tests" },
     { flag: "--fail-on-context-mismatch" },
     { flag: "--fail-on-skipped" },
     { flag: "--fail-on-empty-test-run" },
@@ -1901,4 +1908,4 @@ export function toCompletionFlagString(flagContracts, includeGlobal = true) {
     return normalizeUniqueStringList(all).join(" ");
 }
 //# sourceMappingURL=flag-contracts.js.map
-//# debugId=e302f519-aa51-503b-bd1a-f3155338f133
+//# debugId=6664bc8f-e5da-5593-a2df-ac45f1cef09e

package/dist/sdk/cli-contracts/flag-lexicon-contracts.js

@@ -5,7 +5,7 @@
  * per-command growth budgets.
  */
 
-!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]="6ba3d756-dcd6-59b7-92fe-ec33d294d72b")}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]="8320177c-e95d-5d14-a914-4ac37230c0b9")}catch(e){}}();
 import { hasSubcommandFlagContractsForCommand, resolveSubcommandFlagContractsForCommand, } from "./flag-contracts.js";
 import { PM_COMMAND_CAPABILITY_CONTRACTS, } from "../agent-capability-contracts.js";
 import { enrichCliFlagInvocationContracts } from "../flag-invocation-contracts.js";
@@ -153,8 +153,8 @@ const PM_COMMAND_FLAG_BUDGET_MAXIMUMS = Object.freeze({
     docs: 30,
     deps: 32,
     plan: 109,
-    test: 48,
-    "test-all": 37,
+    test: 52,
+    "test-all": 40,
     telemetry: 21,
     stats: 29,
     health: 36,
@@ -337,4 +337,4 @@ export function renderPmFlagLexiconMarkdown() {
     ].join("\n");
 }
 //# sourceMappingURL=flag-lexicon-contracts.js.map
-//# debugId=6ba3d756-dcd6-59b7-92fe-ec33d294d72b
+//# debugId=8320177c-e95d-5d14-a914-4ac37230c0b9

package/dist/sdk/cli-contracts/registration-helpers.js

@@ -4,7 +4,7 @@
  * Provides CLI runtime support for Registration Helpers.
  */
 
-!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]="8d60b13c-c58a-506f-adc9-2414dd69edef")}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]="01742f33-d1e8-5684-a585-2add88ddb73c")}catch(e){}}();
 import { Option } from "commander";
 import { pathExists, refreshSearchArtifactsForMutation, shouldRunSearchRefreshInForeground, EXIT_CODE, PmCliError, printError, printResult, writeStdout, getSettingsPath, resolvePmRoot, readSettings, runActiveServiceOverride, setActiveCommandResult, } from "../runtime-primitives.js";
 import { ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS, CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS, CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS, CREATE_COMMANDER_STRING_OPTION_CONTRACTS, LIST_COMMANDER_STRING_OPTION_CONTRACTS, NEXT_COMMANDER_STRING_OPTION_CONTRACTS, SEARCH_COMMANDER_STRING_OPTION_CONTRACTS, UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS, UPDATE_COMMANDER_STRING_OPTION_CONTRACTS, readFirstValueFromCommanderOptions, readFirstStringFromCommanderOptions, readStringArrayFromCommanderOptions, } from "../cli-contracts.js";
@@ -259,6 +259,9 @@ function pushSharedBackgroundTestCommandArgs(args, options) {
     pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
     pushOptionalValueFlag(args, "--pm-context", options.pmContext);
     pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
+    pushOptionalValueFlag(args, "--workspace-context", options.workspaceContext);
+    pushOptionalBooleanFlag(args, "--override-linked-workspace-context", options.overrideLinkedWorkspaceContext);
+    pushOptionalBooleanFlag(args, "--allow-untrusted-linked-tests", options.allowUntrustedLinkedTests);
     pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
     pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
     pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
@@ -985,4 +988,4 @@ export const _testOnly = {
     collectMutationItemIds,
 };
 //# sourceMappingURL=registration-helpers.js.map
-//# debugId=8d60b13c-c58a-506f-adc9-2414dd69edef
+//# debugId=01742f33-d1e8-5684-a585-2add88ddb73c

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]="e0314840-0dac-5966-8c4f-3a3e5db15688")}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]="fc485dff-5576-536e-86b2-8cc167d4513c")}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";
@@ -398,6 +398,13 @@ export const PM_TOOL_PARAMETER_PROPERTIES = {
     ignoreGlobal: { type: "boolean" },
     pmContext: { type: "string", enum: ["schema", "tracker", "auto"] },
     overrideLinkedPmContext: { type: "boolean" },
+    workspaceContext: {
+        type: "string",
+        enum: ["source", "isolated", "snapshot"],
+    },
+    overrideLinkedWorkspaceContext: { type: "boolean" },
+    allowUntrustedLinkedTests: { type: "boolean" },
+    acknowledgeLinkedTests: { type: "boolean" },
     failOnContextMismatch: { type: "boolean" },
     failOnSkipped: { type: "boolean" },
     failOnEmptyTestRun: { type: "boolean" },
@@ -1376,6 +1383,19 @@ export const PM_TOOL_PARAMETER_METADATA = {
     overrideLinkedPmContext: {
         description: "Force run-level --pm-context to override per-linked-test pm_context_mode metadata for all linked-test entries.",
     },
+    workspaceContext: {
+        description: "Source-workspace mode: source preserves read-only source context, isolated omits it for self-sandboxing commands, and snapshot runs from a temporary workspace paired with the selected tracker sandbox.",
+        examples: ["source", "isolated", "snapshot"],
+    },
+    overrideLinkedWorkspaceContext: {
+        description: "Force run-level --workspace-context over per-linked-test workspace_context_mode metadata.",
+    },
+    allowUntrustedLinkedTests: {
+        description: "Explicitly execute commands not yet trusted by this clone when testing.allow_untrusted_linked_tests is also enabled.",
+    },
+    acknowledgeLinkedTests: {
+        description: "Record clone-local trust for the item's current linked commands without executing them.",
+    },
     failOnContextMismatch: {
         description: "Fail linked PM command runs when source and sandbox tracker item counts differ.",
     },
@@ -2072,4 +2092,4 @@ export const PM_TOOL_ACTION_SCOPED_PARAMETER_METADATA = {
     },
 };
 //# sourceMappingURL=tool-parameter-tables.js.map
-//# debugId=e0314840-0dac-5966-8c4f-3a3e5db15688
+//# debugId=fc485dff-5576-536e-86b2-8cc167d4513c