oh-my-opencode-slim 0.6.4 → 0.8.0

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

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

package/dist/cli/model-selection.d.ts

@@ -0,0 +1,30 @@
+export interface ModelSelectionCandidate {
+    model: string;
+    status?: 'alpha' | 'beta' | 'deprecated' | 'active';
+    contextLimit?: number;
+    outputLimit?: number;
+    reasoning?: boolean;
+    toolcall?: boolean;
+    attachment?: boolean;
+    tags?: string[];
+    meta?: Record<string, unknown>;
+}
+export interface RankedModel<T extends ModelSelectionCandidate> {
+    candidate: T;
+    score: number;
+}
+export interface SelectionOptions<T extends ModelSelectionCandidate> {
+    excludeModels?: string[];
+    tieBreaker?: (left: T, right: T) => number;
+}
+export type ScoreFunction<T extends ModelSelectionCandidate> = (candidate: T) => number;
+export interface RoleScoring<T extends ModelSelectionCandidate> {
+    primary: ScoreFunction<T>;
+    support: ScoreFunction<T>;
+}
+export declare function rankModels<T extends ModelSelectionCandidate>(models: T[], scoreFn: ScoreFunction<T>, options?: SelectionOptions<T>): RankedModel<T>[];
+export declare function pickBestModel<T extends ModelSelectionCandidate>(models: T[], scoreFn: ScoreFunction<T>, options?: SelectionOptions<T>): T | null;
+export declare function pickPrimaryAndSupport<T extends ModelSelectionCandidate>(models: T[], scoring: RoleScoring<T>, preferredPrimaryModel?: string): {
+    primary: T | null;
+    support: T | null;
+};

package/dist/cli/opencode-models.d.ts

@@ -0,0 +1,18 @@
+import type { DiscoveredModel, OpenCodeFreeModel } from './types';
+export declare function parseOpenCodeModelsVerboseOutput(output: string, providerFilter?: string, freeOnly?: boolean): DiscoveredModel[];
+export declare function discoverModelCatalog(): Promise<{
+    models: DiscoveredModel[];
+    error?: string;
+}>;
+export declare function discoverOpenCodeFreeModels(): Promise<{
+    models: OpenCodeFreeModel[];
+    error?: string;
+}>;
+export declare function discoverProviderFreeModels(providerID: string): Promise<{
+    models: OpenCodeFreeModel[];
+    error?: string;
+}>;
+export declare function discoverProviderModels(providerID: string): Promise<{
+    models: DiscoveredModel[];
+    error?: string;
+}>;

package/dist/cli/opencode-selection.d.ts

@@ -0,0 +1,3 @@
+import type { OpenCodeFreeModel } from './types';
+export declare function pickBestCodingOpenCodeModel(models: OpenCodeFreeModel[]): OpenCodeFreeModel | null;
+export declare function pickSupportOpenCodeModel(models: OpenCodeFreeModel[], primaryModel?: string): OpenCodeFreeModel | null;

package/dist/cli/paths.d.ts

@@ -3,5 +3,7 @@ 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 getExistingLiteConfigPath(): string;
 export declare function getExistingConfigPath(): string;
 export declare function ensureConfigDir(): void;

package/dist/cli/precedence-resolver.d.ts

@@ -0,0 +1,16 @@
+import type { AgentResolutionProvenance } from './types';
+export interface AgentLayerInput {
+    agentName: string;
+    openCodeDirectOverride?: string;
+    manualUserPlan?: string[];
+    pinnedModel?: string;
+    dynamicRecommendation?: string[];
+    providerFallbackPolicy?: string[];
+    systemDefault: string[];
+}
+export interface ResolvedAgentLayerResult {
+    model: string;
+    chain: string[];
+    provenance: AgentResolutionProvenance;
+}
+export declare function resolveAgentWithPrecedence(input: AgentLayerInput): ResolvedAgentLayerResult;

package/dist/cli/providers.d.ts

