@kisev/skills-opencode 1.0.0 → 1.1.0

package/dist/cli.js

@@ -1,55 +1,217 @@
 #!/usr/bin/env node
+import { createInterface } from "node:readline/promises";
+import { AgentProfileError, applyAgentProfileChange, availableModels, availableModelVariants, FIXED_AGENT_ROLES, listAgentProfiles, previewAgentProfileChange, validateAgentName, validateModel, validateVariant, } from "./agent-profiles.js";
 import { apply, InstallerError, preview, result } from "./installer.js";
-function parseArguments(arguments_) {
-    const [action, ...rest] = arguments_;
-    if (action !== "install" && action !== "uninstall")
-        throw new InstallerError("invalid_input", "Use install or uninstall");
-    let scope;
-    let dryRun = false;
-    let confirm;
-    for (let index = 0; index < rest.length; index += 1) {
-        const value = rest[index];
-        if (value === "--scope") {
-            const candidate = rest[++index];
-            if (candidate !== "global" && candidate !== "project")
+import { LifecycleError } from "./lifecycle.js";
+function parseOptions(values) {
+    const options = { dryRun: false };
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (!value.startsWith("--")) {
+            if (options.name)
+                throw new InstallerError("invalid_input", `Unexpected argument: ${value}`);
+            options.name = value;
+        }
+        else if (value === "--scope") {
+            const scope = values[++index];
+            if (scope !== "global" && scope !== "project")
                 throw new InstallerError("invalid_input", "--scope must be global or project");
-            if (scope)
+            if (options.scope)
                 throw new InstallerError("invalid_input", "--scope may be supplied once");
-            scope = candidate;
+            options.scope = scope;
         }
         else if (value === "--dry-run") {
-            if (dryRun)
+            if (options.dryRun)
                 throw new InstallerError("invalid_input", "--dry-run may be supplied once");
-            dryRun = true;
+            options.dryRun = true;
         }
         else if (value === "--confirm") {
-            if (confirm)
+            if (options.confirm)
                 throw new InstallerError("invalid_input", "--confirm may be supplied once");
-            confirm = rest[++index];
-            if (!confirm)
+            options.confirm = values[++index];
+            if (!options.confirm)
                 throw new InstallerError("invalid_input", "--confirm requires a digest");
         }
+        else if (value === "--provider") {
+            options.provider = values[++index];
+            if (!options.provider)
+                throw new InstallerError("invalid_input", "--provider requires a value");
+        }
+        else if (value === "--model") {
+            options.model = values[++index];
+            if (!options.model)
+                throw new InstallerError("invalid_input", "--model requires a value");
+        }
+        else if (value === "--variant") {
+            options.variant = values[++index];
+            if (!options.variant)
+                throw new InstallerError("invalid_input", "--variant requires a value");
+        }
+        else if (value === "--clear-variant") {
+            if (options.variant !== undefined)
+                throw new InstallerError("invalid_input", "Use only one variant option");
+            options.variant = null;
+        }
         else {
             throw new InstallerError("invalid_input", `Unknown argument: ${value}`);
         }
     }
-    if (!scope)
+    if (!options.scope)
         throw new InstallerError("invalid_input", "--scope is required");
-    if (dryRun === Boolean(confirm))
+    return options;
+}
+function requireConfirmationMode(options) {
+    if (options.dryRun === Boolean(options.confirm))
         throw new InstallerError("invalid_input", "Use exactly one of --dry-run or --confirm <digest>");
-    return { action, scope, dryRun, confirm };
 }
-async function main() {
+function exactModel(options) {
+    if (!options.model)
+        return undefined;
+    if (options.model.includes("/")) {
+        const model = validateModel(options.model);
+        if (options.provider && model.split("/", 1)[0] !== options.provider)
+            throw new InstallerError("invalid_input", "--provider does not match the exact --model value");
+        return model;
+    }
+    if (!options.provider)
+        throw new InstallerError("invalid_input", "--provider is required when --model is not provider/model");
+    return validateModel(`${options.provider}/${options.model}`);
+}
+async function choose(label, values, input) {
+    process.stderr.write(`${label}:\n${values.map((value, index) => `  ${index + 1}. ${value}`).join("\n")}\n`);
+    const answer = await input.question("> ");
+    const index = Number(answer) - 1;
+    if (!Number.isSafeInteger(index) || !values[index])
+        throw new InstallerError("invalid_input", `Invalid ${label.toLowerCase()} selection`);
+    return values[index];
+}
+async function interactiveSelection(options) {
+    if (!process.stdin.isTTY || !process.stderr.isTTY)
+        throw new InstallerError("terminal_required", "agent configure requires a terminal or explicit --provider and --model");
+    const input = createInterface({ input: process.stdin, output: process.stderr });
     try {
-        const parsed = parseArguments(process.argv.slice(2));
-        if (parsed.dryRun) {
-            process.stdout.write(`${result(await preview(parsed.action, parsed.scope), false)}\n`);
-            return;
+        const inventory = await listAgentProfiles(options.scope);
+        const configurable = inventory.profiles.filter((item) => item.ownership !== "user-owned").map((item) => item.name);
+        const name = options.name ? validateAgentName(options.name) : await choose("Agent", configurable.length ? configurable : FIXED_AGENT_ROLES, input);
+        if (options.provider && options.model)
+            return { name, model: exactModel(options), ...(validateVariant(options.variant) ? { variant: validateVariant(options.variant) } : {}) };
+        let models;
+        try {
+            models = await availableModels();
+        }
+        catch (error) {
+            if (!(error instanceof AgentProfileError) || error.code !== "catalog_unavailable")
+                throw error;
+            const provider = options.provider ?? (await input.question("Provider: ")).trim();
+            const model = options.model ?? (await input.question("Model: ")).trim();
+            const variant = options.variant === undefined ? (await input.question("Variant (optional): ")).trim() : options.variant;
+            return { name, model: validateModel(model.includes("/") ? model : `${provider}/${model}`), ...(validateVariant(variant) ? { variant: validateVariant(variant) } : {}) };
+        }
+        const providers = [...new Set(models.map((model) => model.split("/", 1)[0]))].sort();
+        const provider = options.provider ?? (await choose("Provider", providers, input));
+        const selectedModel = options.model
+            ? exactModel({ ...options, provider })
+            : await choose("Model", models.filter((model) => model.startsWith(`${provider}/`)), input);
+        let variants = [];
+        try {
+            variants = await availableModelVariants(selectedModel);
         }
-        process.stdout.write(`${result(await apply(parsed.action, parsed.scope, parsed.confirm), true)}\n`);
+        catch (error) {
+            if (!(error instanceof AgentProfileError) || error.code !== "catalog_unavailable")
+                throw error;
+        }
+        const variant = options.variant === null
+            ? undefined
+            : options.variant ?? (variants.length ? await choose("Variant", ["none", ...variants.filter((value) => value !== "none")], input) : (await input.question("Variant (optional): ")).trim());
+        return { name, model: selectedModel, ...(variant && variant !== "none" ? { variant: validateVariant(variant) } : {}) };
+    }
+    finally {
+        input.close();
+    }
+}
+async function runProfile(request, options) {
+    requireConfirmationMode(options);
+    if (options.dryRun) {
+        const plan = await previewAgentProfileChange(request, options.scope);
+        process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, requires_restart: false, plan }, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${JSON.stringify(await applyAgentProfileChange(request, options.scope, options.confirm), null, 2)}\n`);
+    }
+}
+async function run(arguments_) {
+    const [domain, operation, ...rest] = arguments_;
+    if (domain === "install" || domain === "uninstall") {
+        if (operation?.startsWith("--") || operation === undefined)
+            rest.unshift(...(operation ? [operation] : []));
+        else
+            throw new InstallerError("invalid_input", `Unexpected argument: ${operation}`);
+        const options = parseOptions(rest);
+        if (options.name || options.provider || options.model || options.variant !== undefined)
+            throw new InstallerError("invalid_input", "Installer accepts only scope and confirmation options");
+        requireConfirmationMode(options);
+        const action = domain;
+        process.stdout.write(`${result(options.dryRun ? await preview(action, options.scope) : await apply(action, options.scope, options.confirm), !options.dryRun)}\n`);
+        return;
+    }
+    if (domain === "agent" && operation === "list") {
+        const options = parseOptions(rest);
+        if (options.dryRun || options.confirm || options.name || options.provider || options.model || options.variant !== undefined)
+            throw new InstallerError("invalid_input", "agent list accepts only --scope");
+        process.stdout.write(`${JSON.stringify({ status: "ok", inventory: await listAgentProfiles(options.scope) }, null, 2)}\n`);
+        return;
+    }
+    if (domain === "agent" && operation === "configure") {
+        const options = parseOptions(rest);
+        requireConfirmationMode(options);
+        const selected = options.provider && options.model && options.name
+            ? { name: validateAgentName(options.name), model: exactModel(options), ...(validateVariant(options.variant) ? { variant: validateVariant(options.variant) } : {}) }
+            : await interactiveSelection(options);
+        await runProfile({ action: "model-set", ...selected, variant: selected.variant ?? null }, options);
+        return;
+    }
+    if (domain === "agent" && operation === "model-set") {
+        const options = parseOptions(rest);
+        const name = validateAgentName(options.name ?? "");
+        const model = exactModel(options);
+        if (!model)
+            throw new InstallerError("invalid_input", "agent model-set requires --provider and --model, or exact --model provider/model");
+        await runProfile({ action: "model-set", name, model, variant: options.variant ?? null }, options);
+        return;
+    }
+    if (domain === "agent" && operation === "reconcile") {
+        const options = parseOptions(rest);
+        if (options.name || options.provider || options.model || options.variant !== undefined)
+            throw new InstallerError("invalid_input", "agent reconcile accepts only scope and confirmation options");
+        await runProfile({ action: "reconcile" }, options);
+        return;
+    }
+    if (domain === "critic" && (operation === "add" || operation === "remove")) {
+        const options = parseOptions(rest);
+        const name = options.name === "critic" || options.name?.startsWith("critic-")
+            ? options.name
+            : `critic-${options.name ?? ""}`;
+        if (operation === "add") {
+            const model = exactModel(options);
+            if (!model)
+                throw new InstallerError("invalid_input", "critic add requires --provider and --model, or exact --model provider/model");
+            await runProfile({ action: "critic-add", name, model, variant: options.variant ?? null }, options);
+        }
+        else {
+            if (options.provider || options.model || options.variant !== undefined)
+                throw new InstallerError("invalid_input", "critic remove does not accept model options");
+            await runProfile({ action: "critic-remove", name }, options);
+        }
+        return;
+    }
+    throw new InstallerError("invalid_input", "Use install, uninstall, agent list|configure|model-set|reconcile, or critic add|remove");
+}
+async function main() {
+    try {
+        await run(process.argv.slice(2));
     }
     catch (error) {
-        const known = error instanceof InstallerError ? error : new InstallerError("internal_error", error instanceof Error ? error.message : String(error));
+        const known = error instanceof LifecycleError ? error : new InstallerError("internal_error", error instanceof Error ? error.message : String(error));
         process.stdout.write(`${JSON.stringify({ status: "error", error: { code: known.code, message: known.message } })}\n`);
         process.exitCode = 2;
     }

package/dist/generate-assets.js

@@ -1,10 +1,39 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { COMMAND_REGISTRY, renderCommand } from "./registry.js";
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const commandsRoot = resolve(packageRoot, "assets", "commands");
-await mkdir(commandsRoot, { recursive: true });
+const arguments_ = process.argv.slice(2);
+const rootIndex = arguments_.indexOf("--root");
+if (rootIndex !== -1 && !arguments_[rootIndex + 1])
+    throw new Error("--root requires a path");
+const commandsRoot = rootIndex === -1
+    ? resolve(packageRoot, "assets", "commands")
+    : resolve(arguments_[rootIndex + 1] ?? "");
+const check = arguments_.includes("--check");
+const expectedNames = new Set(COMMAND_REGISTRY.map((command) => `${command.name}.md`));
+if (!check)
+    await mkdir(commandsRoot, { recursive: true });
+const entries = await readdir(commandsRoot, { withFileTypes: true }).catch(() => []);
+for (const entry of entries) {
+    if (entry.isFile() && !expectedNames.has(entry.name)) {
+        if (check)
+            throw new Error(`unexpected generated asset: ${entry.name}`);
+        await unlink(resolve(commandsRoot, entry.name));
+    }
+    else if (!entry.isFile()) {
+        throw new Error(`unexpected entry in generated assets: ${entry.name}`);
+    }
+}
 for (const command of COMMAND_REGISTRY) {
-    await writeFile(resolve(commandsRoot, `${command.name}.md`), renderCommand(command), "utf8");
+    const destination = resolve(commandsRoot, `${command.name}.md`);
+    const expected = renderCommand(command);
+    if (check) {
+        const actual = await readFile(destination, "utf8").catch(() => "");
+        if (actual !== expected)
+            throw new Error(`generated asset drift: ${command.name}.md`);
+    }
+    else {
+        await writeFile(destination, expected, "utf8");
+    }
 }

package/dist/index.d.ts

@@ -8,6 +8,8 @@ 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 type OpenCodeOptions = {
     backgroundAttempts?: BackgroundAttemptsOptions;
@@ -19,7 +21,9 @@ export type OpenCodeOptions = {
     zedBell?: ZedBellOptions;
     zedClickablePaths?: ZedClickablePathsOptions;
 };
-declare const plugin: () => Promise<{
+declare const plugin: (input: {
+    directory?: string;
+}) => Promise<{
     tool: {
         route: {
             description: string;
@@ -29,10 +33,10 @@ declare const plugin: () => Promise<{
                     dispatch: "dispatch";
                 }>;
                 category: import("zod").ZodEnum<{
+                    review: "review";
                     exploration: "exploration";
                     architecture: "architecture";
                     implementation: "implementation";
-                    review: "review";
                     documentation: "documentation";
                     quick: "quick";
                 }>;
@@ -53,7 +57,7 @@ declare const plugin: () => Promise<{
             };
             execute(args: {
                 action: "preview" | "dispatch";
-                category: "exploration" | "architecture" | "implementation" | "review" | "documentation" | "quick";
+                category: "review" | "exploration" | "architecture" | "implementation" | "documentation" | "quick";
                 task: string;
                 requirements: string[];
                 agents: {
@@ -80,6 +84,38 @@ declare const plugin: () => Promise<{
             args: {};
             execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
         };
+        agent_profiles: {
+            description: string;
+            args: {
+                action: import("zod").ZodEnum<{
+                    list: "list";
+                    model_set: "model_set";
+                    critic_add: "critic_add";
+                    critic_remove: "critic_remove";
+                }>;
+                phase: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    preview: "preview";
+                    apply: "apply";
+                }>>;
+                scope: import("zod").ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>;
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+                model: import("zod").ZodOptional<import("zod").ZodString>;
+                variant: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                confirmation_digest: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            execute(args: {
+                action: "list" | "model_set" | "critic_add" | "critic_remove";
+                scope: "global" | "project";
+                phase?: "preview" | "apply" | undefined;
+                name?: string | undefined;
+                model?: string | undefined;
+                variant?: string | null | undefined;
+                confirmation_digest?: string | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
     };
     "tool.execute.before": (input: {
         tool: string;
@@ -88,7 +124,9 @@ declare const plugin: () => Promise<{
         args: unknown;
     }) => Promise<void>;
 }>;
-export declare const server: () => Promise<{
+export declare const server: (input: {
+    directory?: string;
+}) => Promise<{
     tool: {
         route: {
             description: string;
@@ -98,10 +136,10 @@ export declare const server: () => Promise<{
                     dispatch: "dispatch";
                 }>;
                 category: import("zod").ZodEnum<{
+                    review: "review";
                     exploration: "exploration";
                     architecture: "architecture";
                     implementation: "implementation";
-                    review: "review";
                     documentation: "documentation";
                     quick: "quick";
                 }>;
@@ -122,7 +160,7 @@ export declare const server: () => Promise<{
             };
             execute(args: {
                 action: "preview" | "dispatch";
-                category: "exploration" | "architecture" | "implementation" | "review" | "documentation" | "quick";
+                category: "review" | "exploration" | "architecture" | "implementation" | "documentation" | "quick";
                 task: string;
                 requirements: string[];
                 agents: {
@@ -149,6 +187,38 @@ export declare const server: () => Promise<{
             args: {};
             execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
         };
+        agent_profiles: {
+            description: string;
+            args: {
+                action: import("zod").ZodEnum<{
+                    list: "list";
+                    model_set: "model_set";
+                    critic_add: "critic_add";
+                    critic_remove: "critic_remove";
+                }>;
+                phase: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    preview: "preview";
+                    apply: "apply";
+                }>>;
+                scope: import("zod").ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>;
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+                model: import("zod").ZodOptional<import("zod").ZodString>;
+                variant: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                confirmation_digest: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            execute(args: {
+                action: "list" | "model_set" | "critic_add" | "critic_remove";
+                scope: "global" | "project";
+                phase?: "preview" | "apply" | undefined;
+                name?: string | undefined;
+                model?: string | undefined;
+                variant?: string | null | undefined;
+                confirmation_digest?: string | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
     };
     "tool.execute.before": (input: {
         tool: string;

package/dist/index.js

@@ -8,16 +8,18 @@ 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"],
-    version: "1.0.0",
+    replacements: ["capabilities", "route", "doctor", "agent_profiles"],
+    version: "1.1.0",
 };
-const plugin = (async () => {
+const plugin = (async (input) => {
     const gate = new RoutingGate();
     const route = tool({
         description: "Resolve a capability category and dispatch one eligible agent through a one-use Task receipt gate.",
@@ -52,8 +54,37 @@ const plugin = (async () => {
             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 } });
         },
     });
+    const agentProfiles = tool({
+        description: "List, preview, or apply package-owned OpenCode agent profile configuration without editing opencode.json.",
+        args: {
+            action: tool.schema.enum(["list", "model_set", "critic_add", "critic_remove"]),
+            phase: tool.schema.enum(["preview", "apply"]).optional(),
+            scope: tool.schema.enum(["global", "project"]),
+            name: tool.schema.string().optional(),
+            model: tool.schema.string().optional(),
+            variant: tool.schema.string().nullable().optional(),
+            confirmation_digest: tool.schema.string().optional(),
+        },
+        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)
+                    throw new Error("agent_profiles list accepts only scope");
+                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 } : {}) };
+            if (args.phase === "preview")
+                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));
+        },
+    });
     return {
-        tool: { route, capabilities, doctor },
+        tool: { route, capabilities, doctor, agent_profiles: agentProfiles },
         "tool.execute.before": async (input, output) => {
             if (input.tool !== "task")
                 return;

package/dist/installer.d.ts

@@ -1,4 +1,5 @@
-export type Scope = "global" | "project";
+import { LifecycleError, type Scope, type TransactionOptions } from "./lifecycle.js";
+export type { Scope } from "./lifecycle.js";
 export type Action = "install" | "uninstall";
 export type Operation = "create" | "update" | "remove" | "unchanged" | "missing" | "conflict";
 export type PlanItem = {
@@ -12,14 +13,14 @@ export type Plan = {
     action: Action;
     scope: Scope;
     root: string;
+    package_version: string;
     operations: PlanItem[];
-    manifest_sha256?: string;
     digest: string;
+    receipt_expires_at?: string;
+    requires_restart: boolean;
 };
-export declare class InstallerError extends Error {
-    readonly code: string;
-    constructor(code: string, message: string);
+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, digest: string, 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 result(plan: Plan, applied: boolean): string;