oh-my-opencode-serverlocal 0.1.0

package/dist/cli/install.d.ts

@@ -0,0 +1,7 @@
+import type { InstallArgs, InstallConfig } from './types';
+export declare function configureBackgroundSubagents(config: InstallConfig): Promise<{
+    enabledNow: boolean;
+    configuredTarget?: string;
+}>;
+export declare function shouldInstallCompanion(config: InstallConfig): Promise<boolean>;
+export declare function install(args: InstallArgs): Promise<number>;

package/dist/cli/model-key-normalization.d.ts

@@ -0,0 +1 @@
+export declare function buildModelKeyAliases(input: string): string[];

package/dist/cli/paths.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Get the OpenCode plugin config directory.
+ *
+ * Resolution order:
+ * 1. OPENCODE_CONFIG_DIR (custom OpenCode directory)
+ * 2. XDG_CONFIG_HOME/opencode
+ * 3. ~/.config/opencode
+ */
+export declare function getConfigDir(): string;
+/**
+ * Get OpenCode config directories in read/search order.
+ *
+ * Resolution order:
+ * 1. OPENCODE_CONFIG_DIR (if set)
+ * 2. XDG_CONFIG_HOME/opencode or ~/.config/opencode
+ *
+ * Duplicate entries are removed.
+ */
+export declare function getConfigSearchDirs(): string[];
+export declare function getOpenCodeConfigPaths(): string[];
+export declare function getConfigJson(): string;
+export declare function getConfigJsonc(): string;
+export declare function getLiteConfig(): string;
+export declare function getLiteConfigJsonc(): string;
+export declare function getTuiConfig(): string;
+export declare function getTuiConfigJsonc(): string;
+export declare function getExistingLiteConfigPath(): string;
+export declare function getExistingTuiConfigPath(): string;
+export declare function getExistingConfigPath(): string;
+export declare function ensureConfigDir(): void;
+export declare function ensureTuiConfigDir(): void;
+/**
+ * Ensure the directory for OpenCode's main config file exists.
+ */
+export declare function ensureOpenCodeConfigDir(): void;

package/dist/cli/providers.d.ts

@@ -0,0 +1,145 @@
+import type { InstallConfig } from './types';
+export declare const GENERATED_PRESETS: readonly ["openai", "opencode-go"];
+export declare const MODEL_MAPPINGS: {
+    readonly openai: {
+        readonly orchestrator: {
+            readonly model: "openai/gpt-5.6-terra";
+            readonly variant: "medium";
+        };
+        readonly oracle: {
+            readonly model: "openai/gpt-5.6-sol";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "openai/gpt-5.6-luna";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "openai/gpt-5.6-luna";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "openai/gpt-5.6-luna";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "openai/gpt-5.6-luna";
+            readonly variant: "medium";
+        };
+    };
+    readonly kimi: {
+        readonly orchestrator: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "max";
+        };
+        readonly oracle: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "kimi-for-coding/k2p5";
+            readonly variant: "low";
+        };
+    };
+    readonly copilot: {
+        readonly orchestrator: {
+            readonly model: "github-copilot/claude-opus-4.6";
+            readonly variant: "max";
+        };
+        readonly oracle: {
+            readonly model: "github-copilot/claude-opus-4.6";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "github-copilot/gemini-3.1-pro-preview";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "github-copilot/claude-sonnet-4.6";
+            readonly variant: "low";
+        };
+    };
+    readonly 'zai-plan': {
+        readonly orchestrator: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "max";
+        };
+        readonly oracle: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "zai-coding-plan/glm-5";
+            readonly variant: "low";
+        };
+    };
+    readonly 'opencode-go': {
+        readonly orchestrator: {
+            readonly model: "opencode-go/minimax-m3";
+            readonly variant: "max";
+        };
+        readonly oracle: {
+            readonly model: "opencode-go/qwen3.7-max";
+            readonly variant: "max";
+        };
+        readonly explorer: {
+            readonly model: "opencode-go/deepseek-v4-flash";
+            readonly variant: "max";
+        };
+        readonly librarian: {
+            readonly model: "opencode-go/deepseek-v4-flash";
+            readonly variant: "high";
+        };
+        readonly designer: {
+            readonly model: "opencode-go/kimi-k2.7-code";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "opencode-go/deepseek-v4-flash";
+            readonly variant: "high";
+        };
+        readonly observer: {
+            readonly model: "opencode-go/mimo-v2.5";
+            readonly variant: "max";
+        };
+    };
+};
+export type PresetName = keyof typeof MODEL_MAPPINGS;
+export type GeneratedPresetName = (typeof GENERATED_PRESETS)[number];
+export declare function isPresetName(value: string): value is PresetName;
+export declare function getPresetNames(): PresetName[];
+export declare function isGeneratedPresetName(value: string): value is GeneratedPresetName;
+export declare function getGeneratedPresetNames(): GeneratedPresetName[];
+export declare function generateLiteConfig(installConfig: InstallConfig): Record<string, unknown>;

