@kisev/skills-opencode 1.0.0 → 1.1.1

package/dist/cli-output.d.ts

@@ -0,0 +1,11 @@
+import type { AgentInventory, AgentProfilePlan } from "./agent-profiles.js";
+import type { Plan as InstallerPlan } from "./installer.js";
+type DisplayPlan = InstallerPlan | AgentProfilePlan;
+export declare function terminalSafe(value: string): string;
+export declare function renderPlan(plan: DisplayPlan, options: {
+    applied: boolean;
+    confirmationCommand?: string;
+}): string;
+export declare function renderInventory(inventory: AgentInventory): string;
+export declare function shellCommand(arguments_: readonly string[]): string;
+export {};

package/dist/cli-output.js

@@ -0,0 +1,149 @@
+const GROUPS = ["Agents", "Commands", "Plugins", "State"];
+const OPERATIONS = ["create", "update", "remove", "conflict", "missing", "unchanged"];
+const UNSAFE_TERMINAL_CHARACTER = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+export function terminalSafe(value) {
+    return [...value]
+        .map((character) => {
+        const code = character.codePointAt(0);
+        const unsafe = character === "\\" || UNSAFE_TERMINAL_CHARACTER.test(character);
+        if (!unsafe)
+            return character;
+        if (character === "\\")
+            return "\\\\";
+        if (character === "\n")
+            return "\\n";
+        if (character === "\r")
+            return "\\r";
+        if (character === "\t")
+            return "\\t";
+        if (code <= 0xff)
+            return `\\x${code.toString(16).padStart(2, "0")}`;
+        if (code <= 0xffff)
+            return `\\u${code.toString(16).padStart(4, "0")}`;
+        return `\\u{${code.toString(16)}}`;
+    })
+        .join("");
+}
+function groupFor(path) {
+    if (path.startsWith("agents/"))
+        return "Agents";
+    if (path.startsWith("commands/"))
+        return "Commands";
+    if (path.startsWith("plugins/"))
+        return "Plugins";
+    return "State";
+}
+function actionName(action) {
+    return {
+        install: "Install",
+        uninstall: "Uninstall",
+        "model-set": "Configure agent model",
+        "critic-add": "Add critic",
+        "critic-remove": "Remove critic",
+        reconcile: "Reconcile agents",
+    }[action];
+}
+function operationSummary(operations) {
+    return OPERATIONS.map((operation) => {
+        const count = operations.filter((item) => item.operation === operation).length;
+        return count ? `${operation} ${count}` : undefined;
+    })
+        .filter(Boolean)
+        .join(", ");
+}
+function shortPath(path, group) {
+    if (group === "State")
+        return terminalSafe(path);
+    const value = path.slice(path.indexOf("/") + 1);
+    return terminalSafe(value.endsWith(".md") || value.endsWith(".js") ? value.slice(0, -3) : value);
+}
+function detailLines(operations) {
+    const lines = [];
+    for (const group of GROUPS) {
+        const grouped = operations.filter((item) => groupFor(item.path) === group && item.operation !== "unchanged");
+        for (const operation of OPERATIONS.filter((value) => value !== "unchanged" && grouped.some((item) => item.operation === value))) {
+            const values = grouped
+                .filter((item) => item.operation === operation)
+                .map((item) => operation === "conflict"
+                ? `${shortPath(item.path, group)} (${terminalSafe(item.reason ?? "conflict")})`
+                : shortPath(item.path, group));
+            const visible = operation === "conflict" ? values : values.slice(0, 8);
+            const rest = values.length - visible.length;
+            lines.push(`  ${group}/${operation}: ${visible.join(", ")}${rest ? ` (+${rest} more)` : ""}`);
+        }
+    }
+    return lines;
+}
+function migrationSummary(operations) {
+    const count = operations.filter((item) => item.reason === "v1.0.0 ownership transfer").length;
+    return count
+        ? `  Ownership migration: ${count} agent${count === 1 ? "" : "s"} from v1.0.0`
+        : undefined;
+}
+export function renderPlan(plan, options) {
+    const version = "package_version" in plan ? ` @kisev/skills-opencode ${plan.package_version}` : "";
+    const lines = [
+        `${actionName(plan.action)}${version} (${plan.scope})`,
+        `Target: ${terminalSafe(plan.root)}`,
+        "",
+        options.applied ? "Applied changes:" : "Planned changes:",
+    ];
+    for (const group of GROUPS) {
+        const operations = plan.operations.filter((item) => groupFor(item.path) === group);
+        if (operations.length)
+            lines.push(`  ${group}: ${operationSummary(operations)}`);
+    }
+    const migration = migrationSummary(plan.operations);
+    if (migration)
+        lines.push(migration);
+    const details = detailLines(plan.operations);
+    if (details.length)
+        lines.push("", "Details:", ...details);
+    const conflicts = plan.operations.filter((item) => item.operation === "conflict").length;
+    lines.push("", `Conflicts: ${conflicts || "none"}`);
+    lines.push(options.applied
+        ? `Restart required: ${plan.requires_restart ? "yes" : "no"}`
+        : `Restart after apply: ${plan.requires_restart ? "yes" : "no"}`);
+    if (!options.applied) {
+        if (plan.receipt_expires_at)
+            lines.push(`Confirmation expires: ${plan.receipt_expires_at}`);
+        lines.push(`Digest: ${plan.digest}`);
+        if (options.confirmationCommand)
+            lines.push("", "Apply:", `  ${options.confirmationCommand}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function table(rows) {
+    const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => row[column]?.length ?? 0)));
+    return rows.map((row) => row
+        .map((value, column) => value.padEnd(widths[column]))
+        .join("  ")
+        .trimEnd());
+}
+export function renderInventory(inventory) {
+    const rows = [
+        ["NAME", "MODEL", "VARIANT", "OWNER", "STATE"],
+        ...inventory.profiles.map((profile) => [
+            terminalSafe(profile.name),
+            terminalSafe(profile.model ?? "default"),
+            terminalSafe(profile.variant ?? "-"),
+            profile.ownership,
+            profile.state,
+        ]),
+    ];
+    return `${[
+        `OpenCode agents (${inventory.scope})`,
+        `Target: ${terminalSafe(inventory.root)}`,
+        "",
+        ...table(rows),
+        "",
+        `Critic pool: ${inventory.critic_pool.map(terminalSafe).join(", ")}`,
+        `Collisions: ${inventory.collisions.length ? inventory.collisions.map(terminalSafe).join(", ") : "none"}`,
+        `Drift: ${inventory.drift.length ? inventory.drift.map(terminalSafe).join(", ") : "none"}`,
+    ].join("\n")}\n`;
+}
+export function shellCommand(arguments_) {
+    return ["npm", "exec", "--", "skills-opencode", ...arguments_]
+        .map((value) => /^[A-Za-z0-9_./:@=-]+$/.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`)
+        .join(" ");
+}

package/dist/cli.js

@@ -1,56 +1,265 @@
 #!/usr/bin/env node
-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 { createInterface } from "node:readline/promises";
+import { AgentProfileError, applyAgentProfileChange, availableModels, availableModelVariants, FIXED_AGENT_ROLES, listAgentProfiles, previewAgentProfileChange, validateAgentName, validateModel, validateVariant, } from "./agent-profiles.js";
+import { renderInventory, renderPlan, shellCommand, terminalSafe } from "./cli-output.js";
+import { apply, InstallerError, preview } from "./installer.js";
+import { LifecycleError } from "./lifecycle.js";
+function parseOptions(values) {
+    const options = { dryRun: false, json: 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 if (value === "--json") {
+            if (options.json)
+                throw new InstallerError("invalid_input", "--json may be supplied once");
+            options.json = true;
+        }
         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);
+        }
+        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);
+        if (options.json)
+            process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, requires_restart: false, plan }, null, 2)}\n`);
+        else
+            process.stdout.write(renderPlan(plan, { applied: false, confirmationCommand: shellCommand(profileConfirmationArguments(request, options.scope, plan.digest)) }));
+    }
+    else {
+        const applied = await applyAgentProfileChange(request, options.scope, options.confirm);
+        if (options.json)
+            process.stdout.write(`${JSON.stringify(applied, null, 2)}\n`);
+        else
+            process.stdout.write(renderPlan(applied.plan, { applied: true }));
+    }
+}
+function profileConfirmationArguments(request, scope, digest) {
+    if (request.action === "reconcile")
+        return ["agent", "reconcile", "--scope", scope, "--confirm", digest];
+    if (request.action === "critic-remove")
+        return ["critic", "remove", request.name, "--scope", scope, "--confirm", digest];
+    const command = request.action === "critic-add" ? ["critic", "add", request.name] : ["agent", "model-set", request.name];
+    command.push("--scope", scope, "--model", request.model);
+    if (request.variant)
+        command.push("--variant", request.variant);
+    else if (request.action === "model-set")
+        command.push("--clear-variant");
+    command.push("--confirm", digest);
+    return command;
+}
+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;
+        if (options.dryRun) {
+            const plan = await preview(action, options.scope);
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, requires_restart: false, plan }, null, 2)}\n`);
+            else
+                process.stdout.write(renderPlan(plan, { applied: false, confirmationCommand: shellCommand([action, "--scope", options.scope, "--confirm", plan.digest]) }));
+        }
+        else {
+            const plan = await apply(action, options.scope, options.confirm);
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ status: "ok", applied: true, requires_restart: plan.requires_restart, plan }, null, 2)}\n`);
+            else
+                process.stdout.write(renderPlan(plan, { applied: true }));
+        }
+        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");
+        const inventory = await listAgentProfiles(options.scope);
+        if (options.json)
+            process.stdout.write(`${JSON.stringify({ status: "ok", inventory }, null, 2)}\n`);
+        else
+            process.stdout.write(renderInventory(inventory));
+        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);
         }
-        process.stdout.write(`${result(await apply(parsed.action, parsed.scope, parsed.confirm), true)}\n`);
+        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));
-        process.stdout.write(`${JSON.stringify({ status: "error", error: { code: known.code, message: known.message } })}\n`);
+        const known = error instanceof LifecycleError ? error : new InstallerError("internal_error", error instanceof Error ? error.message : String(error));
+        if (process.argv.includes("--json"))
+            process.stdout.write(`${JSON.stringify({ status: "error", error: { code: known.code, message: known.message } })}\n`);
+        else
+            process.stderr.write(`Error [${known.code}]: ${terminalSafe(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;