@@ -27,10 +27,10 @@ export declare const MODEL_MAPPINGS: {
     };
     readonly openai: {
         readonly orchestrator: {
-            readonly model: "openai/gpt-5.2-codex";
+            readonly model: "openai/gpt-5.3-codex";
         };
         readonly oracle: {
-            readonly model: "openai/gpt-5.2-codex";
+            readonly model: "openai/gpt-5.3-codex";
             readonly variant: "high";
         };
         readonly librarian: {
@@ -50,6 +50,130 @@ export declare const MODEL_MAPPINGS: {
             readonly variant: "low";
         };
     };
+    readonly anthropic: {
+        readonly orchestrator: {
+            readonly model: "anthropic/claude-opus-4-6";
+        };
+        readonly oracle: {
+            readonly model: "anthropic/claude-opus-4-6";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "anthropic/claude-sonnet-4-5";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "anthropic/claude-haiku-4-5";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "anthropic/claude-sonnet-4-5";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "anthropic/claude-sonnet-4-5";
+            readonly variant: "low";
+        };
+    };
+    readonly copilot: {
+        readonly orchestrator: {
+            readonly model: "github-copilot/grok-code-fast-1";
+        };
+        readonly oracle: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            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/grok-code-fast-1";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "github-copilot/grok-code-fast-1";
+            readonly variant: "low";
+        };
+    };
+    readonly 'zai-plan': {
+        readonly orchestrator: {
+            readonly model: "zai-coding-plan/glm-4.7";
+        };
+        readonly oracle: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "zai-coding-plan/glm-4.7";
+            readonly variant: "low";
+        };
+    };
+    readonly antigravity: {
+        readonly orchestrator: {
+            readonly model: "google/antigravity-gemini-3-flash";
+        };
+        readonly oracle: {
+            readonly model: "google/antigravity-gemini-3-pro";
+        };
+        readonly librarian: {
+            readonly model: "google/antigravity-gemini-3-flash";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "google/antigravity-gemini-3-flash";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "google/antigravity-gemini-3-flash";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "google/antigravity-gemini-3-flash";
+            readonly variant: "low";
+        };
+    };
+    readonly chutes: {
+        readonly orchestrator: {
+            readonly model: "chutes/kimi-k2.5";
+        };
+        readonly oracle: {
+            readonly model: "chutes/kimi-k2.5";
+            readonly variant: "high";
+        };
+        readonly librarian: {
+            readonly model: "chutes/minimax-m2.1";
+            readonly variant: "low";
+        };
+        readonly explorer: {
+            readonly model: "chutes/minimax-m2.1";
+            readonly variant: "low";
+        };
+        readonly designer: {
+            readonly model: "chutes/kimi-k2.5";
+            readonly variant: "medium";
+        };
+        readonly fixer: {
+            readonly model: "chutes/minimax-m2.1";
+            readonly variant: "low";
+        };
+    };
     readonly 'zen-free': {
         readonly orchestrator: {
             readonly model: "opencode/big-pickle";
@@ -76,4 +200,5 @@ export declare const MODEL_MAPPINGS: {
         };
     };
 };
+export declare function generateAntigravityMixedPreset(config: InstallConfig, existingPreset?: Record<string, unknown>): Record<string, unknown>;
 export declare function generateLiteConfig(installConfig: InstallConfig): Record<string, unknown>;

package/dist/cli/scoring-v2/engine.d.ts

@@ -0,0 +1,4 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+import type { ScoredCandidate, ScoringAgentName } from './types';
+export declare function scoreCandidateV2(model: DiscoveredModel, agent: ScoringAgentName, externalSignals?: ExternalSignalMap): ScoredCandidate;
+export declare function rankModelsV2(models: DiscoveredModel[], agent: ScoringAgentName, externalSignals?: ExternalSignalMap): ScoredCandidate[];

package/dist/cli/scoring-v2/features.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+import type { FeatureVector, ScoringAgentName } from './types';
+export declare function extractFeatureVector(model: DiscoveredModel, agent: ScoringAgentName, externalSignals?: ExternalSignalMap): FeatureVector;

package/dist/cli/scoring-v2/index.d.ts

@@ -0,0 +1,4 @@
+export { rankModelsV2, scoreCandidateV2 } from './engine';
+export { extractFeatureVector } from './features';
+export type { FeatureVector, ScoredCandidate, ScoringAgentName, } from './types';
+export { getFeatureWeights } from './weights';

package/dist/cli/scoring-v2/types.d.ts

@@ -0,0 +1,17 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+export type ScoreFeatureName = 'status' | 'context' | 'output' | 'versionBonus' | 'reasoning' | 'toolcall' | 'attachment' | 'quality' | 'coding' | 'latencyPenalty' | 'pricePenalty';
+export type FeatureVector = Record<ScoreFeatureName, number>;
+export type FeatureWeights = Record<ScoreFeatureName, number>;
+export type ScoringAgentName = 'orchestrator' | 'oracle' | 'designer' | 'explorer' | 'librarian' | 'fixer';
+export interface ScoringContext {
+    agent: ScoringAgentName;
+    externalSignals?: ExternalSignalMap;
+}
+export interface ScoredCandidate {
+    model: DiscoveredModel;
+    totalScore: number;
+    scoreBreakdown: {
+        features: FeatureVector;
+        weighted: FeatureVector;
+    };
+}