package/dist/cli/skills.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A skill that is managed externally (e.g. user-installed) and needs
+ * permission grants but is NOT installed by this plugin's CLI.
+ */
+export interface PermissionOnlySkill {
+    /** Skill name - must match the name OpenCode uses for permission checks */
+    name: string;
+    /** List of agents that should auto-allow this skill */
+    allowedAgents: string[];
+    /** Human-readable description (for documentation only) */
+    description: string;
+}
+/**
+ * Skills managed externally (not installed by this plugin's CLI).
+ * Entries here only affect agent permission grants - nothing is installed.
+ */
+export declare const PERMISSION_ONLY_SKILLS: PermissionOnlySkill[];
+/**
+ * Get permission presets for a specific agent based on bundled skills.
+ * @param agentName - The name of the agent
+ * @param skillList - Optional explicit list of skills to allow (overrides defaults)
+ * @returns Permission rules for the skill permission type
+ */
+export declare function getSkillPermissionsForAgent(agentName: string, skillList?: string[], disabledSkillNames?: string[]): Record<string, 'allow' | 'ask' | 'deny'>;

package/dist/cli/system.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveOpenCodePath(): string;
+export declare function isOpenCodeInstalled(): Promise<boolean>;
+export declare function isTmuxInstalled(): Promise<boolean>;
+export declare function getOpenCodeVersion(): Promise<string | null>;
+export declare function getOpenCodePath(): string | null;
+export declare function fetchLatestVersion(packageName: string): Promise<string | null>;

package/dist/cli/types.d.ts

