oh-my-opencode-slim 0.7.0 → 0.8.1

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

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

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

@@ -12,3 +12,7 @@ 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/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

@@ -130,7 +130,7 @@ export declare const MODEL_MAPPINGS: {
             readonly model: "google/antigravity-gemini-3-flash";
         };
         readonly oracle: {
-            readonly model: "google/antigravity-gemini-3-pro";
+            readonly model: "google/antigravity-gemini-3.1-pro";
         };
         readonly librarian: {
             readonly model: "google/antigravity-gemini-3-flash";

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/skills.d.ts

@@ -15,11 +15,28 @@ export interface RecommendedSkill {
     /** Optional commands to run after the skill is added */
     postInstallCommands?: string[];
 }
+/**
+ * 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;
+}
 /**
  * List of recommended skills.
  * Add new skills here to include them in the installation flow.
  */
 export declare const RECOMMENDED_SKILLS: RecommendedSkill[];
+/**
+ * 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[];
 /**
  * Install a skill using `npx skills add`.
  * @param skill - The skill to install

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

@@ -11,7 +11,12 @@ export interface InstallArgs {
     tmux?: BooleanArg;
     skills?: BooleanArg;
     opencodeFree?: BooleanArg;
+    balancedSpend?: BooleanArg;
     opencodeFreeModel?: string;
+    aaKey?: string;
+    openrouterKey?: string;
+    dryRun?: boolean;
+    modelsOnly?: boolean;
 }
 export interface OpenCodeFreeModel {
     providerID: string;
@@ -43,10 +48,41 @@ 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>;
@@ -69,11 +105,19 @@ export interface InstallConfig {
     availableOpenCodeFreeModels?: OpenCodeFreeModel[];
     selectedChutesPrimaryModel?: string;
     selectedChutesSecondaryModel?: string;
-    availableChutesFreeModels?: OpenCodeFreeModel[];
+    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;

package/dist/config/constants.d.ts

@@ -3,6 +3,7 @@ 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;

package/dist/config/schema.d.ts

@@ -1,5 +1,53 @@
 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>;
@@ -57,11 +105,55 @@ export declare const FailoverConfigSchema: z.ZodObject<{
         explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
         librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
         fixer: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
+    }, 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>;
@@ -101,7 +193,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
             explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
             librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
             fixer: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
+        }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginConfig = z.infer<typeof PluginConfigSchema>;

package/dist/hooks/autopilot/index.d.ts

@@ -0,0 +1,43 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../../config';
+declare const AUTOPILOT_CONTINUE_PROMPT = "[AUTOPILOT] Continue executing work in this same session now. Do not acknowledge autopilot, do not ask for confirmation, and do not stop after a status message. Perform the next concrete action immediately (run a tool/command, edit files, or advance the active todo). Only stop when all todos are completed/cancelled or the user explicitly disables autopilot.";
+interface MessagePart {
+    type: string;
+    text?: string;
+}
+interface TodoEntry {
+    status?: string;
+}
+type AutopilotCommand = 'enable' | 'disable' | 'status' | null;
+declare function parseAutopilotCommand(text: string, keyword: string, disableKeyword: string): AutopilotCommand;
+declare function extractTodoList(data: unknown): TodoEntry[];
+declare function isActiveTodo(todo: TodoEntry): boolean;
+export declare function createAutopilotHook(ctx: PluginInput, config: PluginConfig): {
+    'chat.message': (input: {
+        sessionID: string;
+        agent?: string;
+        messageID?: string;
+    }, output: {
+        parts: MessagePart[];
+    }) => Promise<void>;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: {
+                sessionID?: string;
+                status?: {
+                    type?: string;
+                };
+                info?: {
+                    id?: string;
+                    role?: string;
+                    sessionID?: string;
+                    time?: {
+                        completed?: number;
+                    };
+                };
+            };
+        };
+    }) => Promise<void>;
+};
+export { AUTOPILOT_CONTINUE_PROMPT, extractTodoList, isActiveTodo, parseAutopilotCommand, };

package/dist/hooks/delegate-task-retry/guidance.d.ts

@@ -0,0 +1,2 @@
+import { type DetectedError } from './patterns';
+export declare function buildRetryGuidance(errorInfo: DetectedError): string;

package/dist/hooks/delegate-task-retry/hook.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare function createDelegateTaskRetryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: {
+        tool: string;
+    }, output: {
+        output: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/index.d.ts

@@ -0,0 +1,4 @@
+export type { DelegateTaskErrorPattern, DetectedError } from './patterns';
+export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError } from './patterns';
+export { buildRetryGuidance } from './guidance';
+export { createDelegateTaskRetryHook } from './hook';

package/dist/hooks/delegate-task-retry/patterns.d.ts

@@ -0,0 +1,11 @@
+export interface DelegateTaskErrorPattern {
+    pattern: string;
+    errorType: string;
+    fixHint: string;
+}
+export declare const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[];
+export interface DetectedError {
+    errorType: string;
+    originalOutput: string;
+}
+export declare function detectDelegateTaskError(output: string): DetectedError | null;

package/dist/hooks/index.d.ts

@@ -1,4 +1,6 @@
 export type { AutoUpdateCheckerOptions } from './auto-update-checker';
 export { createAutoUpdateCheckerHook } from './auto-update-checker';
+export { createDelegateTaskRetryHook } from './delegate-task-retry';
+export { createJsonErrorRecoveryHook } from './json-error-recovery';
 export { createPhaseReminderHook } from './phase-reminder';
 export { createPostReadNudgeHook } from './post-read-nudge';

package/dist/hooks/json-error-recovery/hook.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare const JSON_ERROR_TOOL_EXCLUDE_LIST: readonly ["bash", "read", "glob", "grep", "webfetch", "grep_app_searchgithub", "websearch_web_search_exa"];
+export declare const JSON_ERROR_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const JSON_ERROR_REMINDER = "\n[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]\n\nYou sent invalid JSON arguments. The system could not parse your tool call.\nSTOP and do this NOW:\n\n1. LOOK at the error message above to see what was expected vs what you sent.\n2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).\n3. RETRY the tool call with valid JSON.\n\nDO NOT repeat the exact same invalid call.\n";
+interface ToolExecuteAfterInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteAfterOutput {
+    title: string;
+    output: unknown;
+    metadata: unknown;
+}
+export declare function createJsonErrorRecoveryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/json-error-recovery/index.d.ts

@@ -0,0 +1 @@
+export { createJsonErrorRecoveryHook, JSON_ERROR_PATTERNS, JSON_ERROR_REMINDER, JSON_ERROR_TOOL_EXCLUDE_LIST, } from './hook';