@agentxm/workspace-operations 0.28.4-bootstrap.0

package/dist/src/plan/operation-resolution.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Operation resolution — the single truthful value every plan-family command
+ * terminates with.
+ *
+ * One `OperationResolution` is produced at every termination path of a
+ * plan-family invocation (preview, blocked, cancelled, applied, partial,
+ * failed, interrupted). The operation outcome is a pure derivation over the
+ * unit terminal multiset and the operation-level events the value carries, and
+ * the exit code is a pure mapping from that outcome. Every channel — machine
+ * document, human render, telemetry — projects this value; none re-derives its
+ * own account of what happened.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import type { OperationErrorCategory, StepFailure } from "./errors.js";
+import type { ReleaseAgeOperationEvidence } from "@agentxm/registry-protocol/unstable/registry/release-age-policy";
+import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
+import type { BlockingClass, ExecutedPlan, Job, JobStepArtifact, OperationPrecondition, OperationPresentation, PlanRiskCondition, RegistryLifecycleEvidence } from "./plan.js";
+import type { ConfiguredAgentOutcome } from "@agentxm/workspace-state";
+/**
+ * Canonical unit states. `planned` and `ready` are pre-terminal and appear only
+ * in preview-mode and not-executed resolutions; the rest are terminal.
+ * Warnings annotate a state and are never a state of their own.
+ */
+export declare const UnitStateSchema: Schema.Literals<readonly ["planned", "ready", "committed", "unchanged", "failed", "rolled-back", "blocked", "skipped", "cancelled", "interrupted"]>;
+export type UnitState = typeof UnitStateSchema.Type;
+/** Lifecycle phase in which an operation event (blocking, waiting) occurred. */
+export declare const OperationPhaseSchema: Schema.Literals<readonly ["planning", "preview", "confirmation", "validation", "apply", "restoration"]>;
+export type OperationPhase = typeof OperationPhaseSchema.Type;
+/** Canonical operation terminal outcomes. */
+export declare const OperationOutcomeSchema: Schema.Literals<readonly ["previewed", "applied", "no-op", "partial", "failed", "blocked", "cancelled", "interrupted"]>;
+export type OperationOutcome = typeof OperationOutcomeSchema.Type;
+/** Atomicity class that a closure declares and that an execution applies. */
+export declare const AtomicityClassSchema: Schema.Literals<readonly ["closure-atomic", "non-rollbackable"]>;
+export type AtomicityClass = typeof AtomicityClassSchema.Type;
+/** Post-termination disposition of one unit's durable effects. */
+export declare const UnitDispositionSchema: Schema.Literals<readonly ["restored", "retained", "untouched", "unknown"]>;
+export type UnitDisposition = typeof UnitDispositionSchema.Type;
+/**
+ * A typed blocking condition: what class of condition prevented work, which
+ * subject it blocked, in which phase it was determined, and — where one exists
+ * — the machine-readable escape that resolves it.
+ */
+export interface OperationBlock {
+    readonly class: BlockingClass;
+    readonly subject: string;
+    readonly phase: OperationPhase;
+    readonly detail: string;
+    /**
+     * Cause class carried for blocking classes whose exit is not pinned by the
+     * class alone (`precondition-unmet`, `external-blocked`).
+     */
+    readonly causeCode?: OperationErrorCategory;
+    /** Machine-readable reference to what blocked the subject. */
+    readonly reference?: string;
+    readonly escape?: SuggestedAction;
+}
+export interface ResolvedUnit<Output = never> {
+    /** Stable identity: the planned step key where one exists, else the label. */
+    readonly id: string;
+    readonly label: string;
+    readonly state: UnitState;
+    /** Present on units of a failed or interrupted closure. */
+    readonly disposition?: UnitDisposition;
+    /** Present exactly when `state` is `blocked`. */
+    readonly blocking?: OperationBlock;
+    readonly message?: string;
+    /** Annotations on the state, never a state of their own. */
+    readonly warnings?: ReadonlyArray<string>;
+    readonly error?: StepFailure;
+    readonly artifact?: JobStepArtifact;
+    readonly agentOutcomes?: ReadonlyArray<ConfiguredAgentOutcome>;
+    readonly registryLifecycle?: RegistryLifecycleEvidence;
+    readonly links?: {
+        readonly html: string;
+    };
+    readonly output?: Output;
+}
+export interface OperationInterruption {
+    readonly signal: "SIGINT" | "SIGTERM";
+    /**
+     * Durable-state disposition of attempted work at the stopping point:
+     * `restored` when the closure rolled it back, `retained` when settled
+     * commits stand, `unknown` when a started unit's settlement was not
+     * observed, and `none` when nothing was attempted.
+     */
+    readonly disposition: "restored" | "retained" | "unknown" | "none";
+}
+/** One observed durable change or restoration. */
+export interface OperationFootprintEntry {
+    readonly path: string;
+    readonly change: "created" | "modified" | "removed" | "restored";
+}
+/**
+ * Machine-readable recovery content accompanying a `failed`, `partial`, or
+ * `interrupted` outcome: what durable state was retained rather than restored
+ * and what action resolves it. It never blocks a later invocation — the next
+ * mutation converges from the current workspace state.
+ */
+export interface OperationRecovery {
+    readonly retained: ReadonlyArray<string>;
+    /** OS-temporary directory preserving pre-change snapshots, when it survives. */
+    readonly snapshotDir?: string;
+    readonly actions: ReadonlyArray<SuggestedAction>;
+}
+export interface OperationAtomicity {
+    /** The class the operation's closures declared. */
+    readonly declared: AtomicityClass;
+    /**
+     * The class that actually applied to durable effects: `closure-atomic`
+     * when effects were fully restored or never made; `non-rollbackable` when
+     * effects were retained, by design or because restoration failed.
+     */
+    readonly applied: AtomicityClass;
+}
+export interface OperationResolution<Output = never> {
+    readonly _tag: "OperationResolution";
+    readonly name: string;
+    readonly description: Option.Option<string>;
+    readonly mode: "preview" | "apply";
+    readonly candidateId?: string;
+    readonly atomicity: OperationAtomicity;
+    readonly units: ReadonlyArray<ResolvedUnit<Output>>;
+    /** The user declined a required confirmation before any mutation. */
+    readonly declined?: boolean;
+    /** Operation-level typed blocking; nothing was attempted. */
+    readonly blocking?: OperationBlock;
+    /** Operation-level failure cause, carrying the cause class for the exit. */
+    readonly failure?: StepFailure;
+    readonly interruption?: OperationInterruption;
+    /** A flag-requested divergence check found divergence on a preview. */
+    readonly divergence?: boolean;
+    /** Observed durable footprint reported by the mutation layers. */
+    readonly footprint?: ReadonlyArray<OperationFootprintEntry>;
+    readonly recovery?: OperationRecovery;
+    readonly presentation?: OperationPresentation;
+    readonly releaseAge?: ReleaseAgeOperationEvidence;
+    readonly preconditions?: ReadonlyArray<OperationPrecondition>;
+    readonly riskConditions?: ReadonlyArray<PlanRiskCondition>;
+    readonly suggestions?: ReadonlyArray<SuggestedAction>;
+}
+export interface UnitStateCounts {
+    readonly total: number;
+    readonly planned: number;
+    readonly ready: number;
+    readonly committed: number;
+    readonly unchanged: number;
+    readonly failed: number;
+    readonly rolledBack: number;
+    readonly blocked: number;
+    readonly skipped: number;
+    readonly cancelled: number;
+    readonly interrupted: number;
+    /** Annotation count, outside the state partition. */
+    readonly warnings: number;
+}
+export declare const countUnitStates: (units: ReadonlyArray<ResolvedUnit<unknown>>) => UnitStateCounts;
+/**
+ * The operation outcome, derived — never decided — from the resolution's
+ * operation-level events and its unit terminal multiset:
+ *
+ * - an external termination request resolves `interrupted`;
+ * - a typed blocking condition that prevented execution resolves `blocked`;
+ * - a declined confirmation resolves `cancelled`;
+ * - preview mode with planned units resolves `previewed`;
+ * - an empty preview resolves `no-op`;
+ * - otherwise the multiset decides: restored work is `failed` (with its
+ *   rollback report), surviving commits plus failures are `partial`, commits
+ *   alone are `applied`, and zero state-changing effects are `no-op`.
+ */
+export declare const deriveOperationOutcome: (resolution: OperationResolution<unknown>) => OperationOutcome;
+export declare const unitIdOf: (step: {
+    readonly key?: string;
+    readonly label: string;
+}) => string;
+/** Units of a plan that was not executed: planned readiness, typed blocking. */
+export declare const plannedUnits: <Requirements, Output>(jobs: ReadonlyArray<Job<Requirements, Output>>) => ReadonlyArray<ResolvedUnit<Output>>;
+/**
+ * Units of an executed plan. `restored: true` marks the closure-atomic
+ * failure path where every committed effect was rolled back.
+ */
+export declare const executedUnits: <Output>(executed: ExecutedPlan<Output>, options?: {
+    readonly restored?: boolean;
+}) => ReadonlyArray<ResolvedUnit<Output>>;
+/**
+ * Stable-identity ordering for machine documents. Code-unit comparison, not
+ * locale collation, so the order is identical on every host.
+ */
+export declare const unitsByStableIdentity: <Output>(units: ReadonlyArray<ResolvedUnit<Output>>) => ReadonlyArray<ResolvedUnit<Output>>;
+export interface MakeOperationResolutionArgs<Output> {
+    readonly name: string;
+    readonly description: Option.Option<string>;
+    readonly mode: "preview" | "apply";
+    readonly atomicity: OperationAtomicity;
+    readonly units: ReadonlyArray<ResolvedUnit<Output>>;
+    readonly candidateId?: string | undefined;
+    readonly declined?: boolean | undefined;
+    readonly blocking?: OperationBlock | undefined;
+    readonly failure?: StepFailure | undefined;
+    readonly interruption?: OperationInterruption | undefined;
+    readonly divergence?: boolean | undefined;
+    readonly footprint?: ReadonlyArray<OperationFootprintEntry> | undefined;
+    readonly recovery?: OperationRecovery | undefined;
+    readonly presentation?: OperationPresentation | undefined;
+    readonly releaseAge?: ReleaseAgeOperationEvidence | undefined;
+    readonly preconditions?: ReadonlyArray<OperationPrecondition> | undefined;
+    readonly riskConditions?: ReadonlyArray<PlanRiskCondition> | undefined;
+    readonly suggestions?: ReadonlyArray<SuggestedAction> | undefined;
+}
+export declare const makeOperationResolution: <Output = never>(args: MakeOperationResolutionArgs<Output>) => OperationResolution<Output>;
+/** The atomicity class a plan declares; local plans default closure-atomic. */
+export declare const declaredAtomicity: (plan: {
+    readonly executionCapabilities?: {
+        readonly rollback: "local-atomic" | "non-rollbackable";
+    };
+}) => AtomicityClass;
+//# sourceMappingURL=operation-resolution.d.ts.map