@@ -0,0 +1,47 @@
+export type BooleanArg = 'yes' | 'no';
+export type BackgroundSubagentsArg = 'ask' | 'yes' | 'no';
+export type CompanionArg = 'ask' | BooleanArg;
+export interface InstallArgs {
+    tui: boolean;
+    skills?: BooleanArg;
+    preset?: string;
+    dryRun?: boolean;
+    reset?: boolean;
+    backgroundSubagents?: BackgroundSubagentsArg;
+    backgroundSubagentsTarget?: string;
+    companion?: CompanionArg;
+}
+export interface OpenCodeConfig {
+    plugin?: unknown[];
+    provider?: Record<string, unknown>;
+    agent?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface InstallConfig {
+    hasTmux: boolean;
+    installCustomSkills: boolean;
+    preset?: string;
+    promptForStar?: boolean;
+    dryRun?: boolean;
+    reset: boolean;
+    backgroundSubagents: BackgroundSubagentsArg;
+    backgroundSubagentsTarget?: string;
+    companion?: CompanionArg;
+}
+export interface ConfigMergeResult {
+    success: boolean;
+    configPath: string;
+    error?: string;
+}
+export interface DetectedConfig {
+    isInstalled: boolean;
+    hasKimi: boolean;
+    hasOpenAI: boolean;
+    hasAnthropic?: boolean;
+    hasCopilot?: boolean;
+    hasZaiPlan?: boolean;
+    hasAntigravity: boolean;
+    hasChutes?: boolean;
+    hasOpencodeZen: boolean;
+    hasTmux: boolean;
+}

package/dist/companion/manager.d.ts

@@ -0,0 +1,50 @@
+import type { CompanionConfig } from '../config/schema';
+export declare function stateFilePath(): string;
+export declare function resolveCompanionBinaryPath(config?: CompanionConfig): string | null;
+/**
+ * Tracks live agent activity per session and mirrors it to the companion
+ * state file. Source of truth is OpenCode's session.status events: every
+ * spawned specialist (foreground or background) runs in its own session,
+ * which reports busy/idle independently. Tool-call lifecycles are NOT used
+ * because background Task launches return immediately while the agent keeps
+ * running in its child session.
+ */
+export declare class CompanionManager {
+    private readonly id;
+    private readonly cwd;
+    private status;
+    /** sessionId → agent name, for sessions currently busy. */
+    private readonly busyAgentSessions;
+    private readonly config?;
+    private companionProcess;
+    private wasSpawner;
+    private spawnedCompanionPid;
+    constructor(sessionId: string, cwd: string, config?: CompanionConfig);
+    onLoad(): void;
+    /**
+     * Register this manager behind a single process `exit` listener. Re-inits for
+     * the same OpenCode session dispose the superseded manager immediately so its
+     * detached child does not survive until process exit.
+     */
+    private registerActiveManager;
+    private static disposeActiveManagers;
+    /**
+     * Feed every session.status event here, with the agent name resolved
+     * from sessionAgentMap. Orchestrator sessions drive overall status;
+     * specialist sessions drive the per-agent GIF grid.
+     */
+    onSessionStatus(input: {
+        sessionId?: string;
+        agent?: string;
+        status?: string;
+    }): void;
+    onSessionDeleted(sessionId: string | undefined): void;
+    onWaitingInput(): void;
+    onInputResolved(): void;
+    onExit(): void;
+    private removeOwnedPidFileIfNoSessionsRemain;
+    /** One entry per running agent instance (two fixers → two cells). */
+    private activeAgents;
+    private flush;
+    private spawnIfAvailable;
+}

package/dist/companion/updater.d.ts

@@ -0,0 +1,36 @@
+import type { CompanionConfig } from '../config/schema';
+export interface CompanionManifest {
+    version: string;
+    tag: string;
+    repo: string;
+    checksums?: Record<string, string>;
+}
+export type CompanionUpdateResult = {
+    status: 'installed';
+    binaryPath: string;
+    version: string;
+} | {
+    status: 'current';
+    binaryPath: string;
+    version: string;
+} | {
+    status: 'skipped';
+    reason: string;
+    binaryPath?: string;
+} | {
+    status: 'failed';
+    error: string;
+    binaryPath: string;
+};
+export declare const COMPANION_MANIFEST: CompanionManifest;
+export declare function getCompanionTarget(): string | null;
+export declare function getCompanionBinaryPath(): string;
+export declare function loadCompanionManifestFromPackageRoot(packageRoot: string): CompanionManifest | null;
+export declare function ensureCompanionVersion(options: {
+    config?: CompanionConfig;
+    manifest?: CompanionManifest;
+    dryRun?: boolean;
+    downloadTimeoutMs?: number;
+    lockTimeoutMs?: number;
+    lockStaleMs?: number;
+}): Promise<CompanionUpdateResult>;

package/dist/config/agent-mcps.d.ts

@@ -0,0 +1,11 @@
+import { type AgentName, type PluginConfig } from '.';
+/** Default MCPs per agent - "*" means all MCPs, "!item" excludes specific MCPs */
+export declare const DEFAULT_AGENT_MCPS: Record<AgentName, string[]>;
+/**
+ * Parse a list with wildcard and exclusion syntax.
+ */
+export declare function parseList(items: string[], allAvailable: string[]): string[];
+/**
+ * Get the MCP list for an agent (from config or defaults).
+ */
+export declare function getAgentMcpList(agentName: string, config?: PluginConfig): string[];

package/dist/config/constants.d.ts

@@ -0,0 +1,38 @@
+export declare const AGENT_ALIASES: Record<string, string>;
+export declare const SUBAGENT_NAMES: readonly ["explorer", "librarian", "oracle", "designer", "fixer", "observer", "council", "councillor"];
+export declare const ALL_AGENT_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "fixer", "observer", "council", "councillor"];
+export type AgentName = (typeof ALL_AGENT_NAMES)[number];
+/** Agents that cannot be disabled even if listed in disabled_agents config. */
+export declare const PROTECTED_AGENTS: Set<string>;
+/**
+ * Default models for each agent.
+ * All set to undefined so agents follow the global/session model.
+ * Users can override per-agent via oh-my-opencode-slim.json agents.<name>.model.
+ */
+export declare const DEFAULT_MODELS: Record<AgentName, string | undefined>;
+export declare const POLL_INTERVAL_MS = 500;
+export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;
+export declare const MAX_POLL_TIME_MS: number;
+export declare const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+export declare const PHASE_REMINDER_TEXT = "!IMPORTANT! Scheduler workflow: First choose the lightest workflow that fits the work. If direct execution is justified, complete it and verify proportionately. Otherwise: plan lanes/dependencies \u2192 dispatch background specialists \u2192 track task IDs \u2192 wait for hook-driven completion \u2192 reconcile terminal results \u2192 verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!";
+export declare function formatSystemReminder(text: string): string;
+export declare const PHASE_REMINDER: string;
+export declare const WRITABLE_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- Prefer dedicated file tools for normal code work: glob/grep/ast_grep_search for discovery, read for file contents, and edit/write/apply_patch for targeted source changes.\n- Use bash for execution and automation: git, package managers, tests, builds, scripts, diagnostics, and shell-native filesystem operations.\n- Shell is acceptable for bulk or mechanical filesystem changes when it is clearer or safer than many individual edits (for example: truncate generated logs, remove build artifacts, batch rename/move files), especially when the user explicitly asks for that shell operation.\n- Before destructive or broad shell operations, verify the target set and quote paths. Prefer a dry-run/listing first when practical.\n- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.";
+export declare const READONLY_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- READ-ONLY: inspect and report; do not modify files.\n- Prefer dedicated file tools for codebase inspection: glob/grep/ast_grep_search for discovery and read for file contents.\n- Bash is allowed for non-mutating diagnostics and shell-native inspection when it is the clearest tool, but not for modifying files.\n- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.";
+export declare const NO_SHELL_READONLY_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- READ-ONLY: inspect and report; do not modify files.\n- Use glob/grep/ast_grep_search for discovery and read for file contents.\n- Do not use bash or shell commands.";
+export declare const TMUX_SPAWN_DELAY_MS = 500;
+export declare const COUNCILLOR_STAGGER_MS = 250;
+export declare const STABLE_POLLS_THRESHOLD = 3;
+/** Agents that are disabled by default. Users must explicitly enable them
+ *  by removing from disabled_agents and configuring an appropriate model. */
+export declare const DEFAULT_DISABLED_AGENTS: string[];
+export declare const DEFAULT_MAX_SESSIONS_PER_AGENT = 2;
+export declare const DEFAULT_READ_CONTEXT_MIN_LINES = 10;
+export declare const DEFAULT_READ_CONTEXT_MAX_FILES = 8;
+export type ImageRouting = 'auto' | 'direct';
+/**
+ * Used when image_routing is omitted, preserving legacy conditional Observer
+ * routing. Explicit "auto" is validated separately after config layers merge.
+ */
+export declare const DEFAULT_IMAGE_ROUTING: ImageRouting;
+export declare function resolveImageRouting(imageRouting: ImageRouting | undefined): ImageRouting;

