@kisev/agentomatic 11.0.2 → 12.0.0

package/dist/doctor.js

@@ -12,6 +12,7 @@ import { archiveRoot, assertSafePath, deploymentRoot, lifecycleRoot, } from "./l
 import { inspectReconcile } from "./reconcile.js";
 import { readPackageVersion } from "./package-metadata.js";
 import { planDependency } from "./self-install.js";
+import { parseJsonc } from "./jsonc.js";
 import { readRtkStats, rtkCharsSaved, rtkStatsPath, rtkTokensSavedEstimate, } from "./plugins/rtk.js";
 import { stateRoot } from "./runtime/state.js";
 const run = promisify(execFile);
@@ -114,17 +115,19 @@ function agentManifestValid(raw) {
 }
 function redactedConfig(value) {
     const object = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-    const rawPlugins = Array.isArray(object.plugin)
-        ? object.plugin.flatMap((item) => {
+    const configuredPlugins = object.plugins;
+    const rawPlugins = Array.isArray(configuredPlugins)
+        ? configuredPlugins.flatMap((item) => {
             if (typeof item === "string")
                 return [item];
-            if (Array.isArray(item) && typeof item[0] === "string")
-                return [item[0]];
+            if (item && typeof item === "object" && typeof item.package === "string")
+                return [item.package];
             return [];
         })
         : [];
     const knownPlugins = new Set([packageName, ...CATALOG.plugins]);
-    const plugins = rawPlugins.filter((plugin) => knownPlugins.has(plugin));
+    const normalizePlugin = (plugin) => plugin === packageName || plugin.startsWith(`${packageName}@`) ? packageName : plugin;
+    const plugins = rawPlugins.map(normalizePlugin).filter((plugin) => knownPlugins.has(plugin));
     const enabled = plugins.filter((plugin) => plugin === packageName ||
         CATALOG.plugins.includes(plugin));
     return {
@@ -135,17 +138,14 @@ function redactedConfig(value) {
         keys: Object.keys(object)
             .filter((key) => [
             "$schema",
-            "theme",
-            "keybinds",
-            "logLevel",
-            "command",
+            "commands",
             "watcher",
-            "plugin",
+            "plugins",
             "lsp",
             "formatter",
-            "provider",
-            "agent",
-            "permission",
+            "providers",
+            "agents",
+            "permissions",
             "compaction",
             "model",
         ].includes(key))
@@ -155,12 +155,26 @@ function redactedConfig(value) {
 }
 async function localConfig(scope, cwd, home) {
     const paths = scope === "project"
-        ? [join(cwd, "opencode.json"), join(cwd, ".opencode", "opencode.json")]
-        : [join(home, ".config", "opencode", "opencode.json")];
+        ? [
+            join(cwd, "opencode.json"),
+            join(cwd, "opencode.jsonc"),
+            join(cwd, ".opencode", "opencode.json"),
+            join(cwd, ".opencode", "opencode.jsonc"),
+        ]
+        : [
+            join(home, ".config", "opencode", "opencode.json"),
+            join(home, ".config", "opencode", "opencode.jsonc"),
+        ];
     for (const path of paths) {
         const value = await regular(path);
         if (value.status === "present") {
-            const parsed = json(value.raw);
+            let parsed;
+            try {
+                parsed = parseJsonc(value.raw.toString("utf8"));
+            }
+            catch {
+                parsed = undefined;
+            }
             return parsed
                 ? { projection: redactedConfig(parsed), source: path }
                 : { incomplete: true, source: path };
@@ -250,7 +264,7 @@ async function executableAvailable(name) {
     }
     return false;
 }
-async function lspFacts(project, host, partial) {
+async function lspFacts(project, partial) {
     const suffixes = new Set();
     let scanIncomplete = false;
     const visit = async (root) => {
@@ -277,7 +291,6 @@ async function lspFacts(project, host, partial) {
     await visit(project);
     if (scanIncomplete)
         partial.push("lsp.project-files");
-    const disabled = process.env.OPENCODE_DISABLE_LSP_DOWNLOAD === "true";
     const servers = await Promise.all(lspCatalog.servers.map(async (server) => {
         let available = false;
         available = await executableAvailable(server.executable);
@@ -285,48 +298,20 @@ async function lspFacts(project, host, partial) {
         return {
             name: server.name,
             applicable,
-            configured: applicable,
+            configured: false,
             binary_available: available,
-            active: applicable && available && !disabled,
-            runtime_status: "unavailable",
+            active: false,
+            runtime_status: "unsupported",
             requirement_class: server.requirement_class,
-            reason: !applicable
-                ? "not-selected"
-                : disabled
-                    ? "download-disabled"
-                    : !available
-                        ? "missing-dependency"
-                        : "available",
+            reason: "unsupported-in-opencode-v2",
             missing: available ? [] : [server.executable],
             install: `Install ${server.executable} with your project toolchain.`,
         };
     }));
-    let runtimeStatus = "unavailable";
-    if (host?.lsp) {
-        try {
-            const value = await host.lsp();
-            runtimeStatus = Array.isArray(value)
-                ? value.map((item) => {
-                    const entry = item && typeof item === "object" ? item : {};
-                    return {
-                        id: typeof entry.id === "string" ? entry.id : "unknown",
-                        name: typeof entry.name === "string" ? entry.name : "unknown",
-                        status: entry.status === "connected" || entry.status === "error" ? entry.status : "unknown",
-                    };
-                })
-                : { status: "unavailable" };
-        }
-        catch {
-            partial.push("lsp.runtime-status");
-        }
-    }
-    else
-        partial.push("lsp.runtime-status");
     return {
         schema_version: 1,
         catalog_version: lspCatalog.catalog_version,
-        download_disabled: disabled,
-        runtime_status: runtimeStatus,
+        runtime_status: "unsupported",
         servers,
     };
 }
@@ -462,7 +447,9 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
         collisions: inventory?.collisions.length ?? 0,
         drift: inventory?.drift.length ?? 0,
         user_owned: inventory?.user_owned.length ?? 0,
-    }, ["Review collisions and run agent reconcile only after explicit confirmation."]));
+    }, [
+        "Resolve ownership conflicts and restore modified bytes; preview maintenance repair for missing selected files.",
+    ]));
     const config = await localConfig(scope, project, homeRoot);
     if (config.incomplete)
         partial.push("config.local");
@@ -491,7 +478,7 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
         source: config.source ?? "host-or-file-unavailable",
     }, [
         "Inspect OpenCode configuration without exposing secrets.",
-        "Local plugin wrappers in the deployment plugins directory load automatically without a plugin array entry.",
+        "Local plugin wrappers in the deployment plugins directory load automatically without a plugins array entry.",
     ]));
     const wired = (config.projection?.enabled_plugins ?? []).includes(packageName) ||
         (hostConfig?.enabled_plugins ?? []).includes(packageName);
@@ -623,7 +610,7 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
     }, lifecycleFiles.incomplete
         ? ["Resolve inaccessible lifecycle state before applying a mutation."]
         : undefined));