package/dist/src/plan/operation-resolution.js

@@ -0,0 +1,324 @@
+/**
+ * Operation resolution — the single truthful value every plan-family command
+ * terminates with.
+ *
+ * One `OperationResolution` is produced at every termination path of a
+ * plan-family invocation (preview, blocked, cancelled, applied, partial,
+ * failed, interrupted). The operation outcome is a pure derivation over the
+ * unit terminal multiset and the operation-level events the value carries, and
+ * the exit code is a pure mapping from that outcome. Every channel — machine
+ * document, human render, telemetry — projects this value; none re-derives its
+ * own account of what happened.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+// -----------------------------------------------------------------------------
+// Canonical vocabulary
+// -----------------------------------------------------------------------------
+/**
+ * Canonical unit states. `planned` and `ready` are pre-terminal and appear only
+ * in preview-mode and not-executed resolutions; the rest are terminal.
+ * Warnings annotate a state and are never a state of their own.
+ */
+export const UnitStateSchema = Schema.Literals([
+    "planned",
+    "ready",
+    "committed",
+    "unchanged",
+    "failed",
+    "rolled-back",
+    "blocked",
+    "skipped",
+    "cancelled",
+    // Started but not settled when the operation stopped; the disposition
+    // carries the durable-effect fact (restored, retained, or unknown).
+    "interrupted",
+]).annotate({
+    identifier: "UnitState",
+    title: "Unit State",
+    description: "Canonical lifecycle state of one unit of work.",
+});
+/** Lifecycle phase in which an operation event (blocking, waiting) occurred. */
+export const OperationPhaseSchema = Schema.Literals([
+    "planning",
+    "preview",
+    "confirmation",
+    "validation",
+    "apply",
+    "restoration",
+]).annotate({
+    identifier: "OperationPhase",
+    title: "Operation Phase",
+    description: "Lifecycle phase of a plan-family operation.",
+});
+/** Canonical operation terminal outcomes. */
+export const OperationOutcomeSchema = Schema.Literals([
+    "previewed",
+    "applied",
+    "no-op",
+    "partial",
+    "failed",
+    "blocked",
+    "cancelled",
+    "interrupted",
+]).annotate({
+    identifier: "OperationOutcome",
+    title: "Operation Outcome",
+    description: "Canonical terminal outcome of a plan-family operation.",
+});
+/** Atomicity class that a closure declares and that an execution applies. */
+export const AtomicityClassSchema = Schema.Literals([
+    "closure-atomic",
+    "non-rollbackable",
+]).annotate({
+    identifier: "AtomicityClass",
+    title: "Atomicity Class",
+    description: "Failure-atomicity class of an operation's durable effects.",
+});
+/** Post-termination disposition of one unit's durable effects. */
+export const UnitDispositionSchema = Schema.Literals([
+    "restored",
+    "retained",
+    "untouched",
+    // Settlement was not observed before the operation stopped: the unit's
+    // durable effects may or may not exist. Only evidenced states are reported;
+    // unknown is the evidenced absence of settlement, never a guess.
+    "unknown",
+]).annotate({
+    identifier: "UnitDisposition",
+    title: "Unit Disposition",
+    description: "What became of a unit's durable effects after termination.",
+});
+export const countUnitStates = (units) => {
+    let planned = 0;
+    let ready = 0;
+    let committed = 0;
+    let unchanged = 0;
+    let failed = 0;
+    let rolledBack = 0;
+    let blocked = 0;
+    let skipped = 0;
+    let cancelled = 0;
+    let interrupted = 0;
+    let warnings = 0;
+    for (const unit of units) {
+        warnings += unit.warnings?.length ?? 0;
+        switch (unit.state) {
+            case "planned":
+                planned += 1;
+                break;
+            case "ready":
+                ready += 1;
+                break;
+            case "committed":
+                committed += 1;
+                break;
+            case "unchanged":
+                unchanged += 1;
+                break;
+            case "failed":
+                failed += 1;
+                break;
+            case "rolled-back":
+                rolledBack += 1;
+                break;
+            case "blocked":
+                blocked += 1;
+                break;
+            case "skipped":
+                skipped += 1;
+                break;
+            case "cancelled":
+                cancelled += 1;
+                break;
+            case "interrupted":
+                interrupted += 1;
+                break;
+        }
+    }
+    return {
+        total: units.length,
+        planned,
+        ready,
+        committed,
+        unchanged,
+        failed,
+        rolledBack,
+        blocked,
+        skipped,
+        cancelled,
+        interrupted,
+        warnings,
+    };
+};
+/**
+ * The operation outcome, derived — never decided — from the resolution's
+ * operation-level events and its unit terminal multiset:
+ *
+ * - an external termination request resolves `interrupted`;
+ * - a typed blocking condition that prevented execution resolves `blocked`;
+ * - a declined confirmation resolves `cancelled`;
+ * - preview mode with planned units resolves `previewed`;
+ * - an empty preview resolves `no-op`;
+ * - otherwise the multiset decides: restored work is `failed` (with its
+ *   rollback report), surviving commits plus failures are `partial`, commits
+ *   alone are `applied`, and zero state-changing effects are `no-op`.
+ */
+export const deriveOperationOutcome = (resolution) => {
+    if (resolution.interruption !== undefined)
+        return "interrupted";
+    if (resolution.blocking !== undefined)
+        return "blocked";
+    if (resolution.declined === true)
+        return "cancelled";
+    if (resolution.mode === "preview" && resolution.units.length > 0)
+        return "previewed";
+    const counts = countUnitStates(resolution.units);
+    if (counts.rolledBack > 0)
+        return "failed";
+    const attemptedFailures = counts.failed + counts.blocked;
+    const operationFailed = resolution.failure !== undefined;
+    if (counts.committed > 0) {
+        return attemptedFailures > 0 || operationFailed ? "partial" : "applied";
+    }
+    if (attemptedFailures > 0 || operationFailed)
+        return "failed";
+    return "no-op";
+};
+// -----------------------------------------------------------------------------
+// Unit construction from plan machinery
+// -----------------------------------------------------------------------------
+export const unitIdOf = (step) => step.key ?? step.label;
+/** Units of a plan that was not executed: planned readiness, typed blocking. */
+export const plannedUnits = (jobs) => jobs.flatMap((job) => job.steps.map((step) => {
+    const base = {
+        id: unitIdOf(step),
+        label: step.label,
+        ...(step.artifact === undefined ? {} : { artifact: step.artifact }),
+        ...(step.agentOutcomes === undefined ? {} : { agentOutcomes: step.agentOutcomes }),
+        ...(step.registryLifecycle === undefined
+            ? {}
+            : { registryLifecycle: step.registryLifecycle }),
+    };
+    switch (step.readiness) {
+        case "ready":
+            return {
+                ...base,
+                state: "ready",
+                ...(step.message === undefined || step.message.length === 0
+                    ? {}
+                    : { message: step.message }),
+            };
+        case "warn":
+            return { ...base, state: "ready", warnings: [step.warnMessage] };
+        case "error":
+            return {
+                ...base,
+                state: "blocked",
+                message: step.errorMessage,
+                blocking: {
+                    class: "precondition-unmet",
+                    subject: unitIdOf(step),
+                    phase: "planning",
+                    detail: step.errorMessage,
+                    ...(step.blockingConditionIds !== undefined && step.blockingConditionIds.length > 0
+                        ? { reference: step.blockingConditionIds[0] }
+                        : {}),
+                },
+            };
+    }
+}));
+/**
+ * Units of an executed plan. `restored: true` marks the closure-atomic
+ * failure path where every committed effect was rolled back.
+ */
+export const executedUnits = (executed, options) => executed.jobs.flatMap((job) => job.steps.map((step) => {
+    const base = {
+        id: unitIdOf(step),
+        label: step.label,
+        ...(step.agentOutcomes === undefined ? {} : { agentOutcomes: step.agentOutcomes }),
+        ...(step.registryLifecycle === undefined
+            ? {}
+            : { registryLifecycle: step.registryLifecycle }),
+    };
+    if (step.result.result === "success") {
+        const success = {
+            ...base,
+            ...(step.result.message.length === 0 ? {} : { message: step.result.message }),
+            ...(step.result.warnings !== undefined && step.result.warnings.length > 0
+                ? { warnings: step.result.warnings }
+                : {}),
+            ...(step.result.artifact === undefined ? {} : { artifact: step.result.artifact }),
+            ...(step.result.links === undefined ? {} : { links: step.result.links }),
+            ...(step.result.output === undefined ? {} : { output: step.result.output }),
+        };
+        if (step.result.disposition === "skipped") {
+            return { ...success, state: "skipped" };
+        }
+        if (step.result.disposition === "unchanged" ||
+            step.result.artifact?.change === "unchanged") {
+            return { ...success, state: "unchanged" };
+        }
+        if (options?.restored === true) {
+            return { ...success, state: "rolled-back", disposition: "restored" };
+        }
+        return { ...success, state: "committed" };
+    }
+    const failureBase = {
+        ...base,
+        message: step.result.message,
+        error: step.result.error,
+    };
+    const blocking = step.result.blocking;
+    if (blocking !== undefined) {
+        return {
+            ...failureBase,
+            state: "blocked",
+            ...(options?.restored === true ? { disposition: "untouched" } : {}),
+            blocking: {
+                class: blocking.class,
+                subject: unitIdOf(step),
+                phase: "apply",
+                detail: step.result.message,
+                ...(blocking.reference === undefined ? {} : { reference: blocking.reference }),
+            },
+        };
+    }
+    return {
+        ...failureBase,
+        state: "failed",
+        ...(options?.restored === true ? { disposition: "restored" } : {}),
+    };
+}));
+/**
+ * Stable-identity ordering for machine documents. Code-unit comparison, not
+ * locale collation, so the order is identical on every host.
+ */
+export const unitsByStableIdentity = (units) => [...units].sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+export const makeOperationResolution = (args) => ({
+    _tag: "OperationResolution",
+    name: args.name,
+    description: args.description,
+    mode: args.mode,
+    atomicity: args.atomicity,
+    units: args.units,
+    ...(args.candidateId === undefined ? {} : { candidateId: args.candidateId }),
+    ...(args.declined === undefined ? {} : { declined: args.declined }),
+    ...(args.blocking === undefined ? {} : { blocking: args.blocking }),
+    ...(args.failure === undefined ? {} : { failure: args.failure }),
+    ...(args.interruption === undefined ? {} : { interruption: args.interruption }),
+    ...(args.divergence === undefined ? {} : { divergence: args.divergence }),
+    ...(args.footprint === undefined ? {} : { footprint: args.footprint }),
+    ...(args.recovery === undefined ? {} : { recovery: args.recovery }),
+    ...(args.presentation === undefined ? {} : { presentation: args.presentation }),
+    ...(args.releaseAge === undefined ? {} : { releaseAge: args.releaseAge }),
+    ...(args.preconditions === undefined ? {} : { preconditions: args.preconditions }),
+    ...(args.riskConditions === undefined ? {} : { riskConditions: args.riskConditions }),
+    ...(args.suggestions === undefined ? {} : { suggestions: args.suggestions }),
+});
+/** The atomicity class a plan declares; local plans default closure-atomic. */
+export const declaredAtomicity = (plan) => plan.executionCapabilities?.rollback === "non-rollbackable"
+    ? "non-rollbackable"
+    : "closure-atomic";
+//# sourceMappingURL=operation-resolution.js.map