package/dist/config/council-schema.d.ts

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+import { type CouncillorModelEntry } from '../utils/councillor-models';
+export type { CouncillorModelEntry };
+/**
+ * Configuration for a single councillor within a preset.
+ * Each councillor is an independent LLM that processes the same prompt.
+ *
+ * Councillors run as agent sessions with read-only codebase access
+ * (read, glob, grep, lsp, list). They can examine the codebase but
+ * cannot modify files or spawn subagents.
+ *
+ * `model` accepts a single ID or an ordered fallback chain. The parsed config
+ * exposes `models` (the normalized chain) plus `model` (the primary, for
+ * backward compatibility).
+ */
+export declare const CouncillorConfigSchema: z.ZodPipe<z.ZodObject<{
+    model: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>;
+    variant: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodTransform<{
+    model: string;
+    variant: string | undefined;
+    prompt: string | undefined;
+    models: CouncillorModelEntry[];
+}, {
+    model: string | (string | {
+        id: string;
+        variant?: string | undefined;
+    })[];
+    variant?: string | undefined;
+    prompt?: string | undefined;
+}>>;
+export type CouncillorConfig = z.infer<typeof CouncillorConfigSchema>;
+/**
+ * A named preset grouping several councillors.
+ *
+ * All keys are treated as councillor names mapping to councillor configs.
+ * The reserved key `"master"` is silently ignored (legacy from when
+ * council-master was a separate agent).
+ */
+export declare const CouncilPresetSchema: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>, z.ZodTransform<Record<string, {
+    model: string;
+    variant: string | undefined;
+    prompt: string | undefined;
+    models: CouncillorModelEntry[];
+}>, Record<string, Record<string, unknown>>>>;
+export type CouncilPreset = z.infer<typeof CouncilPresetSchema>;
+/**
+ * Execution mode for councillors.
+ * - parallel: Run all councillors concurrently (default, fastest for multi-model systems)
+ * - serial: Run councillors one at a time (required for single-model systems to avoid conflicts)
+ */
+export declare const CouncillorExecutionModeSchema: z.ZodDefault<z.ZodEnum<{
+    parallel: "parallel";
+    serial: "serial";
+}>>;
+/**
+ * Top-level council configuration.
+ *
+ * Example JSONC:
+ * ```jsonc
+ * {
+ *   "council": {
+ *     "presets": {
+ *       "default": {
+ *         "alpha": { "model": "openai/gpt-5.6-luna" },
+ *         "beta":  { "model": "openai/gpt-5.3-codex" },
+ *         "gamma": { "model": "google/gemini-3-pro" }
+ *       }
+ *     },
+ *     "timeout": 180000,
+ *     "councillor_execution_mode": "serial"
+ *   }
+ * }
+ * ```
+ */
+export declare const CouncilConfigSchema: z.ZodPipe<z.ZodObject<{
+    presets: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>, z.ZodTransform<Record<string, {
+        model: string;
+        variant: string | undefined;
+        prompt: string | undefined;
+        models: CouncillorModelEntry[];
+    }>, Record<string, Record<string, unknown>>>>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    default_preset: z.ZodDefault<z.ZodString>;
+    councillor_execution_mode: z.ZodDefault<z.ZodEnum<{
+        parallel: "parallel";
+        serial: "serial";
+    }>>;
+    councillor_retries: z.ZodDefault<z.ZodNumber>;
+    master: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodTransform<{
+    presets: Record<string, Record<string, {
+        model: string;
+        variant: string | undefined;
+        prompt: string | undefined;
+        models: CouncillorModelEntry[];
+    }>>;
+    timeout: number;
+    default_preset: string;
+    councillor_execution_mode: "parallel" | "serial";
+    councillor_retries: number;
+    _deprecated: string[] | undefined;
+    _legacyMasterModel: string | undefined;
+}, {
+    presets: Record<string, Record<string, {
+        model: string;
+        variant: string | undefined;
+        prompt: string | undefined;
+        models: CouncillorModelEntry[];
+    }>>;
+    timeout: number;
+    default_preset: string;
+    councillor_execution_mode: "parallel" | "serial";
+    councillor_retries: number;
+    master?: unknown;
+}>>;
+export type CouncilConfig = z.infer<typeof CouncilConfigSchema>;
+export type CouncillorExecutionMode = z.infer<typeof CouncillorExecutionModeSchema>;
+/**
+ * Result of a council session.
+ */
+export interface CouncilResult {
+    success: boolean;
+    result?: string;
+    error?: string;
+    councillorResults: Array<{
+        name: string;
+        model: string;
+        status: 'completed' | 'failed' | 'timed_out';
+        result?: string;
+        error?: string;
+    }>;
+}

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './council-schema';
+export { deepMerge, loadAgentPrompt, loadPluginConfig, } from './loader';
+export * from './schema';
+export { getAcpAgentNames, getAgentOverride, getCustomAgentNames, } from './utils';

package/dist/config/loader.d.ts

@@ -0,0 +1,88 @@
+import { type PluginConfig } from './schema';
+/**
+ * Warning kinds produced during config loading.
+ */
+export type ConfigLoadWarningKind = 'invalid-json' | 'invalid-schema' | 'read-error' | 'missing-preset';
+/**
+ * A warning emitted while loading plugin configuration.
+ */
+export interface ConfigLoadWarning {
+    path: string;
+    kind: ConfigLoadWarningKind;
+    message: string;
+    formatted?: unknown;
+}
+/**
+ * Options for loadPluginConfig.
+ */
+export interface LoadPluginConfigOptions {
+    /**
+     * Called with a warning whenever config loading produces a non-fatal issue.
+     * The loader still falls back to defaults and continues normally.
+     */
+    onWarning?: (warning: ConfigLoadWarning) => void;
+    /**
+     * Suppress console warnings while still invoking onWarning.
+     */
+    silent?: boolean;
+}
+/**
+ * Find plugin config paths (user and project) for a given directory.
+ * User config uses getConfigSearchDirs() for lookup.
+ * Project config uses <directory>/.opencode/oh-my-opencode-slim.
+ *
+ * @param directory - Project directory to search for .opencode config
+ * @returns Object with userConfigPath and projectConfigPath (null if not found)
+ */
+export declare function findPluginConfigPaths(directory: string): {
+    userConfigPath: string | null;
+    projectConfigPath: string | null;
+};
+/**
+ * Merge two plugin configs using the loader's merge rules.
+ * Project/override takes precedence over base.
+ */
+export declare function mergePluginConfigs(base: PluginConfig, override: PluginConfig): PluginConfig;
+/**
+ * Recursively merge two objects, with override values taking precedence.
+ * For nested objects, merges recursively. For arrays and primitives, override replaces base.
+ *
+ * @param base - Base object to merge into
+ * @param override - Override object whose values take precedence
+ * @returns Merged object, or undefined if both inputs are undefined
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(base?: T, override?: T): T | undefined;
+/**
+ * Load plugin configuration from user and project config files, merging them appropriately.
+ *
+ * Configuration is loaded from two locations:
+ * 1. User config: $OPENCODE_CONFIG_DIR/oh-my-opencode-slim.jsonc or .json,
+ *    or ~/.config/opencode/oh-my-opencode-slim.jsonc or .json (or $XDG_CONFIG_HOME)
+ * 2. Project config: <directory>/.opencode/oh-my-opencode-slim.jsonc or .json
+ *
+ * JSONC format is preferred over JSON (allows comments and trailing commas).
+ * Project config takes precedence over user config. Nested objects (agents, tmux) are
+ * deep-merged, while top-level arrays are replaced entirely by project config.
+ *
+ * @param directory - Project directory to search for .opencode config
+ * @param options - Optional load options including onWarning callback
+ * @returns Merged plugin configuration (empty object if no configs found)
+ */
+export declare function loadPluginConfig(directory: string, options?: LoadPluginConfigOptions): PluginConfig;
+/**
+ * Load custom prompt for an agent from the prompts directory.
+ * Checks for {agent}.md (replaces default) and {agent}_append.md (appends to default).
+ * If preset is provided and safe for paths, it first checks {preset}/ subdirectory,
+ * then falls back to the root prompts directory.
+ *
+ * @param agentName - Name of the agent (e.g., "orchestrator", "explorer")
+ * @param optionsOrPreset - Optional preset name or options configuration
+ * @returns Object with prompt and/or appendPrompt if files exist
+ */
+export declare function loadAgentPrompt(agentName: string, optionsOrPreset?: string | {
+    preset?: string;
+    projectDirectory?: string;
+}): {
+    prompt?: string;
+    appendPrompt?: string;
+};

package/dist/config/runtime-preset.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Module-level runtime preset state.
+ *
+ * Survives plugin re-inits triggered by client.config.update() →
+ * Instance.dispose(). The plugin function re-runs but this module-level
+ * variable persists within the same Node.js process.
+ */
+export declare function setActiveRuntimePreset(name: string | null): void;
+export declare function getActiveRuntimePreset(): string | null;
+export declare function getPreviousRuntimePreset(): string | null;
+export declare function setActiveRuntimePresetWithPrevious(name: string | null): void;