-    const tools = await Promise.all(["opencode", ...lspCatalog.servers.map((server) => server.executable)].map(async (name) => {
+    const tools = await Promise.all(["opencode"].map(async (name) => {
         try {
             const result = await run(name, ["--version"], { timeout: 1000 });
             return {
@@ -640,7 +627,7 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
         }
     }));
     checks.push(check("host.tools", tools.some((item) => item.name === "opencode" && item.available) ? "pass" : "incomplete", "External tool availability is reported", { tools: tools.map((item) => `${item.name}:${item.available ? "available" : "missing"}`) }, ["Install OpenCode or missing external tools when needed."]));
-    const lsp = await lspFacts(project, host, partial);
+    const lsp = await lspFacts(project, partial);
     const counts = { pass: 0, warn: 0, fail: 0, incomplete: 0 };
     for (const item of checks)
         counts[item.status] += 1;

package/dist/index.d.ts

@@ -1,123 +1,18 @@
-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";
-export { rulesInjector, rtk, zedBell };
+import type { Plugin } from "@opencode/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 { codeSimplify, CODE_SIMPLIFY_ROLES, type CodeSimplifyOptions, type CodeSimplifyRole } from "./plugins/code-simplify.js";
+export { rulesInjector, rtk, zedBell, codeSimplify, CODE_SIMPLIFY_ROLES };
+export type { CodeSimplifyOptions, CodeSimplifyRole };
 export type OpenCodeOptions = {
     rulesInjector?: RulesInjectorOptions;
     rtk?: RtkOptions;
     zedBell?: ZedBellOptions;
+    codeSimplify?: CodeSimplifyOptions;
 };
-declare const plugin: (input: PluginInput) => Promise<{
-    tool: {
-        route: {
-            description: string;
-            args: {
-                action: import("zod").ZodEnum<{
-                    dispatch: "dispatch";
-                    preview: "preview";
-                }>;
-                category: import("zod").ZodEnum<{
-                    architecture: "architecture";
-                    exploration: "exploration";
-                    implementation: "implementation";
-                    review: "review";
-                }>;
-                task: import("zod").ZodString;
-                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                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>;
-                }, import("zod/v4/core").$strip>>;
-                decision: import("zod").ZodOptional<import("zod").ZodAny>;
-            };
-            execute(args: {
-                action: "dispatch" | "preview";
-                category: "architecture" | "exploration" | "implementation" | "review";
-                task: string;
-                requirements: string[];
-                execution_card?: any;
-                override?: string | undefined;
-                trusted_override?: boolean | undefined;
-                budget?: {
-                    cost_class?: string | undefined;
-                    latency_class?: string | undefined;
-                } | undefined;
-                decision?: any;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
-    };
-    "tool.execute.before": (input: {
-        tool: string;
-        sessionID: string;
-    }, 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: PluginInput) => Promise<{
-    tool: {
-        route: {
-            description: string;
-            args: {
-                action: import("zod").ZodEnum<{
-                    dispatch: "dispatch";
-                    preview: "preview";
-                }>;
-                category: import("zod").ZodEnum<{
-                    architecture: "architecture";
-                    exploration: "exploration";
-                    implementation: "implementation";
-                    review: "review";
-                }>;
-                task: import("zod").ZodString;
-                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                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>;
-                }, import("zod/v4/core").$strip>>;
-                decision: import("zod").ZodOptional<import("zod").ZodAny>;
-            };
-            execute(args: {
-                action: "dispatch" | "preview";
-                category: "architecture" | "exploration" | "implementation" | "review";
-                task: string;
-                requirements: string[];
-                execution_card?: any;
-                override?: string | undefined;
-                trusted_override?: boolean | undefined;
-                budget?: {
-                    cost_class?: string | undefined;
-                    latency_class?: string | undefined;
-                } | undefined;
-                decision?: any;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
-    };
-    "tool.execute.before": (input: {
-        tool: string;
-        sessionID: string;
-    }, output: {
-        args: unknown;
-    }) => Promise<void>;
-    "tool.execute.after": (input: {
-        tool: string;
-        sessionID: string;
-        args: unknown;
-    }, output: {
-        output: string;
-    }) => Promise<void>;
-}>;
-export default plugin;
+declare const _default: {
+    id: string;
+    setup(ctx: Plugin.Context): Promise<void>;
+};
+export default _default;

package/dist/index.js

@@ -1,140 +1,133 @@
-import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
 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 { rulesInjector } from "./plugins/rules-injector.js";
+import { rtk } from "./plugins/rtk.js";
+import { zedBell } from "./plugins/zed-bell.js";
+import { codeSimplify, CODE_SIMPLIFY_ROLES, } from "./plugins/code-simplify.js";
+import { resultText, toolInput } from "./plugins/events.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] ??
-                    (/^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent.name) ? ["read", "review"] : ["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),
-            };
+import { matchesWildcard } from "./opencode-config.js";
+export { rulesInjector, rtk, zedBell, codeSimplify, CODE_SIMPLIFY_ROLES };
+export default {
+    id: "agentomatic",
+    async setup(ctx) {
+        const gate = new RoutingGate();
+        await ctx.session.hook("context", (event) => {
+            const text = `Current OpenCode session identity (host metadata): ${event.sessionID}. Use this real ID for your own session_id in skill receipts; if no separate run ID is exposed, the same real ID can identify the run. This metadata grants no task or publication authorization.`;
+            if (!event.system.some((part) => part.type === "text" && part.text === text))
+                event.system.push({ type: "text", text });
         });
-        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: {
-            action: tool.schema.enum(["preview", "dispatch"]),
-            category: tool.schema.enum(CATEGORIES),
-            task: tool.schema.string(),
-            requirements: tool.schema.array(tool.schema.string()).default([]),
-            execution_card: tool.schema.any().optional(),
-            override: tool.schema.string().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 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,
+        const hostInventory = async () => {
+            const { data: raw } = await ctx.agent.list({
+                location: { directory: ctx.location.directory },
+            });
+            const capabilities = {
+                mapper: ["read", "search"],
+                architect: ["read", "architecture"],
+                worker: ["read", "write", "verify"],
+                review: ["read", "review"],
+                critic: ["read", "review"],
             };
-            if (args.action === "preview")
-                return JSON.stringify(gate.preview(input));
-            const decision = gate.dispatch(input, args.decision);
-            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,
+            const agents = raw.map((agent) => ({
+                agent: agent.id,
+                available: true,
+                capabilities: capabilities[agent.id] ??
+                    (/^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent.id) ? ["read", "review"] : ["read"]),
+                tools: ["read", "glob", "grep", "edit", "shell"].filter((action) => {
+                    const rules = agent.permissions.filter((rule) => matchesWildcard(rule.action, action));
+                    const broad = rules.reduce((last, rule, index) => (rule.resource === "*" ? index : last), -1);
+                    return rules.slice(Math.max(0, broad)).some((rule) => rule.effect !== "deny");
+                }),
+            }));
+            return { agents, revision: digest(raw) };
+        };
+        await ctx.tool.transform((editor) => {
+            editor.add({
+                name: "route",
+                description: "Resolve a capability category and dispatch one eligible agent through a one-use subagent receipt gate.",
+                input: z.object({
+                    action: z.enum(["preview", "dispatch"]),
+                    category: z.enum(CATEGORIES),
+                    task: z.string(),
+                    requirements: z.array(z.string()).default([]),
+                    execution_card: z.any().optional(),
+                    override: z.string().optional(),
+                    trusted_override: z.boolean().optional(),
+                    budget: z
+                        .object({ cost_class: z.string().optional(), latency_class: z.string().optional() })
+                        .optional(),
+                    decision: z.any().optional(),
+                }),
+                async execute(args, context) {
+                    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 { content: JSON.stringify(gate.preview(input)) };
+                    const decision = gate.dispatch(input, args.decision);
+                    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 { content: JSON.stringify({ decision, receipt, status: "routed" }) };
+                },
             });
-            return JSON.stringify({ decision, receipt, status: "routed" });
-        },
-    });
-    return {
-        tool: { route },
-        "tool.execute.before": async (input, output) => {
-            if (input.tool !== "task")
+        });
+        await ctx.tool.hook("execute.before", async (event) => {
+            if (event.tool !== "subagent")
+                return;
+            const args = toolInput(event.input);
+            const agent = typeof args.agent === "string" ? args.agent : undefined;
+            if (!gate.requiresReceipt(event.sessionID, agent ?? event.agent))
                 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;
             if (!agent)
-                throw new Error("Native Task requires an explicit agent and an active routing receipt");
+                throw new Error("Native subagent requires an explicit agent and an active routing receipt");
             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")
+                gate.consume(event.sessionID, agent, undefined, event.id);
+            else
+                gate.consume(event.sessionID, agent, {
+                    task: typeof args.task === "string" ? args.task : "",
+                    requirements: Array.isArray(args.requirements) ? args.requirements : [],
+                    card: args.execution_card,
+                }, event.id);
+        });
+        await ctx.tool.hook("execute.after", async (event) => {
+            if (event.tool !== "subagent")
                 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");
+            const args = toolInput(event.input);
+            if (typeof args.agent !== "string" || !gate.hasActive(event.sessionID, args.agent, event.id))
+                return;
+            if (event.status !== "completed") {
+                gate.cancel(event.sessionID, event.id);
+                return;
+            }
             let result;
             try {
-                result = JSON.parse(output.output);
+                result = JSON.parse(resultText(event.result) ?? "");
             }
             catch {
-                throw new Error("Task result must be JSON structured report");
+                gate.cancel(event.sessionID, event.id);
+                throw new Error("Subagent result must be JSON structured report");
             }
-            gate.complete(input.sessionID, agent, result);
-        },
-    };
-});
-export const server = plugin;
-export default plugin;
+            try {
+                gate.complete(event.sessionID, args.agent, result, event.id);
+            }
+            finally {
+                gate.cancel(event.sessionID, event.id);
+            }
+        });
+    },
+};

package/dist/installer.d.ts

@@ -1,3 +1,4 @@
+import { type AgentProfileRequest } from "./agent-profiles.js";
 import { LifecycleError, type FileMutation, type Scope, type TransactionOptions } from "./lifecycle.js";
 import { CATALOG } from "./catalog.js";
 import { type FixedAgentRole } from "./agent-profiles.js";
@@ -30,6 +31,24 @@ export type Plan = {
         applied?: "changed" | "unchanged" | "skipped";
     };
     requires_restart: boolean;
+    digest: string;
+};
+type ManifestFile = {
+    sha256: string;
+    mode: number;
+    kind: "command" | "agent" | "plugin" | "state";
+};
+type Manifest = {
+    schema_version: 2;
+    package: string;
+    package_version: string;
+    version: string;
+    scope: Scope;
+    commands: string[];
+    agents: FixedAgentRole[];
+    plugins: SelectablePlugin[];
+    core_activation: boolean;
+    files: Record<string, ManifestFile>;
 };
 export type ArchiveCandidate = {
     path: string;
@@ -44,12 +63,16 @@ export type ArchiveCandidate = {
 export declare const SELECTABLE_PLUGINS: SelectablePlugin[];
 export declare const SKILL_COMMANDS: string[];
 export declare function defaultSelection(): InstallerSelection;
+export declare function savedSelection(manifest: Pick<Manifest, "commands" | "agents" | "plugins">): Partial<InstallerSelection>;
+export declare function installedSelection(scope: Scope, cwd?: string, home?: string, overrides?: Partial<InstallerSelection>): Promise<InstallerSelection | null>;
+export declare function coreSelectionMutation(root: string, enabled: boolean): Promise<FileMutation | undefined>;
 export declare function normalizeSelection(value?: Partial<InstallerSelection>): InstallerSelection;
 export declare class InstallerError extends LifecycleError {
 }
 export declare function archiveMutations(candidates: readonly ArchiveCandidate[], scope: Scope, cwd: string, home: string, sourceVersion: string, timestamp?: string): Promise<FileMutation[]>;
-export declare function preview(action: Action, scope: Scope, cwd?: string, home?: string, selection?: Partial<InstallerSelection>, provisionDependency?: boolean): Promise<Plan>;
+export declare function preview(action: Action, scope: Scope, cwd?: string, home?: string, selection?: Partial<InstallerSelection>, provisionDependency?: boolean, profileChanges?: AgentProfileRequest[]): Promise<Plan>;
 export declare function apply(action: Action, scope: Scope, cwd?: string, home?: string, options?: TransactionOptions & {
     dependencyRunner?: DependencyRunner;
-}, selection?: Partial<InstallerSelection>, provisionDependency?: boolean): Promise<Plan>;
+    expectedDigest?: string;
+}, selection?: Partial<InstallerSelection>, provisionDependency?: boolean, profileChanges?: AgentProfileRequest[]): Promise<Plan>;
 export declare function result(plan: Plan, applied: boolean): string;