package/dist/cli/scoring-v2/weights.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureWeights, ScoringAgentName } from './types';
+export declare function getFeatureWeights(agent: ScoringAgentName): FeatureWeights;

package/dist/cli/system.d.ts

@@ -1,4 +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

@@ -3,9 +3,86 @@ export interface InstallArgs {
     tui: boolean;
     kimi?: BooleanArg;
     openai?: BooleanArg;
+    anthropic?: BooleanArg;
+    copilot?: BooleanArg;
+    zaiPlan?: BooleanArg;
+    antigravity?: BooleanArg;
+    chutes?: BooleanArg;
     tmux?: BooleanArg;
     skills?: BooleanArg;
+    opencodeFree?: BooleanArg;
+    balancedSpend?: BooleanArg;
+    opencodeFreeModel?: string;
+    aaKey?: string;
+    openrouterKey?: string;
+    dryRun?: boolean;
+    modelsOnly?: boolean;
 }
+export interface OpenCodeFreeModel {
+    providerID: string;
+    model: string;
+    name: string;
+    status: 'alpha' | 'beta' | 'deprecated' | 'active';
+    contextLimit: number;
+    outputLimit: number;
+    reasoning: boolean;
+    toolcall: boolean;
+    attachment: boolean;
+    dailyRequestLimit?: number;
+}
+export interface DiscoveredModel {
+    providerID: string;
+    model: string;
+    name: string;
+    status: 'alpha' | 'beta' | 'deprecated' | 'active';
+    contextLimit: number;
+    outputLimit: number;
+    reasoning: boolean;
+    toolcall: boolean;
+    attachment: boolean;
+    dailyRequestLimit?: number;
+    costInput?: number;
+    costOutput?: number;
+}
+export interface DynamicAgentAssignment {
+    model: string;
+    variant?: string;
+}
+export type ScoringEngineVersion = 'v1' | 'v2-shadow' | 'v2';
+export type ResolutionLayerName = 'opencode-direct-override' | 'manual-user-plan' | 'pinned-model' | 'dynamic-recommendation' | 'provider-fallback-policy' | 'system-default';
+export interface AgentResolutionProvenance {
+    winnerLayer: ResolutionLayerName;
+    winnerModel: string;
+}
+export interface DynamicPlanScoringMeta {
+    engineVersionApplied: 'v1' | 'v2';
+    shadowCompared: boolean;
+    diffs?: Record<string, {
+        v1TopModel?: string;
+        v2TopModel?: string;
+    }>;
+}
+export interface DynamicModelPlan {
+    agents: Record<string, DynamicAgentAssignment>;
+    chains: Record<string, string[]>;
+    provenance?: Record<string, AgentResolutionProvenance>;
+    scoring?: DynamicPlanScoringMeta;
+}
+export interface ExternalModelSignal {
+    qualityScore?: number;
+    codingScore?: number;
+    latencySeconds?: number;
+    inputPricePer1M?: number;
+    outputPricePer1M?: number;
+    source: 'artificial-analysis' | 'openrouter' | 'merged';
+}
+export type ExternalSignalMap = Record<string, ExternalModelSignal>;
+export type ManualAgentConfig = {
+    primary: string;
+    fallback1: string;
+    fallback2: string;
+    fallback3: string;
+};
 export interface OpenCodeConfig {
     plugin?: string[];
     provider?: Record<string, unknown>;
@@ -15,10 +92,32 @@ export interface OpenCodeConfig {
 export interface InstallConfig {
     hasKimi: boolean;
     hasOpenAI: boolean;
+    hasAnthropic?: boolean;
+    hasCopilot?: boolean;
+    hasZaiPlan?: boolean;
+    hasAntigravity: boolean;
+    hasChutes?: boolean;
     hasOpencodeZen: boolean;
+    useOpenCodeFreeModels?: boolean;
+    preferredOpenCodeModel?: string;
+    selectedOpenCodePrimaryModel?: string;
+    selectedOpenCodeSecondaryModel?: string;
+    availableOpenCodeFreeModels?: OpenCodeFreeModel[];
+    selectedChutesPrimaryModel?: string;
+    selectedChutesSecondaryModel?: string;
+    availableChutesModels?: DiscoveredModel[];
+    dynamicModelPlan?: DynamicModelPlan;
+    scoringEngineVersion?: ScoringEngineVersion;
+    artificialAnalysisApiKey?: string;
+    openRouterApiKey?: string;
+    balanceProviderUsage?: boolean;
     hasTmux: boolean;
     installSkills: boolean;
     installCustomSkills: boolean;
+    setupMode: 'quick' | 'manual';
+    manualAgentConfigs?: Record<string, ManualAgentConfig>;
+    dryRun?: boolean;
+    modelsOnly?: boolean;
 }
 export interface ConfigMergeResult {
     success: boolean;
@@ -29,6 +128,11 @@ 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/config/constants.d.ts

@@ -3,10 +3,12 @@ export declare const SUBAGENT_NAMES: readonly ["explorer", "librarian", "oracle"
 export declare const ORCHESTRATOR_NAME: "orchestrator";
 export declare const ALL_AGENT_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "fixer"];
 export type AgentName = (typeof ALL_AGENT_NAMES)[number];
+export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
 export declare const DEFAULT_MODELS: Record<AgentName, string>;
 export declare const POLL_INTERVAL_MS = 500;
 export declare const POLL_INTERVAL_SLOW_MS = 1000;
 export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;
 export declare const DEFAULT_TIMEOUT_MS: number;
 export declare const MAX_POLL_TIME_MS: number;
+export declare const FALLBACK_FAILOVER_TIMEOUT_MS = 15000;
 export declare const STABLE_POLLS_THRESHOLD = 3;

package/dist/config/loader.d.ts

@@ -3,9 +3,10 @@ import { type PluginConfig } from './schema';
  * Load plugin configuration from user and project config files, merging them appropriately.
  *
  * Configuration is loaded from two locations:
- * 1. User config: ~/.config/opencode/oh-my-opencode-slim.json (or $XDG_CONFIG_HOME)
- * 2. Project config: <directory>/.opencode/oh-my-opencode-slim.json
+ * 1. User config: ~/.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.
  *

package/dist/config/schema.d.ts

@@ -1,4 +1,54 @@
 import { z } from 'zod';
+declare const FALLBACK_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "fixer"];
+declare const MANUAL_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "fixer"];
+export declare const ManualAgentPlanSchema: z.ZodObject<{
+    primary: z.ZodString;
+    fallback1: z.ZodString;
+    fallback2: z.ZodString;
+    fallback3: z.ZodString;
+}, z.core.$strip>;
+export declare const ManualPlanSchema: z.ZodObject<{
+    orchestrator: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    oracle: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    designer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    explorer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    librarian: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    fixer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type ManualAgentName = (typeof MANUAL_AGENT_NAMES)[number];
+export type ManualAgentPlan = z.infer<typeof ManualAgentPlanSchema>;
+export type ManualPlan = z.infer<typeof ManualPlanSchema>;
+export type FallbackAgentName = (typeof FALLBACK_AGENT_NAMES)[number];
 export declare const AgentOverrideConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     temperature: z.ZodOptional<z.ZodNumber>;
@@ -45,8 +95,65 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     maxConcurrentStarts: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;
+export declare const FailoverConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    chains: z.ZodDefault<z.ZodObject<{
+        orchestrator: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        oracle: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        designer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fixer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+}, z.core.$strip>;
+export type FailoverConfig = z.infer<typeof FailoverConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
     preset: z.ZodOptional<z.ZodString>;
+    scoringEngineVersion: z.ZodOptional<z.ZodEnum<{
+        v1: "v1";
+        "v2-shadow": "v2-shadow";
+        v2: "v2";
+    }>>;
+    balanceProviderUsage: z.ZodOptional<z.ZodBoolean>;
+    manualPlan: z.ZodOptional<z.ZodObject<{
+        orchestrator: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        oracle: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        designer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        explorer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        librarian: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        fixer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>>;
     presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         temperature: z.ZodOptional<z.ZodNumber>;
@@ -76,6 +183,18 @@ export declare const PluginConfigSchema: z.ZodObject<{
     background: z.ZodOptional<z.ZodObject<{
         maxConcurrentStarts: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    fallback: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        chains: z.ZodDefault<z.ZodObject<{
+            orchestrator: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            oracle: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            designer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fixer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginConfig = z.infer<typeof PluginConfigSchema>;
 export type { AgentName } from './constants';