/**
 * Plan<StepRequirements>-family machine document (`plan-result-v3`) and the emit boundary.
 *
 * `emitOperationResolution` is the one place a plan-family command terminates:
 * it derives the outcome and exit code from the resolution with the shared
 * pure derivations, records completion semantics for telemetry, emits the
 * machine document, and projects the human render. No channel re-derives its
 * own account of what happened.
 */
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import { Verbosity } from "./cli-flags/index.js";
import { type SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
import { type CommandOutcomeSummary, type SourceKind, type SubjectType } from "./cli-runtime/index.js";
import { type OperationOutcome, type OperationResolution } from "@agentxm/workspace/transitions/planning";
import { Screen } from "./screen/index.js";
import type { TargetedUpdatePublicContext } from "@agentxm/workspace/resolution";
export declare const PLAN_RESULT_CONTRACT = "plan-result-v3";
export declare const AgentCoverageSchema: Schema.Struct<{
    readonly scope: Schema.Literals<readonly ["project", "user"]>;
    readonly agents: Schema.$Array<Schema.String>;
}>;
export type AgentCoverage = typeof AgentCoverageSchema.Type;
export declare const PlanResolutionResultSchema: Schema.Struct<{
    readonly contract: Schema.Literal<"plan-result-v3">;
    readonly outcome: Schema.Literals<readonly ["previewed", "applied", "no-op", "partial", "failed", "blocked", "cancelled", "interrupted"]>;
    readonly mode: Schema.Literals<readonly ["preview", "apply"]>;
    readonly planName: Schema.String;
    readonly planDescription: Schema.optional<Schema.String>;
    readonly candidateId: Schema.optional<Schema.String>;
    readonly message: Schema.optional<Schema.String>;
    readonly atomicity: Schema.Struct<{
        readonly declared: Schema.Literals<readonly ["closure-atomic", "non-rollbackable"]>;
        readonly applied: Schema.Literals<readonly ["closure-atomic", "non-rollbackable"]>;
    }>;
    readonly blocking: Schema.optional<Schema.Struct<{
        readonly class: Schema.Literals<readonly ["approval-required", "override-required", "precondition-unmet", "dependency-failed", "dependency-cycle", "stale-candidate", "policy-excluded", "resource-conflict", "external-blocked", "human-required", "operation-aborted"]>;
        readonly subject: Schema.String;
        readonly phase: Schema.Literals<readonly ["resolution", "planning", "preview", "confirmation", "validation", "apply", "restoration"]>;
        readonly detail: Schema.String;
        readonly causeCode: Schema.optional<Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>>;
        readonly reference: Schema.optional<Schema.String>;
        readonly escape: Schema.optional<Schema.Struct<{
            readonly description: Schema.String;
            readonly cmd: Schema.optional<Schema.String>;
            readonly url: Schema.optional<Schema.String>;
        }>>;
    }>>;
    readonly failure: Schema.optional<Schema.Struct<{
        readonly code: Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>;
        readonly message: Schema.String;
        readonly causes: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly _tag: Schema.String;
            readonly code: Schema.optional<Schema.String>;
            readonly message: Schema.String;
            readonly stack: Schema.optional<Schema.String>;
        }>>>;
    }>>;
    readonly interruption: Schema.optional<Schema.Struct<{
        readonly signal: Schema.Literals<readonly ["SIGINT", "SIGTERM"]>;
        readonly disposition: Schema.Literals<readonly ["restored", "retained", "unknown", "none"]>;
    }>>;
    readonly divergence: Schema.optional<Schema.Boolean>;
    readonly counts: Schema.Struct<{
        readonly total: Schema.Number;
        readonly planned: Schema.Number;
        readonly ready: Schema.Number;
        readonly committed: Schema.Number;
        readonly unchanged: Schema.Number;
        readonly failed: Schema.Number;
        readonly rolledBack: Schema.Number;
        readonly blocked: Schema.Number;
        readonly skipped: Schema.Number;
        readonly cancelled: Schema.Number;
        readonly interrupted: Schema.Number;
        readonly warnings: Schema.Number;
    }>;
    readonly units: Schema.$Array<Schema.Struct<{
        readonly id: Schema.String;
        readonly label: Schema.String;
        readonly state: Schema.Literals<readonly ["planned", "ready", "committed", "unchanged", "failed", "rolled-back", "blocked", "skipped", "cancelled", "interrupted"]>;
        readonly disposition: Schema.optional<Schema.Literals<readonly ["restored", "retained", "untouched", "unknown"]>>;
        readonly blocking: Schema.optional<Schema.Struct<{
            readonly class: Schema.Literals<readonly ["approval-required", "override-required", "precondition-unmet", "dependency-failed", "dependency-cycle", "stale-candidate", "policy-excluded", "resource-conflict", "external-blocked", "human-required", "operation-aborted"]>;
            readonly subject: Schema.String;
            readonly phase: Schema.Literals<readonly ["resolution", "planning", "preview", "confirmation", "validation", "apply", "restoration"]>;
            readonly detail: Schema.String;
            readonly causeCode: Schema.optional<Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>>;
            readonly reference: Schema.optional<Schema.String>;
            readonly escape: Schema.optional<Schema.Struct<{
                readonly description: Schema.String;
                readonly cmd: Schema.optional<Schema.String>;
                readonly url: Schema.optional<Schema.String>;
            }>>;
        }>>;
        readonly message: Schema.optional<Schema.String>;
        readonly warnings: Schema.optional<Schema.$Array<Schema.String>>;
        readonly code: Schema.optional<Schema.String>;
        readonly error: Schema.optional<Schema.Struct<{
            readonly code: Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>;
            readonly message: Schema.String;
            readonly causes: Schema.optional<Schema.$Array<Schema.Struct<{
                readonly _tag: Schema.String;
                readonly code: Schema.optional<Schema.String>;
                readonly message: Schema.String;
                readonly stack: Schema.optional<Schema.String>;
            }>>>;
        }>>;
        readonly artifact: Schema.optional<Schema.Struct<{
            readonly path: Schema.optional<Schema.String>;
            readonly scope: Schema.Literals<readonly ["project", "user"]>;
            readonly agents: Schema.optional<Schema.$Array<Schema.String>>;
            readonly version: Schema.optional<Schema.String>;
            readonly change: Schema.Literals<readonly ["created", "updated", "unchanged", "removed"]>;
            readonly mechanism: Schema.optional<Schema.Literals<readonly ["symlink", "copy"]>>;
            readonly previousVersion: Schema.optional<Schema.String>;
            readonly fileCount: Schema.optional<Schema.Number>;
            readonly targets: Schema.optional<Schema.$Array<Schema.Struct<{
                readonly path: Schema.String;
                readonly change: Schema.Literals<readonly ["created", "updated", "unchanged", "removed"]>;
                readonly agentIds: Schema.optional<Schema.$Array<Schema.String>>;
                readonly unitId: Schema.optional<Schema.String>;
                readonly owner: Schema.optional<Schema.String>;
                readonly entryName: Schema.optional<Schema.String>;
            }>>>;
            readonly references: Schema.optional<Schema.$Array<Schema.Struct<{
                readonly path: Schema.String;
                readonly state: Schema.Literals<readonly ["retained", "absent", "unknown"]>;
                readonly reason: Schema.String;
                readonly unitId: Schema.optional<Schema.String>;
                readonly owner: Schema.optional<Schema.String>;
            }>>>;
            readonly agentOutcomes: Schema.optional<Schema.$Array<Schema.Struct<{
                readonly extensionType: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
                readonly name: Schema.String;
                readonly agentId: Schema.String;
                readonly outcome: Schema.Literals<readonly ["projected", "current", "not-applicable", "unsupported", "blocked", "failed"]>;
                readonly reasonCode: Schema.String;
                readonly reason: Schema.String;
                readonly mechanism: Schema.optional<Schema.String>;
                readonly path: Schema.optional<Schema.String>;
            }>>>;
            readonly source: Schema.optional<Schema.Struct<{
                readonly type: Schema.String;
                readonly origin: Schema.String;
                readonly ref: Schema.optional<Schema.String>;
                readonly directory: Schema.optional<Schema.String>;
                readonly gitTreeHash: Schema.optional<Schema.String>;
            }>>;
            readonly managedRegions: Schema.optional<Schema.$Array<Schema.Struct<{
                readonly unitId: Schema.String;
                readonly path: Schema.String;
                readonly owner: Schema.String;
            }>>>;
            readonly packMembership: Schema.optional<Schema.Struct<{
                readonly pack: Schema.String;
                readonly members: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
                    readonly member: Schema.String;
                    readonly before: Schema.Null;
                    readonly after: Schema.String;
                }>, Schema.Struct<{
                    readonly member: Schema.String;
                    readonly before: Schema.String;
                    readonly after: Schema.Null;
                }>, Schema.Struct<{
                    readonly member: Schema.String;
                    readonly before: Schema.String;
                    readonly after: Schema.String;
                }>]>>;
            }>>;
            readonly registryLifecycle: Schema.optional<Schema.Struct<{
                readonly archival: Schema.optional<Schema.Struct<{
                    readonly archivedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                    readonly reason: Schema.optional<Schema.String>;
                }>>;
                readonly deprecation: Schema.optional<Schema.Union<readonly [Schema.Struct<{
                    readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                    readonly message: Schema.String;
                    readonly replacement: Schema.optional<Schema.Union<readonly [Schema.Struct<{
                        readonly status: Schema.Literal<"available">;
                        readonly fqn: Schema.String;
                    }>, Schema.Struct<{
                        readonly status: Schema.Literal<"unavailable">;
                        readonly fqn: Schema.optional<Schema.String>;
                    }>]>>;
                }>, Schema.Struct<{
                    readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                    readonly message: Schema.optional<Schema.String>;
                    readonly replacement: Schema.Union<readonly [Schema.Struct<{
                        readonly status: Schema.Literal<"available">;
                        readonly fqn: Schema.String;
                    }>, Schema.Struct<{
                        readonly status: Schema.Literal<"unavailable">;
                        readonly fqn: Schema.optional<Schema.String>;
                    }>]>;
                }>]>>;
            }>>;
            readonly sourceSwitch: Schema.optional<Schema.Struct<{
                readonly before: Schema.Struct<{
                    readonly family: Schema.Literals<readonly ["registry", "git", "path"]>;
                    readonly locator: Schema.String;
                    readonly resolution: Schema.String;
                    readonly treeIntegrity: Schema.String;
                }>;
                readonly after: Schema.Struct<{
                    readonly family: Schema.Literals<readonly ["registry", "git", "path"]>;
                    readonly locator: Schema.String;
                    readonly resolution: Schema.String;
                    readonly treeIntegrity: Schema.String;
                }>;
                readonly content: Schema.Literals<readonly ["equivalent", "changed"]>;
                readonly dependencies: Schema.Struct<{
                    readonly effect: Schema.Literals<readonly ["not-applicable", "unchanged", "changed"]>;
                    readonly added: Schema.$Array<Schema.String>;
                    readonly removed: Schema.$Array<Schema.String>;
                    readonly changed: Schema.$Array<Schema.String>;
                }>;
                readonly projections: Schema.Struct<{
                    readonly effect: Schema.Literal<"reconcile">;
                    readonly detail: Schema.String;
                }>;
                readonly guarantees: Schema.Struct<{
                    readonly gained: Schema.$Array<Schema.String>;
                    readonly lost: Schema.$Array<Schema.String>;
                }>;
                readonly packMembers: Schema.optional<Schema.$Array<Schema.Struct<{
                    readonly member: Schema.String;
                    readonly disposition: Schema.Literals<readonly ["added", "removed", "retained", "source-changed", "version-changed", "unchanged"]>;
                    readonly before: Schema.optional<Schema.Struct<{
                        readonly family: Schema.Literals<readonly ["registry", "git", "path", "workspace"]>;
                        readonly locator: Schema.String;
                        readonly resolution: Schema.String;
                    }>>;
                    readonly after: Schema.optional<Schema.Struct<{
                        readonly family: Schema.Literals<readonly ["registry", "git", "path", "workspace"]>;
                        readonly locator: Schema.String;
                        readonly resolution: Schema.String;
                    }>>;
                }>>>;
            }>>;
        }>>;
        readonly agentOutcomes: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly extensionType: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
            readonly name: Schema.String;
            readonly agentId: Schema.String;
            readonly outcome: Schema.Literals<readonly ["projected", "current", "not-applicable", "unsupported", "blocked", "failed"]>;
            readonly reasonCode: Schema.String;
            readonly reason: Schema.String;
            readonly mechanism: Schema.optional<Schema.String>;
            readonly path: Schema.optional<Schema.String>;
        }>>>;
        readonly registryLifecycle: Schema.optional<Schema.Struct<{
            readonly archival: Schema.optional<Schema.Struct<{
                readonly archivedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                readonly reason: Schema.optional<Schema.String>;
            }>>;
            readonly deprecation: Schema.optional<Schema.Union<readonly [Schema.Struct<{
                readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                readonly message: Schema.String;
                readonly replacement: Schema.optional<Schema.Union<readonly [Schema.Struct<{
                    readonly status: Schema.Literal<"available">;
                    readonly fqn: Schema.String;
                }>, Schema.Struct<{
                    readonly status: Schema.Literal<"unavailable">;
                    readonly fqn: Schema.optional<Schema.String>;
                }>]>>;
            }>, Schema.Struct<{
                readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                readonly message: Schema.optional<Schema.String>;
                readonly replacement: Schema.Union<readonly [Schema.Struct<{
                    readonly status: Schema.Literal<"available">;
                    readonly fqn: Schema.String;
                }>, Schema.Struct<{
                    readonly status: Schema.Literal<"unavailable">;
                    readonly fqn: Schema.optional<Schema.String>;
                }>]>;
            }>]>>;
        }>>;
        readonly links: Schema.optional<Schema.Struct<{
            readonly html: Schema.String;
        }>>;
    }>>;
    readonly footprint: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly path: Schema.String;
        readonly change: Schema.Literals<readonly ["created", "modified", "removed", "restored"]>;
    }>>>;
    readonly recovery: Schema.optional<Schema.Struct<{
        readonly retained: Schema.$Array<Schema.String>;
        readonly snapshotDir: Schema.optional<Schema.String>;
        readonly actions: Schema.$Array<Schema.Struct<{
            readonly description: Schema.String;
            readonly cmd: Schema.optional<Schema.String>;
            readonly url: Schema.optional<Schema.String>;
        }>>;
    }>>;
    readonly evaluatedAt: Schema.optional<Schema.String>;
    readonly holdbackCount: Schema.optional<Schema.Number>;
    readonly holdbacks: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly reason: Schema.Literal<"minimum-release-age">;
        readonly target: Schema.String;
        readonly dependencyPath: Schema.$Array<Schema.String>;
        readonly requestedRange: Schema.optional<Schema.String>;
        readonly currentVersion: Schema.optional<Schema.String>;
        readonly selectedVersion: Schema.optional<Schema.String>;
        readonly candidateVersion: Schema.String;
        readonly publishedAt: Schema.String;
        readonly eligibleAt: Schema.String;
        readonly minimumReleaseAgeSeconds: Schema.Number;
        readonly bypassCause: Schema.optional<Schema.Literals<readonly ["exclude", "ignore-flag"]>>;
        readonly exemptionScope: Schema.optional<Schema.Literals<readonly ["project", "user"]>>;
    }>>>;
    readonly releaseAgeBypassCount: Schema.optional<Schema.Number>;
    readonly releaseAgeBypasses: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly reason: Schema.Literal<"minimum-release-age">;
        readonly target: Schema.String;
        readonly dependencyPath: Schema.$Array<Schema.String>;
        readonly requestedRange: Schema.optional<Schema.String>;
        readonly currentVersion: Schema.optional<Schema.String>;
        readonly selectedVersion: Schema.optional<Schema.String>;
        readonly candidateVersion: Schema.String;
        readonly publishedAt: Schema.String;
        readonly eligibleAt: Schema.String;
        readonly minimumReleaseAgeSeconds: Schema.Number;
        readonly bypassCause: Schema.optional<Schema.Literals<readonly ["exclude", "ignore-flag"]>>;
        readonly exemptionScope: Schema.optional<Schema.Literals<readonly ["project", "user"]>>;
    }>>>;
    readonly imports: Schema.optional<Schema.Struct<{
        readonly imported: Schema.Number;
        readonly skipped: Schema.Number;
        readonly conflicting: Schema.Number;
    }>>;
    readonly preconditions: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.String;
        readonly label: Schema.String;
        readonly status: Schema.Literals<readonly ["met", "unmet"]>;
        readonly detail: Schema.optional<Schema.String>;
        readonly blockedOn: Schema.optional<Schema.Literal<"human">>;
        readonly command: Schema.optional<Schema.String>;
    }>>>;
    readonly riskConditions: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
        readonly level: Schema.Literal<"confirmable">;
        readonly id: Schema.String;
        readonly detail: Schema.String;
        readonly consent: Schema.optional<Schema.Literals<readonly ["preapprovable", "interactive-only"]>>;
    }>, Schema.Struct<{
        readonly level: Schema.Literal<"override-required">;
        readonly id: Schema.String;
        readonly policy: Schema.Literals<readonly ["ignore-version-constraints", "accept-warnings"]>;
        readonly requiredFlag: Schema.String;
        readonly detail: Schema.String;
    }>, Schema.Struct<{
        readonly level: Schema.Literal<"blocked">;
        readonly id: Schema.String;
        readonly detail: Schema.String;
        readonly errorCode: Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>;
    }>]>>>;
    readonly agentCoverage: Schema.optional<Schema.Struct<{
        readonly scope: Schema.Literals<readonly ["project", "user"]>;
        readonly agents: Schema.$Array<Schema.String>;
    }>>;
    readonly targetedUpdate: Schema.optional<Schema.Struct<{
        readonly target: Schema.Struct<{
            readonly type: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
            readonly name: Schema.String;
            readonly fqn: Schema.String;
        }>;
        readonly ownership: Schema.Literals<readonly ["absent", "direct-only", "pack-only", "combined"]>;
        readonly activation: Schema.Literals<readonly ["enabled", "disabled"]>;
        readonly authority: Schema.Literals<readonly ["direct", "pack-aware", "blocked"]>;
        readonly direct: Schema.optional<Schema.Struct<{
            readonly source: Schema.Literals<readonly ["bundled", "inline", "registry", "workspace"]>;
            readonly enabled: Schema.Boolean;
            readonly constraint: Schema.optional<Schema.String>;
        }>>;
        readonly packs: Schema.$Array<Schema.Struct<{
            readonly fqn: Schema.String;
            readonly configuredName: Schema.optional<Schema.String>;
            readonly source: Schema.optional<Schema.Literals<readonly ["registry", "workspace"]>>;
            readonly memberSource: Schema.Literals<readonly ["registry", "workspace"]>;
            readonly constraint: Schema.String;
            readonly enabled: Schema.Boolean;
        }>>;
        readonly effectiveConstraint: Schema.optional<Schema.String>;
        readonly memberClosure: Schema.$Array<Schema.Struct<{
            readonly type: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
            readonly name: Schema.String;
            readonly fqn: Schema.String;
        }>>;
        readonly effects: Schema.Struct<{
            readonly settings: Schema.Literals<readonly ["unchanged", "may-update"]>;
            readonly acceptedResolution: Schema.Literals<readonly ["unchanged", "may-update"]>;
            readonly canonical: Schema.Literals<readonly ["unchanged", "may-update"]>;
            readonly projection: Schema.Literals<readonly ["unchanged", "may-update"]>;
            readonly packRoot: Schema.Literals<readonly ["unchanged", "may-update"]>;
            readonly packManifest: Schema.Literals<readonly ["unchanged", "may-update"]>;
        }>;
        readonly relevantProblems: Schema.$Array<Schema.String>;
        readonly blocker: Schema.optional<Schema.Literals<readonly ["not-desired", "disabled", "pack-owned-constraint", "incomplete-graph", "constraint-conflict", "bundled-source", "source-authority", "stale-plan"]>>;
    }>>;
}>;
export type PlanResolutionResult = typeof PlanResolutionResultSchema.Type;
export declare const PlanResolutionDocumentSchema: Schema.Struct<{
    result: Schema.Struct<{
        readonly contract: Schema.Literal<"plan-result-v3">;
        readonly outcome: Schema.Literals<readonly ["previewed", "applied", "no-op", "partial", "failed", "blocked", "cancelled", "interrupted"]>;
        readonly mode: Schema.Literals<readonly ["preview", "apply"]>;
        readonly planName: Schema.String;
        readonly planDescription: Schema.optional<Schema.String>;
        readonly candidateId: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
        readonly atomicity: Schema.Struct<{
            readonly declared: Schema.Literals<readonly ["closure-atomic", "non-rollbackable"]>;
            readonly applied: Schema.Literals<readonly ["closure-atomic", "non-rollbackable"]>;
        }>;
        readonly blocking: Schema.optional<Schema.Struct<{
            readonly class: Schema.Literals<readonly ["approval-required", "override-required", "precondition-unmet", "dependency-failed", "dependency-cycle", "stale-candidate", "policy-excluded", "resource-conflict", "external-blocked", "human-required", "operation-aborted"]>;
            readonly subject: Schema.String;
            readonly phase: Schema.Literals<readonly ["resolution", "planning", "preview", "confirmation", "validation", "apply", "restoration"]>;
            readonly detail: Schema.String;
            readonly causeCode: Schema.optional<Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>>;
            readonly reference: Schema.optional<Schema.String>;
            readonly escape: Schema.optional<Schema.Struct<{
                readonly description: Schema.String;
                readonly cmd: Schema.optional<Schema.String>;
                readonly url: Schema.optional<Schema.String>;
            }>>;
        }>>;
        readonly failure: Schema.optional<Schema.Struct<{
            readonly code: Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>;
            readonly message: Schema.String;
            readonly causes: Schema.optional<Schema.$Array<Schema.Struct<{
                readonly _tag: Schema.String;
                readonly code: Schema.optional<Schema.String>;
                readonly message: Schema.String;
                readonly stack: Schema.optional<Schema.String>;
            }>>>;
        }>>;
        readonly interruption: Schema.optional<Schema.Struct<{
            readonly signal: Schema.Literals<readonly ["SIGINT", "SIGTERM"]>;
            readonly disposition: Schema.Literals<readonly ["restored", "retained", "unknown", "none"]>;
        }>>;
        readonly divergence: Schema.optional<Schema.Boolean>;
        readonly counts: Schema.Struct<{
            readonly total: Schema.Number;
            readonly planned: Schema.Number;
            readonly ready: Schema.Number;
            readonly committed: Schema.Number;
            readonly unchanged: Schema.Number;
            readonly failed: Schema.Number;
            readonly rolledBack: Schema.Number;
            readonly blocked: Schema.Number;
            readonly skipped: Schema.Number;
            readonly cancelled: Schema.Number;
            readonly interrupted: Schema.Number;
            readonly warnings: Schema.Number;
        }>;
        readonly units: Schema.$Array<Schema.Struct<{
            readonly id: Schema.String;
            readonly label: Schema.String;
            readonly state: Schema.Literals<readonly ["planned", "ready", "committed", "unchanged", "failed", "rolled-back", "blocked", "skipped", "cancelled", "interrupted"]>;
            readonly disposition: Schema.optional<Schema.Literals<readonly ["restored", "retained", "untouched", "unknown"]>>;
            readonly blocking: Schema.optional<Schema.Struct<{
                readonly class: Schema.Literals<readonly ["approval-required", "override-required", "precondition-unmet", "dependency-failed", "dependency-cycle", "stale-candidate", "policy-excluded", "resource-conflict", "external-blocked", "human-required", "operation-aborted"]>;
                readonly subject: Schema.String;
                readonly phase: Schema.Literals<readonly ["resolution", "planning", "preview", "confirmation", "validation", "apply", "restoration"]>;
                readonly detail: Schema.String;
                readonly causeCode: Schema.optional<Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>>;
                readonly reference: Schema.optional<Schema.String>;
                readonly escape: Schema.optional<Schema.Struct<{
                    readonly description: Schema.String;
                    readonly cmd: Schema.optional<Schema.String>;
                    readonly url: Schema.optional<Schema.String>;
                }>>;
            }>>;
            readonly message: Schema.optional<Schema.String>;
            readonly warnings: Schema.optional<Schema.$Array<Schema.String>>;
            readonly code: Schema.optional<Schema.String>;
            readonly error: Schema.optional<Schema.Struct<{
                readonly code: Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>;
                readonly message: Schema.String;
                readonly causes: Schema.optional<Schema.$Array<Schema.Struct<{
                    readonly _tag: Schema.String;
                    readonly code: Schema.optional<Schema.String>;
                    readonly message: Schema.String;
                    readonly stack: Schema.optional<Schema.String>;
                }>>>;
            }>>;
            readonly artifact: Schema.optional<Schema.Struct<{
                readonly path: Schema.optional<Schema.String>;
                readonly scope: Schema.Literals<readonly ["project", "user"]>;
                readonly agents: Schema.optional<Schema.$Array<Schema.String>>;
                readonly version: Schema.optional<Schema.String>;
                readonly change: Schema.Literals<readonly ["created", "updated", "unchanged", "removed"]>;
                readonly mechanism: Schema.optional<Schema.Literals<readonly ["symlink", "copy"]>>;
                readonly previousVersion: Schema.optional<Schema.String>;
                readonly fileCount: Schema.optional<Schema.Number>;
                readonly targets: Schema.optional<Schema.$Array<Schema.Struct<{
                    readonly path: Schema.String;
                    readonly change: Schema.Literals<readonly ["created", "updated", "unchanged", "removed"]>;
                    readonly agentIds: Schema.optional<Schema.$Array<Schema.String>>;
                    readonly unitId: Schema.optional<Schema.String>;
                    readonly owner: Schema.optional<Schema.String>;
                    readonly entryName: Schema.optional<Schema.String>;
                }>>>;
                readonly references: Schema.optional<Schema.$Array<Schema.Struct<{
                    readonly path: Schema.String;
                    readonly state: Schema.Literals<readonly ["retained", "absent", "unknown"]>;
                    readonly reason: Schema.String;
                    readonly unitId: Schema.optional<Schema.String>;
                    readonly owner: Schema.optional<Schema.String>;
                }>>>;
                readonly agentOutcomes: Schema.optional<Schema.$Array<Schema.Struct<{
                    readonly extensionType: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
                    readonly name: Schema.String;
                    readonly agentId: Schema.String;
                    readonly outcome: Schema.Literals<readonly ["projected", "current", "not-applicable", "unsupported", "blocked", "failed"]>;
                    readonly reasonCode: Schema.String;
                    readonly reason: Schema.String;
                    readonly mechanism: Schema.optional<Schema.String>;
                    readonly path: Schema.optional<Schema.String>;
                }>>>;
                readonly source: Schema.optional<Schema.Struct<{
                    readonly type: Schema.String;
                    readonly origin: Schema.String;
                    readonly ref: Schema.optional<Schema.String>;
                    readonly directory: Schema.optional<Schema.String>;
                    readonly gitTreeHash: Schema.optional<Schema.String>;
                }>>;
                readonly managedRegions: Schema.optional<Schema.$Array<Schema.Struct<{
                    readonly unitId: Schema.String;
                    readonly path: Schema.String;
                    readonly owner: Schema.String;
                }>>>;
                readonly packMembership: Schema.optional<Schema.Struct<{
                    readonly pack: Schema.String;
                    readonly members: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
                        readonly member: Schema.String;
                        readonly before: Schema.Null;
                        readonly after: Schema.String;
                    }>, Schema.Struct<{
                        readonly member: Schema.String;
                        readonly before: Schema.String;
                        readonly after: Schema.Null;
                    }>, Schema.Struct<{
                        readonly member: Schema.String;
                        readonly before: Schema.String;
                        readonly after: Schema.String;
                    }>]>>;
                }>>;
                readonly registryLifecycle: Schema.optional<Schema.Struct<{
                    readonly archival: Schema.optional<Schema.Struct<{
                        readonly archivedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                        readonly reason: Schema.optional<Schema.String>;
                    }>>;
                    readonly deprecation: Schema.optional<Schema.Union<readonly [Schema.Struct<{
                        readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                        readonly message: Schema.String;
                        readonly replacement: Schema.optional<Schema.Union<readonly [Schema.Struct<{
                            readonly status: Schema.Literal<"available">;
                            readonly fqn: Schema.String;
                        }>, Schema.Struct<{
                            readonly status: Schema.Literal<"unavailable">;
                            readonly fqn: Schema.optional<Schema.String>;
                        }>]>>;
                    }>, Schema.Struct<{
                        readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                        readonly message: Schema.optional<Schema.String>;
                        readonly replacement: Schema.Union<readonly [Schema.Struct<{
                            readonly status: Schema.Literal<"available">;
                            readonly fqn: Schema.String;
                        }>, Schema.Struct<{
                            readonly status: Schema.Literal<"unavailable">;
                            readonly fqn: Schema.optional<Schema.String>;
                        }>]>;
                    }>]>>;
                }>>;
                readonly sourceSwitch: Schema.optional<Schema.Struct<{
                    readonly before: Schema.Struct<{
                        readonly family: Schema.Literals<readonly ["registry", "git", "path"]>;
                        readonly locator: Schema.String;
                        readonly resolution: Schema.String;
                        readonly treeIntegrity: Schema.String;
                    }>;
                    readonly after: Schema.Struct<{
                        readonly family: Schema.Literals<readonly ["registry", "git", "path"]>;
                        readonly locator: Schema.String;
                        readonly resolution: Schema.String;
                        readonly treeIntegrity: Schema.String;
                    }>;
                    readonly content: Schema.Literals<readonly ["equivalent", "changed"]>;
                    readonly dependencies: Schema.Struct<{
                        readonly effect: Schema.Literals<readonly ["not-applicable", "unchanged", "changed"]>;
                        readonly added: Schema.$Array<Schema.String>;
                        readonly removed: Schema.$Array<Schema.String>;
                        readonly changed: Schema.$Array<Schema.String>;
                    }>;
                    readonly projections: Schema.Struct<{
                        readonly effect: Schema.Literal<"reconcile">;
                        readonly detail: Schema.String;
                    }>;
                    readonly guarantees: Schema.Struct<{
                        readonly gained: Schema.$Array<Schema.String>;
                        readonly lost: Schema.$Array<Schema.String>;
                    }>;
                    readonly packMembers: Schema.optional<Schema.$Array<Schema.Struct<{
                        readonly member: Schema.String;
                        readonly disposition: Schema.Literals<readonly ["added", "removed", "retained", "source-changed", "version-changed", "unchanged"]>;
                        readonly before: Schema.optional<Schema.Struct<{
                            readonly family: Schema.Literals<readonly ["registry", "git", "path", "workspace"]>;
                            readonly locator: Schema.String;
                            readonly resolution: Schema.String;
                        }>>;
                        readonly after: Schema.optional<Schema.Struct<{
                            readonly family: Schema.Literals<readonly ["registry", "git", "path", "workspace"]>;
                            readonly locator: Schema.String;
                            readonly resolution: Schema.String;
                        }>>;
                    }>>>;
                }>>;
            }>>;
            readonly agentOutcomes: Schema.optional<Schema.$Array<Schema.Struct<{
                readonly extensionType: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
                readonly name: Schema.String;
                readonly agentId: Schema.String;
                readonly outcome: Schema.Literals<readonly ["projected", "current", "not-applicable", "unsupported", "blocked", "failed"]>;
                readonly reasonCode: Schema.String;
                readonly reason: Schema.String;
                readonly mechanism: Schema.optional<Schema.String>;
                readonly path: Schema.optional<Schema.String>;
            }>>>;
            readonly registryLifecycle: Schema.optional<Schema.Struct<{
                readonly archival: Schema.optional<Schema.Struct<{
                    readonly archivedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                    readonly reason: Schema.optional<Schema.String>;
                }>>;
                readonly deprecation: Schema.optional<Schema.Union<readonly [Schema.Struct<{
                    readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                    readonly message: Schema.String;
                    readonly replacement: Schema.optional<Schema.Union<readonly [Schema.Struct<{
                        readonly status: Schema.Literal<"available">;
                        readonly fqn: Schema.String;
                    }>, Schema.Struct<{
                        readonly status: Schema.Literal<"unavailable">;
                        readonly fqn: Schema.optional<Schema.String>;
                    }>]>>;
                }>, Schema.Struct<{
                    readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
                    readonly message: Schema.optional<Schema.String>;
                    readonly replacement: Schema.Union<readonly [Schema.Struct<{
                        readonly status: Schema.Literal<"available">;
                        readonly fqn: Schema.String;
                    }>, Schema.Struct<{
                        readonly status: Schema.Literal<"unavailable">;
                        readonly fqn: Schema.optional<Schema.String>;
                    }>]>;
                }>]>>;
            }>>;
            readonly links: Schema.optional<Schema.Struct<{
                readonly html: Schema.String;
            }>>;
        }>>;
        readonly footprint: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly path: Schema.String;
            readonly change: Schema.Literals<readonly ["created", "modified", "removed", "restored"]>;
        }>>>;
        readonly recovery: Schema.optional<Schema.Struct<{
            readonly retained: Schema.$Array<Schema.String>;
            readonly snapshotDir: Schema.optional<Schema.String>;
            readonly actions: Schema.$Array<Schema.Struct<{
                readonly description: Schema.String;
                readonly cmd: Schema.optional<Schema.String>;
                readonly url: Schema.optional<Schema.String>;
            }>>;
        }>>;
        readonly evaluatedAt: Schema.optional<Schema.String>;
        readonly holdbackCount: Schema.optional<Schema.Number>;
        readonly holdbacks: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly reason: Schema.Literal<"minimum-release-age">;
            readonly target: Schema.String;
            readonly dependencyPath: Schema.$Array<Schema.String>;
            readonly requestedRange: Schema.optional<Schema.String>;
            readonly currentVersion: Schema.optional<Schema.String>;
            readonly selectedVersion: Schema.optional<Schema.String>;
            readonly candidateVersion: Schema.String;
            readonly publishedAt: Schema.String;
            readonly eligibleAt: Schema.String;
            readonly minimumReleaseAgeSeconds: Schema.Number;
            readonly bypassCause: Schema.optional<Schema.Literals<readonly ["exclude", "ignore-flag"]>>;
            readonly exemptionScope: Schema.optional<Schema.Literals<readonly ["project", "user"]>>;
        }>>>;
        readonly releaseAgeBypassCount: Schema.optional<Schema.Number>;
        readonly releaseAgeBypasses: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly reason: Schema.Literal<"minimum-release-age">;
            readonly target: Schema.String;
            readonly dependencyPath: Schema.$Array<Schema.String>;
            readonly requestedRange: Schema.optional<Schema.String>;
            readonly currentVersion: Schema.optional<Schema.String>;
            readonly selectedVersion: Schema.optional<Schema.String>;
            readonly candidateVersion: Schema.String;
            readonly publishedAt: Schema.String;
            readonly eligibleAt: Schema.String;
            readonly minimumReleaseAgeSeconds: Schema.Number;
            readonly bypassCause: Schema.optional<Schema.Literals<readonly ["exclude", "ignore-flag"]>>;
            readonly exemptionScope: Schema.optional<Schema.Literals<readonly ["project", "user"]>>;
        }>>>;
        readonly imports: Schema.optional<Schema.Struct<{
            readonly imported: Schema.Number;
            readonly skipped: Schema.Number;
            readonly conflicting: Schema.Number;
        }>>;
        readonly preconditions: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly id: Schema.String;
            readonly label: Schema.String;
            readonly status: Schema.Literals<readonly ["met", "unmet"]>;
            readonly detail: Schema.optional<Schema.String>;
            readonly blockedOn: Schema.optional<Schema.Literal<"human">>;
            readonly command: Schema.optional<Schema.String>;
        }>>>;
        readonly riskConditions: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
            readonly level: Schema.Literal<"confirmable">;
            readonly id: Schema.String;
            readonly detail: Schema.String;
            readonly consent: Schema.optional<Schema.Literals<readonly ["preapprovable", "interactive-only"]>>;
        }>, Schema.Struct<{
            readonly level: Schema.Literal<"override-required">;
            readonly id: Schema.String;
            readonly policy: Schema.Literals<readonly ["ignore-version-constraints", "accept-warnings"]>;
            readonly requiredFlag: Schema.String;
            readonly detail: Schema.String;
        }>, Schema.Struct<{
            readonly level: Schema.Literal<"blocked">;
            readonly id: Schema.String;
            readonly detail: Schema.String;
            readonly errorCode: Schema.Literals<readonly ["issues", "usage", "not_found", "auth", "forbidden", "conflict", "rate_limit", "network", "validation", "internal", "unavailable", "quota", "auth_required", "auth_expired", "auth_denied", "timeout"]>;
        }>]>>>;
        readonly agentCoverage: Schema.optional<Schema.Struct<{
            readonly scope: Schema.Literals<readonly ["project", "user"]>;
            readonly agents: Schema.$Array<Schema.String>;
        }>>;
        readonly targetedUpdate: Schema.optional<Schema.Struct<{
            readonly target: Schema.Struct<{
                readonly type: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
                readonly name: Schema.String;
                readonly fqn: Schema.String;
            }>;
            readonly ownership: Schema.Literals<readonly ["absent", "direct-only", "pack-only", "combined"]>;
            readonly activation: Schema.Literals<readonly ["enabled", "disabled"]>;
            readonly authority: Schema.Literals<readonly ["direct", "pack-aware", "blocked"]>;
            readonly direct: Schema.optional<Schema.Struct<{
                readonly source: Schema.Literals<readonly ["bundled", "inline", "registry", "workspace"]>;
                readonly enabled: Schema.Boolean;
                readonly constraint: Schema.optional<Schema.String>;
            }>>;
            readonly packs: Schema.$Array<Schema.Struct<{
                readonly fqn: Schema.String;
                readonly configuredName: Schema.optional<Schema.String>;
                readonly source: Schema.optional<Schema.Literals<readonly ["registry", "workspace"]>>;
                readonly memberSource: Schema.Literals<readonly ["registry", "workspace"]>;
                readonly constraint: Schema.String;
                readonly enabled: Schema.Boolean;
            }>>;
            readonly effectiveConstraint: Schema.optional<Schema.String>;
            readonly memberClosure: Schema.$Array<Schema.Struct<{
                readonly type: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "rule", "hook", "knowledge"]>;
                readonly name: Schema.String;
                readonly fqn: Schema.String;
            }>>;
            readonly effects: Schema.Struct<{
                readonly settings: Schema.Literals<readonly ["unchanged", "may-update"]>;
                readonly acceptedResolution: Schema.Literals<readonly ["unchanged", "may-update"]>;
                readonly canonical: Schema.Literals<readonly ["unchanged", "may-update"]>;
                readonly projection: Schema.Literals<readonly ["unchanged", "may-update"]>;
                readonly packRoot: Schema.Literals<readonly ["unchanged", "may-update"]>;
                readonly packManifest: Schema.Literals<readonly ["unchanged", "may-update"]>;
            }>;
            readonly relevantProblems: Schema.$Array<Schema.String>;
            readonly blocker: Schema.optional<Schema.Literals<readonly ["not-desired", "disabled", "pack-owned-constraint", "incomplete-graph", "constraint-conflict", "bundled-source", "source-authority", "stale-plan"]>>;
        }>>;
    }>;
}>;
export type PlanResolutionDocument = typeof PlanResolutionDocumentSchema.Type;
export interface PlanResolutionResultOptions {
    readonly verbose?: boolean;
    readonly debug?: boolean;
    readonly message?: string;
    readonly imports?: {
        readonly imported: number;
        readonly skipped: number;
        readonly conflicting: number;
    };
    readonly targetedUpdate?: TargetedUpdatePublicContext;
}
export declare const toPlanResolutionResult: (resolution: OperationResolution<unknown>, options?: PlanResolutionResultOptions) => PlanResolutionResult;
/** Telemetry completion summary projected from the same resolution. */
export declare const operationResolutionSummary: (resolution: OperationResolution<unknown>, context?: {
    readonly subjectType?: SubjectType;
    readonly sourceKind?: SourceKind;
}) => CommandOutcomeSummary;
export interface EmitOperationResolutionOptions {
    readonly suggestions?: ReadonlyArray<SuggestedAction>;
    readonly withoutSuggestions?: boolean;
    /** Overrides the derived human headline and is carried in the document. */
    readonly message?: string;
    readonly imports?: {
        readonly imported: number;
        readonly skipped: number;
        readonly conflicting: number;
    };
    readonly targetedUpdate?: TargetedUpdatePublicContext;
}
export interface EmittedOperationResolution {
    readonly outcome: OperationOutcome;
    readonly exitCode: number;
    readonly emitted: boolean;
}
/**
 * Terminate a plan-family invocation: derive outcome and exit, record
 * completion semantics, emit the machine document, and project the human
 * render. Returns the derivations so callers can act on them without
 * re-deriving.
 */
export declare const emitOperationResolution: (command: string, resolution: OperationResolution<unknown>, options?: EmitOperationResolutionOptions) => Effect.Effect<{
    outcome: "blocked" | "failed" | "cancelled" | "interrupted" | "previewed" | "applied" | "no-op" | "partial";
    exitCode: number;
    emitted: boolean;
}, never, Verbosity | Screen>;
/**
 * Terminate a plan-family invocation that planned nothing: an empty resolution
 * in the invocation's actual mode whose outcome derives `no-op`, with the
 * stated message.
 */
export declare const emitNoOpOperation: (command: string, args: {
    readonly mode: "preview" | "apply";
    readonly planName: string;
    readonly planDescription?: string;
    readonly message: string;
    readonly suggestions?: ReadonlyArray<SuggestedAction>;
    readonly withoutSuggestions?: boolean;
}) => Effect.Effect<{
    outcome: "blocked" | "failed" | "cancelled" | "interrupted" | "previewed" | "applied" | "no-op" | "partial";
    exitCode: number;
    emitted: boolean;
}, never, Verbosity | Screen>;
//# sourceMappingURL=operation-output.d.ts.map