@unbrained/pm-cli 2026.8.11 → 2026.8.13

package/dist/sdk/governance/assurance-action.d.ts

@@ -4,9 +4,10 @@
  * Normalizes the assurance action vocabulary once for CLI, SDK, and MCP hosts.
  */
 import type { GlobalOptions } from "../../core/shared/command-types.js";
-import { type AssuranceDeclaration, type AssuranceGateVerdict, type AssuranceMutationReceipt } from "./assurance.js";
+import { type AssuranceBundleMutationReceipt, type AssuranceDeclaration, type AssuranceGateVerdict, type AssuranceMutationReceipt } from "./assurance.js";
+import { type AssuranceDerivedProposal, type AssurancePreset, type AssurancePresetId } from "./assurance-presets.js";
 /** Assurance registry and evaluation verbs shared by every transport. */
-export declare const ASSURANCE_ACTIONS: readonly ["list", "show", "put", "remove", "run", "verdicts"];
+export declare const ASSURANCE_ACTIONS: readonly ["list", "show", "put", "remove", "run", "verdicts", "presets", "apply", "derive", "promote"];
 /** Assurance declaration kinds shared by every transport. */
 export declare const ASSURANCE_DECLARATION_KINDS: readonly ["measurement", "assertion", "gate"];
 /** Assurance action verb. */
@@ -39,9 +40,32 @@ export interface AssuranceActionInput {
     author?: string;
     /** Audited mutation rationale. */
     message?: string;
+    /** Built-in preset selected for preview or application. */
+    preset?: string;
+    /** pm item that owns preset or derived assertions. */
+    owner?: string;
+    /** Explicitly accept derived proposals. */
+    apply?: boolean;
+    /** Explicit next assertion enforcement level. */
+    enforcement?: string;
 }
 /** Result union returned by transport-neutral assurance execution. */
-export type AssuranceActionResult = AssuranceDeclaration | AssuranceMutationReceipt | AssuranceGateVerdict | {
+export type AssuranceActionResult = AssuranceDeclaration | AssuranceMutationReceipt | AssuranceGateVerdict | AssuranceBundleMutationReceipt | AssurancePreset | {
+    items: AssuranceDerivedProposal[];
+    count: number;
+    applied?: AssuranceBundleMutationReceipt;
+} | {
+    items: Array<{
+        id: AssurancePresetId;
+        title: string;
+        description: string;
+    }>;
+    count: number;
+    row_contract: {
+        row_keys: ["items"];
+        jq_selector: ".items[]";
+    };
+} | {
     id: string;
 } | {
     /** Registry declarations. */

package/dist/sdk/governance/assurance-action.js

@@ -1,9 +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]="597e1ac0-f461-5984-95a9-cd3447b1fea7")}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]="36dfa230-06bd-5902-a0c9-94a7c34cda90")}catch(e){}}();
 import { EXIT_CODE } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
 import { ASSURANCE_GATE_TRIGGERS, evaluateAssuranceGate, getAssuranceDeclaration, listAssuranceDeclarations, listAssuranceVerdicts, putAssuranceDeclaration, recordAssuranceVerdict, removeAssuranceDeclaration, } from "./assurance.js";
+import { ASSURANCE_PRESET_IDS, acceptAssuranceProposals, applyAssurancePreset, createAssurancePreset, deriveAssuranceProposals, promoteAssuranceAssertion, } from "./assurance-presets.js";
 import { MAX_ASSURANCE_VERDICT_LIMIT } from "./assurance-limits.js";
+import { normalizeAssuranceEvaluation, normalizeAssuranceMutation, } from "./assurance-mutation-error.js";
 import { createAssuranceWorkspaceContext } from "./assurance-runtime.js";
 import { resolvePmRoot } from "../runtime-primitives.js";
 import { parseRuntimeInteger, readRuntimeString } from "../runtime-input.js";
@@ -15,6 +17,10 @@ export const ASSURANCE_ACTIONS = [
     "remove",
     "run",
     "verdicts",
+    "presets",
+    "apply",
+    "derive",
+    "promote",
 ];
 /** Assurance declaration kinds shared by every transport. */
 export const ASSURANCE_DECLARATION_KINDS = [
@@ -35,6 +41,17 @@ function parseKind(value) {
     }
     throw new PmCliError(`Assurance declaration kind is required. Expected: ${ASSURANCE_DECLARATION_KINDS.join(", ")}`, EXIT_CODE.USAGE);
 }
