@kisev/skills-opencode 1.1.1 → 2.0.0

package/dist/index.d.ts

@@ -1,29 +1,14 @@
-import backgroundAttempts, { type BackgroundAttemptsOptions } from "./plugins/background-attempts.js";
-import goalLoop, { type GoalLoopOptions } from "./plugins/goal-loop.js";
-import scheduler, { type SchedulerOptions } from "./plugins/schedule.js";
-import autonomyPolicy, { type AutonomyPolicyOptions } from "./plugins/autonomy-policy.js";
+import { type PluginInput } from "@opencode-ai/plugin";
 import rulesInjector, { type RulesInjectorOptions } from "./plugins/rules-injector.js";
 import rtk, { type RtkOptions } from "./plugins/rtk.js";
 import zedBell, { type ZedBellOptions } from "./plugins/zed-bell.js";
-import zedClickablePaths, { type ZedClickablePathsOptions } from "./plugins/zed-clickable-paths.js";
-export { COMMAND_REGISTRY, renderCommand } from "./registry.js";
-export { CATEGORIES, resolveRouting, RoutingGate } from "./routing.js";
-export { AgentProfileError, FIXED_AGENT_ROLES, applyAgentProfileChange, availableModels, availableModelVariants, listAgentProfiles, previewAgentProfileChange, renderAgentProfile, validateAgentName, validateModel, validateVariant, } from "./agent-profiles.js";
-export type { AgentInventory, AgentModelSelection, AgentOwnership, AgentProfileAction, AgentProfileConfig, AgentProfileOperation, AgentProfilePlan, AgentProfileRecord, AgentProfileRequest, AgentProfileResult, AgentProfileScope, AgentState, DeploymentManifest, DeploymentRecord, FixedAgentRole, } from "./agent-profiles.js";
-export { backgroundAttempts, goalLoop, scheduler, autonomyPolicy, rulesInjector, rtk, zedBell, zedClickablePaths };
+export { rulesInjector, rtk, zedBell, };
 export type OpenCodeOptions = {
-    backgroundAttempts?: BackgroundAttemptsOptions;
-    goalLoop?: GoalLoopOptions;
-    scheduler?: SchedulerOptions;
-    autonomyPolicy?: AutonomyPolicyOptions;
     rulesInjector?: RulesInjectorOptions;
     rtk?: RtkOptions;
     zedBell?: ZedBellOptions;
-    zedClickablePaths?: ZedClickablePathsOptions;
 };
