oh-my-opencode 2.5.4 → 2.6.1

package/dist/config/index.d.ts

@@ -1,2 +1,2 @@
 export { OhMyOpenCodeConfigSchema, AgentOverrideConfigSchema, AgentOverridesSchema, McpNameSchema, AgentNameSchema, HookNameSchema, SisyphusAgentConfigSchema, ExperimentalConfigSchema, } from "./schema";
-export type { OhMyOpenCodeConfig, AgentOverrideConfig, AgentOverrides, McpName, AgentName, HookName, SisyphusAgentConfig, ExperimentalConfig, } from "./schema";
+export type { OhMyOpenCodeConfig, AgentOverrideConfig, AgentOverrides, McpName, AgentName, HookName, SisyphusAgentConfig, ExperimentalConfig, DynamicContextPruningConfig, } from "./schema";

package/dist/config/schema.d.ts

@@ -52,6 +52,7 @@ export declare const HookNameSchema: z.ZodEnum<{
     "non-interactive-env": "non-interactive-env";
     "interactive-bash-session": "interactive-bash-session";
     "empty-message-sanitizer": "empty-message-sanitizer";
+    "thinking-block-validator": "thinking-block-validator";
 }>;
 export declare const AgentOverrideConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
@@ -625,6 +626,8 @@ export declare const ClaudeCodeConfigSchema: z.ZodObject<{
     skills: z.ZodOptional<z.ZodBoolean>;
     agents: z.ZodOptional<z.ZodBoolean>;
     hooks: z.ZodOptional<z.ZodBoolean>;
+    plugins: z.ZodOptional<z.ZodBoolean>;
+    plugins_override: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
 }, z.core.$strip>;
 export declare const SisyphusAgentConfigSchema: z.ZodObject<{
     disabled: z.ZodOptional<z.ZodBoolean>;
@@ -632,12 +635,65 @@ export declare const SisyphusAgentConfigSchema: z.ZodObject<{
     planner_enabled: z.ZodOptional<z.ZodBoolean>;
     replace_plan: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
+export declare const DynamicContextPruningConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    notification: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        minimal: "minimal";
+        detailed: "detailed";
+    }>>;
+    turn_protection: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        turns: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    protected_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    strategies: z.ZodOptional<z.ZodObject<{
+        deduplication: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        supersede_writes: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            aggressive: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        purge_errors: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            turns: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const ExperimentalConfigSchema: z.ZodObject<{
     aggressive_truncation: z.ZodOptional<z.ZodBoolean>;
     auto_resume: z.ZodOptional<z.ZodBoolean>;
     preemptive_compaction: z.ZodOptional<z.ZodBoolean>;
     preemptive_compaction_threshold: z.ZodOptional<z.ZodNumber>;
     truncate_all_tool_outputs: z.ZodDefault<z.ZodBoolean>;
+    dynamic_context_pruning: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        notification: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            minimal: "minimal";
+            detailed: "detailed";
+        }>>;
+        turn_protection: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            turns: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        protected_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        strategies: z.ZodOptional<z.ZodObject<{
+            deduplication: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            supersede_writes: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                aggressive: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            purge_errors: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                turns: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    dcp_on_compaction_failure: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
@@ -677,6 +733,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         "non-interactive-env": "non-interactive-env";
         "interactive-bash-session": "interactive-bash-session";
         "empty-message-sanitizer": "empty-message-sanitizer";
+        "thinking-block-validator": "thinking-block-validator";
     }>>>;
     agents: z.ZodOptional<z.ZodObject<{
         build: z.ZodOptional<z.ZodObject<{
@@ -1203,6 +1260,8 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         skills: z.ZodOptional<z.ZodBoolean>;
         agents: z.ZodOptional<z.ZodBoolean>;
         hooks: z.ZodOptional<z.ZodBoolean>;
+        plugins: z.ZodOptional<z.ZodBoolean>;
+        plugins_override: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     }, z.core.$strip>>;
     google_auth: z.ZodOptional<z.ZodBoolean>;
     sisyphus_agent: z.ZodOptional<z.ZodObject<{
@@ -1217,6 +1276,33 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         preemptive_compaction: z.ZodOptional<z.ZodBoolean>;
         preemptive_compaction_threshold: z.ZodOptional<z.ZodNumber>;
         truncate_all_tool_outputs: z.ZodDefault<z.ZodBoolean>;
+        dynamic_context_pruning: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            notification: z.ZodDefault<z.ZodEnum<{
+                off: "off";
+                minimal: "minimal";
+                detailed: "detailed";
+            }>>;
+            turn_protection: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                turns: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            protected_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            strategies: z.ZodOptional<z.ZodObject<{
+                deduplication: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                supersede_writes: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    aggressive: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                purge_errors: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    turns: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        dcp_on_compaction_failure: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     auto_update: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
@@ -1227,4 +1313,5 @@ export type AgentName = z.infer<typeof AgentNameSchema>;
 export type HookName = z.infer<typeof HookNameSchema>;
 export type SisyphusAgentConfig = z.infer<typeof SisyphusAgentConfigSchema>;
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;
+export type DynamicContextPruningConfig = z.infer<typeof DynamicContextPruningConfigSchema>;
 export { McpNameSchema, type McpName } from "../mcp/types";

package/dist/features/background-agent/manager.d.ts

@@ -31,6 +31,7 @@ export declare class BackgroundManager {
     private clearNotificationsForTask;
     private startPolling;
     private stopPolling;
+    cleanup(): void;
     private notifyParentSession;
     private formatDuration;
     private hasRunningTasks;

package/dist/features/claude-code-plugin-loader/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./loader";
+export type { PluginLoaderOptions, ClaudeSettings } from "./types";

package/dist/features/claude-code-plugin-loader/loader.d.ts

@@ -0,0 +1,20 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { McpServerConfig } from "../claude-code-mcp-loader/types";
+import type { LoadedPlugin, PluginLoadResult, PluginLoadError, HooksConfig, PluginLoaderOptions } from "./types";
+export declare function discoverInstalledPlugins(options?: PluginLoaderOptions): PluginLoadResult;
+export declare function loadPluginCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition>;
+export declare function loadPluginSkillsAsCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition>;
+export declare function loadPluginAgents(plugins: LoadedPlugin[]): Record<string, AgentConfig>;
+export declare function loadPluginMcpServers(plugins: LoadedPlugin[]): Promise<Record<string, McpServerConfig>>;
+export declare function loadPluginHooksConfigs(plugins: LoadedPlugin[]): HooksConfig[];
+export interface PluginComponentsResult {
+    commands: Record<string, CommandDefinition>;
+    skills: Record<string, CommandDefinition>;
+    agents: Record<string, AgentConfig>;
+    mcpServers: Record<string, McpServerConfig>;
+    hooksConfigs: HooksConfig[];
+    plugins: LoadedPlugin[];
+    errors: PluginLoadError[];
+}
+export declare function loadAllPluginComponents(options?: PluginLoaderOptions): Promise<PluginComponentsResult>;

package/dist/features/claude-code-plugin-loader/types.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Claude Code Plugin Types
+ *
+ * Type definitions for Claude Code plugin system compatibility.
+ * Based on https://code.claude.com/docs/en/plugins-reference
+ */
+export type PluginScope = "user" | "project" | "local" | "managed";
+/**
+ * Plugin installation entry in installed_plugins.json
+ */
+export interface PluginInstallation {
+    scope: PluginScope;
+    installPath: string;
+    version: string;
+    installedAt: string;
+    lastUpdated: string;
+    gitCommitSha?: string;
+    isLocal?: boolean;
+}
+/**
+ * Installed plugins database structure
+ * Located at ~/.claude/plugins/installed_plugins.json
+ */
+export interface InstalledPluginsDatabase {
+    version: number;
+    plugins: Record<string, PluginInstallation[]>;
+}
+/**
+ * Plugin author information
+ */
+export interface PluginAuthor {
+    name?: string;
+    email?: string;
+    url?: string;
+}
+/**
+ * Plugin manifest (plugin.json)
+ * Located at <plugin_root>/.claude-plugin/plugin.json
+ */
+export interface PluginManifest {
+    name: string;
+    version?: string;
+    description?: string;
+    author?: PluginAuthor;
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    keywords?: string[];
+    commands?: string | string[];
+    agents?: string | string[];
+    skills?: string | string[];
+    hooks?: string | HooksConfig;
+    mcpServers?: string | McpServersConfig;
+    lspServers?: string | LspServersConfig;
+    outputStyles?: string | string[];
+}
+/**
+ * Hooks configuration
+ */
+export interface HookEntry {
+    type: "command" | "prompt" | "agent";
+    command?: string;
+    prompt?: string;
+    agent?: string;
+}
+export interface HookMatcher {
+    matcher?: string;
+    hooks: HookEntry[];
+}
+export interface HooksConfig {
+    hooks?: {
+        PreToolUse?: HookMatcher[];
+        PostToolUse?: HookMatcher[];
+        PostToolUseFailure?: HookMatcher[];
+        PermissionRequest?: HookMatcher[];
+        UserPromptSubmit?: HookMatcher[];
+        Notification?: HookMatcher[];
+        Stop?: HookMatcher[];
+        SubagentStart?: HookMatcher[];
+        SubagentStop?: HookMatcher[];
+        SessionStart?: HookMatcher[];
+        SessionEnd?: HookMatcher[];
+        PreCompact?: HookMatcher[];
+    };
+}
+/**
+ * MCP servers configuration in plugin
+ */
+export interface PluginMcpServer {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    url?: string;
+    type?: "stdio" | "http" | "sse";
+    disabled?: boolean;
+}
+export interface McpServersConfig {
+    mcpServers?: Record<string, PluginMcpServer>;
+}
+/**
+ * LSP server configuration
+ */
+export interface LspServerConfig {
+    command: string;
+    args?: string[];
+    extensionToLanguage: Record<string, string>;
+    transport?: "stdio" | "socket";
+    env?: Record<string, string>;
+    initializationOptions?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+    workspaceFolder?: string;
+    startupTimeout?: number;
+    shutdownTimeout?: number;
+    restartOnCrash?: boolean;
+    maxRestarts?: number;
+    loggingConfig?: {
+        args?: string[];
+        env?: Record<string, string>;
+    };
+}
+export interface LspServersConfig {
+    [language: string]: LspServerConfig;
+}
+/**
+ * Loaded plugin with all resolved components
+ */
+export interface LoadedPlugin {
+    name: string;
+    version: string;
+    scope: PluginScope;
+    installPath: string;
+    manifest?: PluginManifest;
+    pluginKey: string;
+    commandsDir?: string;
+    agentsDir?: string;
+    skillsDir?: string;
+    hooksPath?: string;
+    mcpPath?: string;
+    lspPath?: string;
+}
+/**
+ * Plugin load result with all components
+ */
+export interface PluginLoadResult {
+    plugins: LoadedPlugin[];
+    errors: PluginLoadError[];
+}
+export interface PluginLoadError {
+    pluginKey: string;
+    installPath: string;
+    error: string;
+}
+/**
+ * Claude settings from ~/.claude/settings.json
+ */
+export interface ClaudeSettings {
+    enabledPlugins?: Record<string, boolean>;
+    [key: string]: unknown;
+}
+/**
+ * Plugin loader options
+ */
+export interface PluginLoaderOptions {
+    /**
+     * Override enabled plugins from oh-my-opencode config.
+     * Key format: "pluginName@marketplace" (e.g., "shell-scripting@claude-code-workflows")
+     * Value: true = enabled, false = disabled
+     *
+     * This takes precedence over ~/.claude/settings.json enabledPlugins
+     */
+    enabledPluginsOverride?: Record<string, boolean>;
+}

package/dist/hooks/anthropic-auto-compact/index.d.ts

@@ -11,6 +11,6 @@ export declare function createAnthropicAutoCompactHook(ctx: PluginInput, options
         };
     }) => Promise<void>;
 };
-export type { AutoCompactState, FallbackState, ParsedTokenLimitError, TruncateState } from "./types";
+export type { AutoCompactState, DcpState, FallbackState, ParsedTokenLimitError, TruncateState } from "./types";
 export { parseAnthropicTokenLimitError } from "./parser";
 export { executeCompact, getLastAssistant } from "./executor";

package/dist/hooks/anthropic-auto-compact/pruning-deduplication.d.ts

@@ -0,0 +1,7 @@
+import type { PruningState } from "./pruning-types";
+export interface DeduplicationConfig {
+    enabled: boolean;
+    protectedTools?: string[];
+}
+export declare function createToolSignature(toolName: string, input: unknown): string;
+export declare function executeDeduplication(sessionID: string, state: PruningState, config: DeduplicationConfig, protectedTools: Set<string>): number;

package/dist/hooks/anthropic-auto-compact/pruning-deduplication.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/anthropic-auto-compact/pruning-executor.d.ts

@@ -0,0 +1,3 @@
+import type { DynamicContextPruningConfig } from "../../config";
+import type { PruningResult } from "./pruning-types";
+export declare function executeDynamicContextPruning(sessionID: string, config: DynamicContextPruningConfig, client: any): Promise<PruningResult>;

package/dist/hooks/anthropic-auto-compact/pruning-purge-errors.d.ts

@@ -0,0 +1,7 @@
+import type { PruningState } from "./pruning-types";
+export interface PurgeErrorsConfig {
+    enabled: boolean;
+    turns: number;
+    protectedTools?: string[];
+}
+export declare function executePurgeErrors(sessionID: string, state: PruningState, config: PurgeErrorsConfig, protectedTools: Set<string>): number;

package/dist/hooks/anthropic-auto-compact/pruning-storage.d.ts

@@ -0,0 +1,2 @@
+import type { PruningState } from "./pruning-types";
+export declare function applyPruning(sessionID: string, state: PruningState): Promise<number>;

package/dist/hooks/anthropic-auto-compact/pruning-supersede.d.ts

@@ -0,0 +1,6 @@
+import type { PruningState } from "./pruning-types";
+export interface SupersedeWritesConfig {
+    enabled: boolean;
+    aggressive: boolean;
+}
+export declare function executeSupersedeWrites(sessionID: string, state: PruningState, config: SupersedeWritesConfig, protectedTools: Set<string>): number;

package/dist/hooks/anthropic-auto-compact/pruning-types.d.ts

@@ -0,0 +1,36 @@
+export interface ToolCallSignature {
+    toolName: string;
+    signature: string;
+    callID: string;
+    turn: number;
+}
+export interface FileOperation {
+    callID: string;
+    tool: string;
+    filePath: string;
+    turn: number;
+}
+export interface ErroredToolCall {
+    callID: string;
+    toolName: string;
+    turn: number;
+    errorAge: number;
+}
+export interface PruningResult {
+    itemsPruned: number;
+    totalTokensSaved: number;
+    strategies: {
+        deduplication: number;
+        supersedeWrites: number;
+        purgeErrors: number;
+    };
+}
+export interface PruningState {
+    toolIdsToPrune: Set<string>;
+    currentTurn: number;
+    fileOperations: Map<string, FileOperation[]>;
+    toolSignatures: Map<string, ToolCallSignature[]>;
+    erroredTools: Map<string, ErroredToolCall>;
+}
+export declare const CHARS_PER_TOKEN = 4;
+export declare function estimateTokens(text: string): number;

package/dist/hooks/anthropic-auto-compact/types.d.ts

@@ -19,12 +19,17 @@ export interface TruncateState {
     truncateAttempt: number;
     lastTruncatedPartId?: string;
 }
+export interface DcpState {
+    attempted: boolean;
+    itemsPruned: number;
+}
 export interface AutoCompactState {
     pendingCompact: Set<string>;
     errorDataBySession: Map<string, ParsedTokenLimitError>;
     retryStateBySession: Map<string, RetryState>;
     fallbackStateBySession: Map<string, FallbackState>;
     truncateStateBySession: Map<string, TruncateState>;
+    dcpStateBySession: Map<string, DcpState>;
     emptyContentAttemptBySession: Map<string, number>;
     compactionInProgress: Set<string>;
 }

package/dist/hooks/index.d.ts

@@ -20,3 +20,4 @@ export { createKeywordDetectorHook } from "./keyword-detector";
 export { createNonInteractiveEnvHook } from "./non-interactive-env";
 export { createInteractiveBashSessionHook } from "./interactive-bash-session";
 export { createEmptyMessageSanitizerHook } from "./empty-message-sanitizer";
+export { createThinkingBlockValidatorHook } from "./thinking-block-validator";

package/dist/hooks/session-notification-utils.d.ts

@@ -0,0 +1,9 @@
+type Platform = "darwin" | "linux" | "win32" | "unsupported";
+export declare function getNotifySendPath(): Promise<string | null>;
+export declare function getOsascriptPath(): Promise<string | null>;
+export declare function getPowershellPath(): Promise<string | null>;
+export declare function getAfplayPath(): Promise<string | null>;
+export declare function getPaplayPath(): Promise<string | null>;
+export declare function getAplayPath(): Promise<string | null>;
+export declare function startBackgroundCheck(platform: Platform): void;
+export {};

package/dist/hooks/thinking-block-validator/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Proactive Thinking Block Validator Hook
+ *
+ * Prevents "Expected thinking/redacted_thinking but found tool_use" errors
+ * by validating and fixing message structure BEFORE sending to Anthropic API.
+ *
+ * This hook runs on the "experimental.chat.messages.transform" hook point,
+ * which is called before messages are converted to ModelMessage format and
+ * sent to the API.
+ *
+ * Key differences from session-recovery hook:
+ * - PROACTIVE (prevents error) vs REACTIVE (fixes after error)
+ * - Runs BEFORE API call vs AFTER API error
+ * - User never sees the error vs User sees error then recovery
+ */
+import type { Message, Part } from "@opencode-ai/sdk";
+interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}
+type MessagesTransformHook = {
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+/**
+ * Validate and fix assistant messages that have tool_use but no thinking block
+ */
+export declare function createThinkingBlockValidatorHook(): MessagesTransformHook;
+export {};