+function parsePreset(value) {
+    if (value && ASSURANCE_PRESET_IDS.includes(value)) {
+        return value;
+    }
+    throw new PmCliError(`Assurance preset is required. Expected: ${ASSURANCE_PRESET_IDS.join(", ")}`, EXIT_CODE.USAGE);
+}
+function requireOwner(input) {
+    if (input.owner?.trim())
+        return input.owner.trim();
+    throw new PmCliError("assurance preset and derivation actions require --owner <pm-item-id>", EXIT_CODE.USAGE);
+}
 function parseDefinition(kind, value) {
     let parsed = value;
     if (typeof value === "string") {
@@ -109,38 +126,99 @@ async function runVerdictsAction(input, pmRoot) {
         row_contract: { row_keys: ["items"], jq_selector: ".items[]" },
     };
 }
+async function runAdoptionAction(action, input, pmRoot) {
+    if (action === "presets") {
+        if (input.preset ?? input.id) {
+            return createAssurancePreset(parsePreset(input.preset ?? input.id), requireOwner(input));
+        }
+        const items = ASSURANCE_PRESET_IDS.map((id) => {
+            const preset = createAssurancePreset(id, "pm-owner");
+            return { id, title: preset.title, description: preset.description };
+        });
+        return {
+            items,
+            count: items.length,
+            row_contract: { row_keys: ["items"], jq_selector: ".items[]" },
+        };
+    }
+    if (action === "apply") {
+        return normalizeAssuranceMutation(() => applyAssurancePreset(pmRoot, parsePreset(input.preset ?? input.id), requireOwner(input), { author: input.author, message: input.message }));
+    }
+    if (action === "derive") {
+        const proposals = await deriveAssuranceProposals(await createAssuranceWorkspaceContext(pmRoot, {
+            resolve_tree: false,
+            trigger: "derive",
+        }), requireOwner(input));
+        const applied = input.apply
+            ? await normalizeAssuranceMutation(() => acceptAssuranceProposals(pmRoot, proposals, {
+                author: input.author,
+                message: input.message ?? "Accept observation-derived assurance proposals",
+            }))
+            : undefined;
+        return {
+            items: proposals,
+            count: proposals.length,
+            ...(applied ? { applied } : {}),
+        };
+    }
+    if (!input.id) {
+        throw new PmCliError("assurance promote requires an assertion id", EXIT_CODE.USAGE);
+    }
+    if (input.enforcement !== "warn" && input.enforcement !== "block") {
+        throw new PmCliError("assurance promote requires --enforcement warn|block", EXIT_CODE.USAGE);
+    }
+    const definition = (await getAssuranceDeclaration(pmRoot, "assertion", input.id));
+    return normalizeAssuranceMutation(() => promoteAssuranceAssertion(pmRoot, definition, input.enforcement, {
+        author: input.author,
+        message: input.message,
+    }));
+}
+async function runGateAction(input, pmRoot) {
+    if (!input.id) {
+        throw new PmCliError("assurance run requires a gate id", EXIT_CODE.USAGE);
+    }
+    const gateId = input.id;
+    if (!input.trigger) {
+        throw new PmCliError("assurance run requires a trigger", EXIT_CODE.USAGE);
+    }
+    if (!ASSURANCE_GATE_TRIGGERS.includes(input.trigger)) {
+        throw new PmCliError(`Unknown assurance trigger ${input.trigger}. Expected: ${ASSURANCE_GATE_TRIGGERS.join(", ")}`, EXIT_CODE.USAGE);
+    }
+    const trigger = input.trigger;
+    const [document, workspaceContext] = await Promise.all([
+        readDocument(pmRoot),
+        createAssuranceWorkspaceContext(pmRoot, {
+            tree_id: input.tree,
+            trigger,
+        }),
+    ]);
+    const verdict = await normalizeAssuranceEvaluation(() => evaluateAssuranceGate(gateId, document, workspaceContext, {
+        trigger,
+        dry_run: input.dry_run === true,
+    }));
+    if (!verdict.dry_run) {
+        await recordAssuranceVerdict(pmRoot, verdict, {
+            author: input.author,
+            message: input.message,
+        });
+    }
+    return verdict;
+}
 /** Execute one assurance request through the public assurance SDK primitives. */
 export async function runAssuranceAction(input, global = {}) {
     const action = parseAction(input.action);
     const pmRoot = resolvePmRoot(process.cwd(), global.path);
+    if (action === "presets" ||
+        action === "apply" ||
+        action === "derive" ||
+        action === "promote") {
+        return runAdoptionAction(action, input, pmRoot);
+    }
     if (action === "verdicts") {
         return runVerdictsAction(input, pmRoot);
     }
     if (action === "run") {
-        if (!input.id) {
-            throw new PmCliError("assurance run requires a gate id", EXIT_CODE.USAGE);
-        }
-        if (!input.trigger) {
-            throw new PmCliError("assurance run requires a trigger", EXIT_CODE.USAGE);
-        }
-        if (!ASSURANCE_GATE_TRIGGERS.includes(input.trigger)) {
-            throw new PmCliError(`Unknown assurance trigger ${input.trigger}. Expected: ${ASSURANCE_GATE_TRIGGERS.join(", ")}`, EXIT_CODE.USAGE);
-        }
-        const [document, workspaceContext] = await Promise.all([
-            readDocument(pmRoot),
-            createAssuranceWorkspaceContext(pmRoot, { tree_id: input.tree }),
-        ]);
-        const verdict = await evaluateAssuranceGate(input.id, document, workspaceContext, {
-            trigger: input.trigger,
-            dry_run: input.dry_run === true,
-        });
-        if (!verdict.dry_run) {
-            await recordAssuranceVerdict(pmRoot, verdict, {
-                author: input.author,
-                message: input.message,
-            });
-        }
-        return verdict;
+        return runGateAction(input, pmRoot);
     }
     const kind = parseKind(input.kind);
     if (action === "list")
@@ -148,16 +226,20 @@ export async function runAssuranceAction(input, global = {}) {
     if (!input.id) {
         throw new PmCliError(`assurance ${action} requires an id`, EXIT_CODE.USAGE);
     }
+    const id = input.id;
     if (action === "show") {
-        return getAssuranceDeclaration(pmRoot, kind, input.id);
+        return getAssuranceDeclaration(pmRoot, kind, id);
     }
     if (action === "remove") {
-        const receipt = await removeAssuranceDeclaration(pmRoot, kind, input.id, { author: input.author, message: input.message });
+        const receipt = await normalizeAssuranceMutation(() => removeAssuranceDeclaration(pmRoot, kind, id, {
+            author: input.author,
+            message: input.message,
+        }));
         return projectMutationReceipt(receipt, input.idOnly);
     }
     const definition = parseDefinition(kind, input.definition);
-    if (definition.id !== input.id) {
-        throw new PmCliError(`Assurance definition id ${definition.id} does not match requested id ${input.id}`, EXIT_CODE.USAGE);
+    if (definition.id !== id) {
+        throw new PmCliError(`Assurance definition id ${definition.id} does not match requested id ${id}`, EXIT_CODE.USAGE);
     }
     const mutationOptions = {
         author: input.author,
@@ -168,7 +250,7 @@ export async function runAssuranceAction(input, global = {}) {
             }
             : {}),
     };
-    const receipt = await putAssuranceDeclaration(pmRoot, kind, definition, mutationOptions);
+    const receipt = await normalizeAssuranceMutation(() => putAssuranceDeclaration(pmRoot, kind, definition, mutationOptions));
     return projectMutationReceipt(receipt, input.idOnly);
 }
 /** Normalize a generic SDK or MCP argument envelope into one assurance request. */
@@ -192,7 +274,11 @@ export function runAssuranceDispatch(args, options, global) {
         idOnly: merged.idOnly === true,
         author: readRuntimeString(merged, "author"),
         message: readRuntimeString(merged, "message"),
+        preset: readRuntimeString(merged, "preset"),
+        owner: readRuntimeString(merged, "owner"),
+        apply: merged.apply === true,
+        enforcement: readRuntimeString(merged, "enforcement"),
     }, global);
 }
 //# sourceMappingURL=assurance-action.js.map