-declare const plugin: (input: {
-    directory?: string;
-}) => Promise<{
+declare const plugin: (input: PluginInput) => Promise<{
     tool: {
         route: {
             description: string;
@@ -37,18 +22,12 @@ declare const plugin: (input: {
                     exploration: "exploration";
                     architecture: "architecture";
                     implementation: "implementation";
-                    documentation: "documentation";
-                    quick: "quick";
                 }>;
                 task: import("zod").ZodString;
                 requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                agents: import("zod").ZodArray<import("zod").ZodObject<{
-                    agent: import("zod").ZodString;
-                    available: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    capabilities: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                }, import("zod/v4/core").$strip>>;
+                execution_card: import("zod").ZodOptional<import("zod").ZodAny>;
                 override: import("zod").ZodOptional<import("zod").ZodString>;
+                trusted_override: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 budget: import("zod").ZodOptional<import("zod").ZodObject<{
                     cost_class: import("zod").ZodOptional<import("zod").ZodString>;
                     latency_class: import("zod").ZodOptional<import("zod").ZodString>;
@@ -57,16 +36,12 @@ declare const plugin: (input: {
             };
             execute(args: {
                 action: "preview" | "dispatch";
-                category: "review" | "exploration" | "architecture" | "implementation" | "documentation" | "quick";
+                category: "review" | "exploration" | "architecture" | "implementation";
                 task: string;
                 requirements: string[];
-                agents: {
-                    agent: string;
-                    available?: boolean | undefined;
-                    capabilities?: string[] | undefined;
-                    tools?: string[] | undefined;
-                }[];
+                execution_card?: any;
                 override?: string | undefined;
+                trusted_override?: boolean | undefined;
                 budget?: {
                     cost_class?: string | undefined;
                     latency_class?: string | undefined;
@@ -81,8 +56,15 @@ declare const plugin: (input: {
         };
         doctor: {
             description: string;
-            args: {};
-            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            args: {
+                scope: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>>;
+            };
+            execute(args: {
+                scope: "global" | "project";
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
         };
         agent_profiles: {
             description: string;
@@ -116,6 +98,25 @@ declare const plugin: (input: {
                 confirmation_digest?: string | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
         };
+        reconcile: {
+            description: string;
+            args: {
+                phase: import("zod").ZodEnum<{
+                    preview: "preview";
+                    apply: "apply";
+                }>;
+                scope: import("zod").ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>;
+                confirmation_digest: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            execute(args: {
+                phase: "preview" | "apply";
+                scope: "global" | "project";
+                confirmation_digest?: string | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
     };
     "tool.execute.before": (input: {
         tool: string;
@@ -123,10 +124,15 @@ declare const plugin: (input: {
     }, output: {
         args: unknown;
     }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        args: unknown;
+    }, output: {
+        output: string;
+    }) => Promise<void>;
 }>;
-export declare const server: (input: {
-    directory?: string;
-}) => Promise<{
+export declare const server: (input: PluginInput) => Promise<{
     tool: {
         route: {
             description: string;
@@ -140,18 +146,12 @@ export declare const server: (input: {
                     exploration: "exploration";
                     architecture: "architecture";
                     implementation: "implementation";
-                    documentation: "documentation";
-                    quick: "quick";
                 }>;
                 task: import("zod").ZodString;
                 requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                agents: import("zod").ZodArray<import("zod").ZodObject<{
-                    agent: import("zod").ZodString;
-                    available: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    capabilities: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                }, import("zod/v4/core").$strip>>;
+                execution_card: import("zod").ZodOptional<import("zod").ZodAny>;
                 override: import("zod").ZodOptional<import("zod").ZodString>;
+                trusted_override: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 budget: import("zod").ZodOptional<import("zod").ZodObject<{
                     cost_class: import("zod").ZodOptional<import("zod").ZodString>;
                     latency_class: import("zod").ZodOptional<import("zod").ZodString>;
@@ -160,16 +160,12 @@ export declare const server: (input: {
             };
             execute(args: {
                 action: "preview" | "dispatch";
-                category: "review" | "exploration" | "architecture" | "implementation" | "documentation" | "quick";
+                category: "review" | "exploration" | "architecture" | "implementation";
                 task: string;
                 requirements: string[];
-                agents: {
-                    agent: string;
-                    available?: boolean | undefined;
-                    capabilities?: string[] | undefined;
-                    tools?: string[] | undefined;
-                }[];
+                execution_card?: any;
                 override?: string | undefined;
+                trusted_override?: boolean | undefined;
                 budget?: {
                     cost_class?: string | undefined;
                     latency_class?: string | undefined;
@@ -184,8 +180,15 @@ export declare const server: (input: {
         };
         doctor: {
             description: string;
-            args: {};
-            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            args: {
+                scope: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>>;
+            };
+            execute(args: {
+                scope: "global" | "project";
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
         };
         agent_profiles: {
             description: string;
@@ -219,6 +222,25 @@ export declare const server: (input: {
                 confirmation_digest?: string | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
         };
+        reconcile: {
+            description: string;
+            args: {
+                phase: import("zod").ZodEnum<{
+                    preview: "preview";
+                    apply: "apply";
+                }>;
+                scope: import("zod").ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>;
+                confirmation_digest: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            execute(args: {
+                phase: "preview" | "apply";
+                scope: "global" | "project";
+                confirmation_digest?: string | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
     };
     "tool.execute.before": (input: {
         tool: string;
@@ -226,5 +248,12 @@ export declare const server: (input: {
     }, output: {
         args: unknown;
     }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        args: unknown;
+    }, output: {
+        output: string;
+    }) => Promise<void>;
 }>;
 export default plugin;

package/dist/index.js

@@ -1,26 +1,52 @@
 import { tool } from "@opencode-ai/plugin";
-import { CATEGORIES, RoutingGate } from "./routing.js";
-import backgroundAttempts from "./plugins/background-attempts.js";
-import goalLoop from "./plugins/goal-loop.js";
-import scheduler from "./plugins/schedule.js";
-import autonomyPolicy from "./plugins/autonomy-policy.js";
+import { CATEGORIES, RoutingGate, } from "./routing.js";
 import rulesInjector from "./plugins/rules-injector.js";
 import rtk from "./plugins/rtk.js";
 import zedBell from "./plugins/zed-bell.js";
-import zedClickablePaths from "./plugins/zed-clickable-paths.js";
 import { applyAgentProfileChange, listAgentProfiles, previewAgentProfileChange, } from "./agent-profiles.js";
-export { COMMAND_REGISTRY, renderCommand } from "./registry.js";
-export { CATEGORIES, resolveRouting, RoutingGate } from "./routing.js";
-export { AgentProfileError, FIXED_AGENT_ROLES, applyAgentProfileChange, availableModels, availableModelVariants, listAgentProfiles, previewAgentProfileChange, renderAgentProfile, validateAgentName, validateModel, validateVariant, } from "./agent-profiles.js";
-export { backgroundAttempts, goalLoop, scheduler, autonomyPolicy, rulesInjector, rtk, zedBell, zedClickablePaths };
-const CATALOG = {
-    skills: ["attempt", "goal", "schedule", "multi-run", "usage", "overview", "lsp-report"],
-    plugins: ["background-attempts", "goal-loop", "schedule", "autonomy-policy", "rules-injector", "rtk", "zed-bell", "zed-clickable-paths"],
-    replacements: ["capabilities", "route", "doctor", "agent_profiles"],
-    version: "1.1.1",
-};
+import { applyReconcile, previewReconcile } from "./reconcile.js";
+import { collectDoctorFacts } from "./doctor.js";
+import { CATALOG } from "./catalog.js";
+import { digest } from "./lifecycle.js";
+export { rulesInjector, rtk, zedBell, };
 const plugin = (async (input) => {
     const gate = new RoutingGate();
+    const hostInventory = async () => {
+        if (!input.client?.app?.agents)
+            throw new Error("Resolved OpenCode agent inventory is unavailable");
+        const response = await input.client.app.agents({ query: { directory: input.directory } });
+        const raw = response.data;
+        if (!Array.isArray(raw))
+            throw new Error("Resolved OpenCode agent inventory is malformed");
+        const capabilities = {
+            mapper: ["read", "search"],
+            architect: ["read", "architecture"],
+            worker: ["read", "write", "verify"],
+            review: ["read", "review"],
+            critic: ["read", "review"],
+        };
+        const agents = raw.map((value) => {
+            const agent = value;
+            if (typeof agent.name !== "string" || !agent.name)
+                throw new Error("Resolved OpenCode agent has no name");
+            return {
+                agent: agent.name,
+                available: true,
+                capabilities: capabilities[agent.name] ?? ["read"],
+                tools: [
+                    "read",
+                    ...(agent.permission?.edit !== "deny" ? ["edit"] : []),
+                    ...Object.entries(agent.tools ?? {})
+                        .filter(([, enabled]) => enabled)
+                        .map(([name]) => name),
+                    ...Object.entries(agent.permission?.bash ?? {})
+                        .filter(([, mode]) => mode !== "deny")
+                        .map(() => "bash"),
+                ].filter((name, index, list) => list.indexOf(name) === index),
+            };
+        });
+        return { agents, revision: digest(raw) };
+    };
     const route = tool({
         description: "Resolve a capability category and dispatch one eligible agent through a one-use Task receipt gate.",
         args: {
@@ -28,30 +54,61 @@ const plugin = (async (input) => {
             category: tool.schema.enum(CATEGORIES),
             task: tool.schema.string(),
             requirements: tool.schema.array(tool.schema.string()).default([]),
-            agents: tool.schema.array(tool.schema.object({ agent: tool.schema.string(), available: tool.schema.boolean().optional(), capabilities: tool.schema.array(tool.schema.string()).optional(), tools: tool.schema.array(tool.schema.string()).optional() })),
+            execution_card: tool.schema.any().optional(),
             override: tool.schema.string().optional(),
-            budget: tool.schema.object({ cost_class: tool.schema.string().optional(), latency_class: tool.schema.string().optional() }).optional(),
-            decision: tool.schema.any().optional()
+            trusted_override: tool.schema.boolean().optional(),
+            budget: tool.schema
+                .object({
+                cost_class: tool.schema.string().optional(),
+                latency_class: tool.schema.string().optional(),
+            })
+                .optional(),
+            decision: tool.schema.any().optional(),
         },
         async execute(args, context) {
-            const input = { category: args.category, requirements: args.requirements, agents: args.agents, override: args.override, budget: args.budget };
+            const inventory = await hostInventory();
+            const input = {
+                category: args.category,
+                task: args.task,
+                requirements: args.requirements,
+                agents: inventory.agents,
+                inventory_revision: inventory.revision,
+                execution_card: args.execution_card,
+                override: args.override,
+                trusted_override: args.trusted_override,
+                budget: args.budget,
+            };
             if (args.action === "preview")
                 return JSON.stringify(gate.preview(input));
             const decision = gate.dispatch(input, args.decision);
-            gate.grant(context.sessionID, decision);
-            return JSON.stringify({ decision, status: "routed" });
-        }
+            if (decision.agent === "worker" && args.execution_card === undefined)
+                throw new Error("implementation dispatch requires a confirmed execution card");
+            const receipt = gate.grant(context.sessionID, decision, {
+                task: args.task,
+                requirements: args.requirements,
+                card: args.execution_card,
+            });
+            return JSON.stringify({ decision, receipt, status: "routed" });
+        },
     });
     const capabilities = tool({
         description: "Show the bundled OpenCode capability catalog without installing or changing anything.",
         args: {},
-        async execute() { return JSON.stringify({ schema_version: 1, status: "ok", ...CATALOG }); },
+        async execute() {
+            return JSON.stringify({ schema_version: 1, status: "ok", ...CATALOG });
+        },
     });
     const doctor = tool({
         description: "Read package health and opt-in defaults without installing or repairing anything.",
-        args: {},
-        async execute() {
-            return JSON.stringify({ schema_version: 1, status: "ok", package: "@kisev/skills-opencode", opencode: ">=1.18.29", state: "not-inspected", mutations: false, defaults: { backgroundAttempts: false, goalLoop: false, scheduler: false, autonomyPolicy: false, zedBell: false, zedClickablePaths: false } });
+        args: { scope: tool.schema.enum(["global", "project"]).default("project") },
+        async execute(args, context) {
+            const host = input.client
+                ? {
+                    config: async () => (await input.client.config.get({ query: { directory: context.directory } })).data,
+                    lsp: async () => (await input.client.lsp.status({ query: { directory: context.directory } })).data,
+                }
+                : undefined;
+            return JSON.stringify(await collectDoctorFacts(args.scope ?? "project", context.directory, undefined, host));
         },
     });
     const agentProfiles = tool({
@@ -68,32 +125,108 @@ const plugin = (async (input) => {
         async execute(args) {
             const cwd = input.directory ?? process.cwd();
             if (args.action === "list") {
-                if (args.phase || args.name || args.model || args.variant !== undefined || args.confirmation_digest)
+                if (args.phase ||
+                    args.name ||
+                    args.model ||
+                    args.variant !== undefined ||
+                    args.confirmation_digest)
                     throw new Error("agent_profiles list accepts only scope");
-                return JSON.stringify({ status: "ok", inventory: await listAgentProfiles(args.scope, cwd) });
+                return JSON.stringify({
+                    status: "ok",
+                    inventory: await listAgentProfiles(args.scope, cwd),
+                });
             }
             if (!args.phase)
                 throw new Error("agent_profiles mutation requires preview or apply phase");
-            const action = { model_set: "model-set", critic_add: "critic-add", critic_remove: "critic-remove" }[args.action];
-            const request = { action, ...(args.name ? { name: args.name } : {}), ...(args.model ? { model: args.model } : {}), ...(args.variant !== undefined ? { variant: args.variant } : {}) };
+            const action = {
+                model_set: "model-set",
+                critic_add: "critic-add",
+                critic_remove: "critic-remove",
+            }[args.action];
+            const request = {
+                action,
+                ...(args.name ? { name: args.name } : {}),
+                ...(args.model ? { model: args.model } : {}),
+                ...(args.variant !== undefined ? { variant: args.variant } : {}),
+            };
             if (args.phase === "preview")
-                return JSON.stringify({ status: "ok", applied: false, requires_restart: false, plan: await previewAgentProfileChange(request, args.scope, cwd) });
+                return JSON.stringify({
+                    status: "ok",
+                    applied: false,
+                    requires_restart: false,
+                    plan: await previewAgentProfileChange(request, args.scope, cwd),
+                });
             if (!args.confirmation_digest)
                 throw new Error("agent_profiles apply requires confirmation_digest");
             return JSON.stringify(await applyAgentProfileChange(request, args.scope, args.confirmation_digest, cwd));
         },
     });
+    const reconcile = tool({
+        description: "Preview or apply scope-isolated removal of retired public assets without touching unknown sources or runtime state.",
+        args: {
+            phase: tool.schema.enum(["preview", "apply"]),
+            scope: tool.schema.enum(["global", "project"]),
+            confirmation_digest: tool.schema.string().optional(),
+        },
+        async execute(args) {
+            const cwd = input.directory ?? process.cwd();
+            if (args.phase === "preview")
+                return JSON.stringify({
+                    status: "ok",
+                    applied: false,
+                    plan: await previewReconcile(args.scope, cwd),
+                });
+            if (!args.confirmation_digest)
+                throw new Error("reconcile apply requires confirmation_digest");
+            return JSON.stringify(await applyReconcile(args.scope, args.confirmation_digest, cwd));
+        },
+    });
     return {
-        tool: { route, capabilities, doctor, agent_profiles: agentProfiles },
+        tool: { route, capabilities, doctor, agent_profiles: agentProfiles, reconcile },
         "tool.execute.before": async (input, output) => {
             if (input.tool !== "task")
                 return;
-            const args = output.args && typeof output.args === "object" ? output.args : {};
-            const agent = typeof args.agent === "string" ? args.agent : typeof args.subagent_type === "string" ? args.subagent_type : undefined;
+            const args = output.args && typeof output.args === "object"
+                ? output.args
+                : {};
+            const agent = typeof args.agent === "string"
+                ? args.agent
+                : typeof args.subagent_type === "string"
+                    ? args.subagent_type
+                    : undefined;
             if (!agent)
                 throw new Error("Native Task requires an explicit agent and an active routing receipt");
-            gate.consume(input.sessionID, agent);
-        }
+            const hasBinding = "task" in args || "requirements" in args || "execution_card" in args;
+            if (!hasBinding)
+                gate.consume(input.sessionID, agent);
+            else {
+                const task = typeof args.task === "string" ? args.task : "";
+                const requirements = Array.isArray(args.requirements)
+                    ? args.requirements
+                    : [];
+                gate.consume(input.sessionID, agent, { task, requirements, card: args.execution_card });
+            }
+        },
+        "tool.execute.after": async (input, output) => {
+            if (input.tool !== "task")
+                return;
+            const args = input.args && typeof input.args === "object" ? input.args : {};
+            const agent = typeof args.agent === "string"
+                ? args.agent
+                : typeof args.subagent_type === "string"
+                    ? args.subagent_type
+                    : undefined;
+            if (!agent)
+                throw new Error("Task result requires an explicit agent");
+            let result;
+            try {
+                result = JSON.parse(output.output);
+            }
+            catch {
+                throw new Error("Task result must be JSON structured report");
+            }
+            gate.complete(input.sessionID, agent, result);
+        },
     };
 });
 export const server = plugin;

package/dist/installer.d.ts

@@ -1,26 +1,54 @@
-import { LifecycleError, type Scope, type TransactionOptions } from "./lifecycle.js";
+import { LifecycleError, type FileMutation, type Scope, type TransactionOptions } from "./lifecycle.js";
+import { CATALOG } from "./catalog.js";
+import { type FixedAgentRole } from "./agent-profiles.js";
 export type { Scope } from "./lifecycle.js";
 export type Action = "install" | "uninstall";
-export type Operation = "create" | "update" | "remove" | "unchanged" | "missing" | "conflict";
+export type Operation = "create" | "update" | "remove" | "unchanged" | "missing" | "conflict" | "archive-pending";
 export type PlanItem = {
     path: string;
     operation: Operation;
     reason?: string;
     sha256?: string;
 };
+export type SelectablePlugin = (typeof CATALOG.plugins)[number];
+export type InstallerSelection = {
+    commands: string[];
+    agents: FixedAgentRole[];
+    plugins: SelectablePlugin[];
+    core_activation: boolean;
+};
 export type Plan = {
-    schema_version: 1;
+    schema_version: 2;
     action: Action;
     scope: Scope;
     root: string;
     package_version: string;
+    selection: InstallerSelection;
     operations: PlanItem[];
     digest: string;
     receipt_expires_at?: string;
     requires_restart: boolean;
 };
+type ManifestFile = {
+    sha256: string;
+    mode: number;
+    kind: "command" | "agent" | "plugin" | "state";
+};
+export type ArchiveCandidate = {
+    path: string;
+    record: ManifestFile;
+    content: Buffer;
+    reason: string;
+    kind: "command" | "agent" | "plugin" | "state";
+};
+export declare const SELECTABLE_PLUGINS: SelectablePlugin[];
+export declare const PACKAGE_COMMANDS: string[];
+export declare const SKILL_COMMANDS: string[];
+export declare function defaultSelection(): InstallerSelection;
+export declare function normalizeSelection(value?: Partial<InstallerSelection>): InstallerSelection;
 export declare class InstallerError extends LifecycleError {
 }
-export declare function preview(action: Action, scope: Scope, cwd?: string, home?: string): Promise<Plan>;
-export declare function apply(action: Action, scope: Scope, confirmationDigest: string, cwd?: string, home?: string, options?: TransactionOptions): Promise<Plan>;
+export declare function archiveMutations(candidates: readonly ArchiveCandidate[], scope: Scope, cwd: string, home: string, sourceVersion: string): Promise<FileMutation[]>;
+export declare function preview(action: Action, scope: Scope, cwd?: string, home?: string, selection?: Partial<InstallerSelection>): Promise<Plan>;
+export declare function apply(action: Action, scope: Scope, confirmationDigest: string, cwd?: string, home?: string, options?: TransactionOptions, selection?: Partial<InstallerSelection>): Promise<Plan>;
 export declare function result(plan: Plan, applied: boolean): string;