package/dist/src/plan/plan-execution.d.ts

@@ -0,0 +1,75 @@
+import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
+import type { PlanPolicyId } from "./plan.js";
+import type { ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
+export interface ConfiguredAgentOperation {
+    readonly extensionType: ExtensionType;
+    readonly name: string;
+    readonly plannedState: "enabled" | "disabled" | "absent";
+}
+export type ConfirmationRecoveryValue = {
+    readonly _tag: "Public";
+    readonly value: string;
+} | {
+    readonly _tag: "Protected";
+} | {
+    readonly _tag: "Unclassified";
+};
+export type ConfirmationRecoveryArgument = {
+    readonly _tag: "Option";
+    readonly flag: string;
+    readonly value: ConfirmationRecoveryValue;
+} | {
+    readonly _tag: "Positional";
+    readonly value: ConfirmationRecoveryValue;
+} | {
+    readonly _tag: "Switch";
+    readonly flag: string;
+    readonly enabled: boolean;
+};
+export interface ConfirmationRecovery {
+    readonly command: ReadonlyArray<string>;
+    readonly arguments: ReadonlyArray<ConfirmationRecoveryArgument>;
+}
+export type PlanExecutionRequest = {
+    readonly mode: "preview";
+} | {
+    readonly mode: "apply";
+    readonly confirmableRiskApproval: "prompt-if-interactive" | "preapproved";
+    readonly acceptedPolicies: ReadonlySet<PlanPolicyId>;
+};
+/** Invocation-scoped policy input plus safe replay metadata for approval recovery. */
+export type PlanExecution = {
+    readonly request: {
+        readonly mode: "preview";
+    };
+    readonly configuredAgentOperations?: ReadonlyArray<ConfiguredAgentOperation>;
+} | {
+    readonly request: Extract<PlanExecutionRequest, {
+        readonly mode: "apply";
+    }>;
+    readonly approvalRecovery: ConfirmationRecovery;
+    readonly configuredAgentOperations?: ReadonlyArray<ConfiguredAgentOperation>;
+};
+export declare const previewPlanExecution: PlanExecution;
+export declare const applyPlanExecution: (options: {
+    readonly approval: "prompt-if-interactive" | "preapproved";
+    readonly acceptedPolicies?: ReadonlySet<PlanPolicyId>;
+    readonly recovery: ConfirmationRecovery;
+    readonly configuredAgentOperations?: ReadonlyArray<ConfiguredAgentOperation>;
+}) => PlanExecution;
+export declare const preapprovedPlanExecution: PlanExecution;
+export declare const promptablePlanExecution: (recovery: ConfirmationRecovery, acceptedPolicies?: ReadonlySet<PlanPolicyId>) => PlanExecution;
+export declare const publicRecoveryValue: (value: string) => ConfirmationRecoveryValue;
+export declare const protectedRecoveryValue: () => ConfirmationRecoveryValue;
+export declare const unclassifiedRecoveryValue: () => ConfirmationRecoveryValue;
+export declare const credentialFreeLocatorRecoveryValue: (value: string) => ConfirmationRecoveryValue;
+export declare const recoveryOption: (flag: string, value: ConfirmationRecoveryValue) => ConfirmationRecoveryArgument;
+export declare const recoveryPositional: (value: ConfirmationRecoveryValue) => ConfirmationRecoveryArgument;
+export declare const recoverySwitch: (flag: string, enabled: boolean) => ConfirmationRecoveryArgument;
+export declare const renderConfirmationRecoveryCommand: (recovery: ConfirmationRecovery, options?: {
+    readonly includeYes?: boolean;
+    readonly additionalSwitches?: ReadonlyArray<string>;
+}) => string | undefined;
+export declare const namedPolicyRecoverySuggestions: (recovery: ConfirmationRecovery, requiredFlags: ReadonlyArray<string>) => ReadonlyArray<SuggestedAction>;
+export declare const confirmationRecoverySuggestions: (recovery: ConfirmationRecovery) => ReadonlyArray<SuggestedAction>;
+//# sourceMappingURL=plan-execution.d.ts.map