-//# debugId=597e1ac0-f461-5984-95a9-cd3447b1fea7
+//# debugId=36dfa230-06bd-5902-a0c9-94a7c34cda90

package/dist/sdk/governance/assurance-mutation-error.d.ts

@@ -0,0 +1,14 @@
+/** Expected declaration-validation or mutation-policy refusal. */
+export declare class AssuranceMutationRefusalError extends TypeError {
+    /** Create one typed refusal while retaining TypeError compatibility for SDK callers. */
+    constructor(message: string);
+}
+/** Expected gate-policy refusal caused by an incomplete or disallowed provider contract. */
+export declare class AssuranceEvaluationRefusalError extends TypeError {
+    /** Create one typed refusal while retaining TypeError compatibility for SDK callers. */
+    constructor(message: string);
+}
+/** Normalize only expected assurance mutation refusals for CLI and MCP hosts. */
+export declare function normalizeAssuranceMutation<T>(operation: () => Promise<T>): Promise<T>;
+/** Normalize only expected assurance evaluation-policy refusals for transport hosts. */
+export declare function normalizeAssuranceEvaluation<T>(operation: () => Promise<T>): Promise<T>;

package/dist/sdk/governance/assurance-mutation-error.js

@@ -0,0 +1,58 @@
+/**
+ * @module sdk/assurance-mutation-error
+ *
+ * Distinguishes expected assurance mutation refusals from unexpected runtime
+ * faults before transport layers normalize them into stable usage errors.
+ */
+
+!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]="93a32771-bf95-5df4-8019-b6be45a5051b")}catch(e){}}();
+import { EXIT_CODE } from "../../core/shared/constants.js";
+import { PmCliError } from "../../core/shared/errors.js";
+/** Expected declaration-validation or mutation-policy refusal. */
+export class AssuranceMutationRefusalError extends TypeError {
+    /** Create one typed refusal while retaining TypeError compatibility for SDK callers. */
+    constructor(message) {
+        super(message);
+        this.name = "AssuranceMutationRefusalError";
+    }
+}
+/** Expected gate-policy refusal caused by an incomplete or disallowed provider contract. */
+export class AssuranceEvaluationRefusalError extends TypeError {
+    /** Create one typed refusal while retaining TypeError compatibility for SDK callers. */
+    constructor(message) {
+        super(message);
+        this.name = "AssuranceEvaluationRefusalError";
+    }
+}
+/** Normalize only expected assurance mutation refusals for CLI and MCP hosts. */
+export async function normalizeAssuranceMutation(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof AssuranceMutationRefusalError) {
+            throw new PmCliError(error.message, EXIT_CODE.USAGE, {
+                code: "invalid_argument_value",
+                reason: "assurance_mutation_refused",
+            });
+        }
+        throw error;
+    }
+}
+/** Normalize only expected assurance evaluation-policy refusals for transport hosts. */
+export async function normalizeAssuranceEvaluation(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof AssuranceEvaluationRefusalError) {
+            throw new PmCliError(error.message, EXIT_CODE.USAGE, {
+                code: "invalid_argument_value",
+                reason: "assurance_evaluation_refused",
+            });
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=assurance-mutation-error.js.map
+//# debugId=93a32771-bf95-5df4-8019-b6be45a5051b

package/dist/sdk/governance/assurance-presets.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @module sdk/governance/assurance-presets
+ *
+ * Supplies readable assurance starter bundles and observation-derived proposals
+ * without introducing privileged evaluation semantics.
+ */
+import { putAssuranceDeclaration, type AssuranceAssertionDefinition, type AssuranceBundleMutationReceipt, type AssuranceDeclarationBundle, type AssuranceEnforcement, type AssuranceEvaluationContext, type AssuranceScope } from "./assurance.js";
+/** Built-in project shapes that can acquire a quality contract in one command. */
+export declare const ASSURANCE_PRESET_IDS: readonly ["software-delivery", "research", "agent-evaluation", "operations"];
+/** Stable built-in assurance preset id. */
+export type AssurancePresetId = (typeof ASSURANCE_PRESET_IDS)[number];
+/** Readable preset bundle before or after application. */
+export interface AssurancePreset {
+    /** Stable preset id. */
+    id: AssurancePresetId;
+    /** Human-readable project shape. */
+    title: string;
+    /** Why the initial contract is useful. */
+    description: string;
+    /** Ordinary declarations that become editable workspace data. */
+    declarations: AssuranceDeclarationBundle;
+}
+/** One observe-level candidate produced from authoritative workspace state. */
+export interface AssuranceDerivedProposal {
+    /** Stable proposal id. */
+    id: string;
+    /** Population used to calculate the proposed threshold. */
+    population_size: number;
+    /** Scope applied while measuring. */
+    scope: AssuranceScope;
+    /** Observed value proposed as the initial ceiling. */
+    observed: number;
+    /** Ordinary declarations created only after explicit acceptance. */
+    declarations: AssuranceDeclarationBundle;
+}
+/** Materialize one built-in preset as ordinary declarations owned by a pm item. */
+export declare function createAssurancePreset(id: AssurancePresetId, ownerItemId: string): AssurancePreset;
+/** Apply one preset atomically; a second identical application is idempotent. */
+export declare function applyAssurancePreset(pmRoot: string, id: AssurancePresetId, ownerItemId: string, options?: {
+    author?: string;
+    message?: string;
+}): Promise<AssuranceBundleMutationReceipt>;
+/** Propose active-scope evidence ceilings from the record without persisting them. */
+export declare function deriveAssuranceProposals(context: AssuranceEvaluationContext, ownerItemId: string): Promise<AssuranceDerivedProposal[]>;
+/** Accept all derived proposals in one audited registry transaction. */
+export declare function acceptAssuranceProposals(pmRoot: string, proposals: readonly AssuranceDerivedProposal[], options?: {
+    author?: string;
+    message?: string;
+}): Promise<AssuranceBundleMutationReceipt>;
+/** Promote one assertion by exactly one enforcement level and audit the transition. */
+export declare function promoteAssuranceAssertion(pmRoot: string, definition: AssuranceAssertionDefinition, enforcement: Exclude<AssuranceEnforcement, "observe">, options?: {
+    author?: string;
+    message?: string;
+}): Promise<Awaited<ReturnType<typeof putAssuranceDeclaration>>>;

package/dist/sdk/governance/assurance-presets.js

@@ -0,0 +1,136 @@
+/**
+ * @module sdk/governance/assurance-presets
+ *
+ * Supplies readable assurance starter bundles and observation-derived proposals
+ * without introducing privileged evaluation semantics.
+ */
+
+!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]="05c29627-6763-5aee-8579-71e563a98780")}catch(e){}}();
+import { evaluateMeasurement, putAssuranceDeclaration, putAssuranceDeclarationBundle, } from "./assurance.js";
+/** Built-in project shapes that can acquire a quality contract in one command. */
+export const ASSURANCE_PRESET_IDS = [
+    "software-delivery",
+    "research",
+    "agent-evaluation",
+    "operations",
+];
+function assertion(id, measurementId, ownerItemId, ceiling, enforcement) {
+    return {
+        id,
+        measurement_id: measurementId,
+        owner_item_id: ownerItemId,
+        scope: { kind: "active" },
+        ceiling,
+        lifetime: "hold",
+        enforcement,
+        negative_control: {
+            cases: [
+                { observed: ceiling, expected: "pass" },
+                { observed: ceiling + 1, expected: "fail" },
+            ],
+        },
+    };
+}
+function evidencePreset(id, title, description, ownerItemId, links) {
+    const prefix = `preset-${id}`;
+    const measurements = links.map((link) => ({
+        id: `${prefix}-missing-${link}`,
+        description: `Active items missing ${link} evidence.`,
+        source: { kind: "links", link, state: "missing" },
+    }));
+    const assertions = measurements.map((measurement) => assertion(`${measurement.id}-zero`, measurement.id, ownerItemId, 0, "warn"));
+    return {
+        id,
+        title,
+        description,
+        declarations: {
+            measurements,
+            assertions,
+            gates: [
+                {
+                    id: `${prefix}-readiness`,
+                    description,
+                    assertion_ids: assertions.map((entry) => entry.id),
+                    triggers: ["ci", "scheduled"],
+                },
+            ],
+        },
+    };
+}
+/** Materialize one built-in preset as ordinary declarations owned by a pm item. */
+export function createAssurancePreset(id, ownerItemId) {
+    if (id === "software-delivery") {
+        return evidencePreset(id, "Software delivery", "Warn when active delivery work lacks executable tests or documentation.", ownerItemId, ["tests", "docs"]);
+    }
+    if (id === "research") {
+        return evidencePreset(id, "Research", "Warn when active research work lacks reproducibility files or documentation.", ownerItemId, ["files", "docs"]);
+    }
+    if (id === "agent-evaluation") {
+        return evidencePreset(id, "Agent evaluation", "Warn when active evaluation work lacks executable scenarios or recorded artifacts.", ownerItemId, ["tests", "files"]);
+    }
+    return evidencePreset(id, "Operations", "Warn when active operational work lacks runbook documentation or repair evidence.", ownerItemId, ["docs", "files"]);
+}
+/** Apply one preset atomically; a second identical application is idempotent. */
+export function applyAssurancePreset(pmRoot, id, ownerItemId, options = {}) {
+    return putAssuranceDeclarationBundle(pmRoot, createAssurancePreset(id, ownerItemId).declarations, options);
+}
+/** Propose active-scope evidence ceilings from the record without persisting them. */
+export async function deriveAssuranceProposals(context, ownerItemId) {
+    const terminalStatuses = new Set(context.terminal_statuses ?? ["closed", "canceled"]);
+    const activeContext = {
+        ...context,
+        items: context.items.filter((item) => !terminalStatuses.has(item.status)),
+    };
+    const proposals = await Promise.all(["files", "tests", "docs"].map(async (link) => {
+        const measurement = {
+            id: `derived-active-missing-${link}`,
+            description: `Observed active items missing ${link} evidence.`,
+            source: { kind: "links", link, state: "missing" },
+        };
+        const measured = await evaluateMeasurement(measurement, activeContext);
+        const observed = measured.value;
+        const derivedAssertion = assertion(`${measurement.id}-ceiling`, measurement.id, ownerItemId, observed, "observe");
+        const id = `active-missing-${link}`;
+        return {
+            id,
+            population_size: activeContext.items.length,
+            scope: { kind: "active" },
+            observed,
+            declarations: {
+                measurements: [measurement],
+                assertions: [derivedAssertion],
+                gates: [
+                    {
+                        id: `derived-${id}`,
+                        description: `Observe the accepted ${link} evidence baseline.`,
+                        assertion_ids: [derivedAssertion.id],
+                        triggers: ["ci", "scheduled"],
+                    },
+                ],
+            },
+        };
+    }));
+    return proposals;
+}
+/** Accept all derived proposals in one audited registry transaction. */
+export function acceptAssuranceProposals(pmRoot, proposals, options = {}) {
+    return putAssuranceDeclarationBundle(pmRoot, {
+        measurements: proposals.flatMap((proposal) => proposal.declarations.measurements),
+        assertions: proposals.flatMap((proposal) => proposal.declarations.assertions),
+        gates: proposals.flatMap((proposal) => proposal.declarations.gates),
+    }, options);
+}
+/** Promote one assertion by exactly one enforcement level and audit the transition. */
+export async function promoteAssuranceAssertion(pmRoot, definition, enforcement, options = {}) {
+    const expected = definition.enforcement === "observe" ? "warn" : "block";
+    if (definition.enforcement === "block" || enforcement !== expected) {
+        throw new TypeError(`assurance assertion ${definition.id} promotion must be ${definition.enforcement} -> ${expected}`);
+    }
+    return putAssuranceDeclaration(pmRoot, "assertion", { ...definition, enforcement }, {
+        ...options,
+        message: options.message ??
+            `Promote assurance assertion ${definition.id} from ${definition.enforcement} to ${enforcement}`,
+    });
+}
+//# sourceMappingURL=assurance-presets.js.map
+//# debugId=05c29627-6763-5aee-8579-71e563a98780

package/dist/sdk/governance/assurance-runtime.d.ts

@@ -11,6 +11,10 @@ export interface CreateAssuranceWorkspaceContextOptions {
     resolve_tree?: boolean;
     /** Provider resolvers keyed by stable provider id. */
     providers?: Readonly<Record<string, AssuranceProviderResolver>>;
+    /** Capabilities for host-provided resolvers that are not extension registrations. */
+    provider_capabilities?: AssuranceEvaluationContext["provider_capabilities"];
+    /** Gate trigger supplied to extension provider resolvers. */
+    trigger?: string;
 }
 /**
  * Build an assurance context from authoritative workspace data and public SDK