oh-my-opencode-slim 2.1.0 → 2.2.0

package/dist/config/strip-orchestrator-model.d.ts

@@ -0,0 +1,9 @@
+import type { PluginConfig, Preset } from './schema';
+export declare function stripOrchestratorModel(agents: Record<string, unknown>, enabled: boolean | undefined, preset: Preset | undefined): void;
+export declare function applyOrchestratorModelConfig(input: {
+    agents: Record<string, unknown>;
+    enabled: boolean | undefined;
+    presets: PluginConfig['presets'];
+    configPreset: string | undefined;
+    runtimePreset: string | null;
+}): void;

package/dist/council/council-manager.d.ts

@@ -41,9 +41,13 @@ export declare class CouncilManager {
     private runAgentSession;
     private runCouncillors;
     /**
-     * Run a single councillor with retry logic for empty responses.
-     * Only retries on "Empty response from provider" errors - timeouts
-     * and other failures are returned immediately.
+     * Run a single councillor across its configured model chain.
+     *
+     * For each model in the chain, empty responses are retried up to
+     * `maxRetries` times (providers that silently rate-limit). Any other
+     * failure or timeout advances to the next model in the chain. The
+     * councillor only fails once every model has been exhausted; the reported
+     * `model` and `error` reflect the last model tried.
      */
     private runCouncillorWithRetry;
 }

package/dist/hooks/command-hook-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Register a command hook in the OpenCode config if it doesn't already exist.
+ * Returns true if the command was registered, false if it already existed.
+ */
+export declare function registerCommandHook(opencodeConfig: Record<string, unknown>, commandName: string, template: string, description: string): boolean;

package/dist/hooks/foreground-fallback/index.d.ts

@@ -2,9 +2,12 @@
  * Runtime model fallback for foreground (interactive) agent sessions.
  *
  * When OpenCode fires a session.error, message.updated, or session.status
- * event containing a rate-limit signal, this manager:
+ * event containing a transient error (rate-limit, 403/Forbidden, etc.), this
+ * manager:
  *   1. Looks up the next untried model in the agent's configured chain
- *   2. Aborts the rate-limited prompt via client.session.abort()
+ *   2. Aborts the rate-limited prompt via client.session.abort() on the
+ *      session.status retry path; session.error and message.updated paths
+ *      re-prompt directly without abort.
  *   3. Re-queues the last user message via client.session.promptAsync()
  *      with the new model - promptAsync returns immediately so we never
  *      block the event handler waiting for a full LLM response.
@@ -14,7 +17,15 @@
  * try/catch, which is not possible for interactive (foreground) sessions.
  */
 import type { PluginInput } from '@opencode-ai/plugin';
+import type { SessionLifecycle } from '../session-lifecycle';
 type OpencodeClient = PluginInput['client'];
+export declare function isFailoverError(error: unknown): boolean;
+/**
+ * Checks whether an error is a transient/retryable error (rate-limit,
+ * 403/Forbidden, etc.) that should trigger model fallback.
+ */
+export declare function isRetryableError(error: unknown): boolean;
+/** @deprecated Use isRetryableError instead. */
 export declare function isRateLimitError(error: unknown): boolean;
 /**
  * Manages runtime model fallback for foreground agent sessions.
@@ -29,8 +40,10 @@ export declare class ForegroundFallbackManager {
      * e.g. { orchestrator: ['anthropic/claude-opus-4-5', 'openai/gpt-4o'] }
      * The first model that hasn't been tried yet is selected on each fallback.
      */
-    private readonly chains;
+    private chains;
     private readonly enabled;
+    /** Consecutive 429s tolerated on the same model before swap/abort. */
+    private readonly maxRetries;
     /** sessionID → last observed model string ("providerID/modelID") */
     private readonly sessionModel;
     /** sessionID → agent name (populated from message.updated info.agent field) */
@@ -45,27 +58,60 @@ export declare class ForegroundFallbackManager {
      *  when the model has changed, allowing the cascade to continue when a
      *  new fallback model also fails within the dedup window. */
     private readonly lastTriggerModel;
+    /** sessionID → consecutive 429 count for the current model.
+     *  Reset on model swap or session deletion. */
+    private readonly sessionRetries;
+    /** Exposed for task-session-manager: prevents idle reconciliation
+     *  while a fallback abort/re-prompt is in flight for this session. */
+    isFallbackInProgress(sessionID: string): boolean;
+    /**
+     * Disable the fallback chain for a specific agent.
+     * After calling this, rate-limit errors for that agent surface instead of
+     * silently falling back through the chain.
+     */
+    disableChain(agentName: string): void;
+    registerSessionAgent(sessionID: string, agentName: string): void;
     constructor(client: OpencodeClient, 
     /**
      * Ordered fallback chains per agent.
      * e.g. { orchestrator: ['anthropic/claude-opus-4-5', 'openai/gpt-4o'] }
      * The first model that hasn't been tried yet is selected on each fallback.
      */
-    chains: Record<string, string[]>, enabled: boolean);
+    chains: Record<string, string[]>, enabled: boolean, 
+    /** Consecutive 429s tolerated on the same model before swap/abort. */
+    maxRetries?: number, coordinator?: SessionLifecycle);
     /**
      * Process an OpenCode plugin event.
      * Call this from the plugin's `event` hook for every event received.
      */
     handleEvent(rawEvent: unknown): Promise<void>;
+    /** Increment retry counter and return true when the budget is exhausted.
+     *  Used by shouldIntervene when tried > 0 — each retry counts toward the
+     *  budget and only triggers fallback after maxRetries - 1 absorptions.
+     *  First failover retry (tried === 0) bypasses the counter via shouldIntervene. */
+    private consumeRetryBudget;
+    /** Intervene immediately on first occurrence (tried === 0), otherwise
+     *  delegate to retry budget. Used by all three event paths. */
+    private shouldTriggerFallback;
+    private isRecoveredStatus;
     private tryFallback;
+    /**
+     * Fallback path for session.status retry events.  Aborts the retry loop
+     * before falling back because promptAsync alone is ignored while the
+     * session is in retry mode.  inProgress is set first so the
+     * task-session-manager sees isFallbackInProgress()=true during the
+     * abort idle window and does not cancel the pending task call.
+     */
+    private tryFallbackWithAbort;
+    private isDeduped;
+    private execFallback;
     /**
      * Determine the fallback chain to use for a session.
      *
      * Priority:
      * 1. Agent name known AND has a configured chain → return it directly
-     * 2. Agent name known but NO chain configured → return [] (no fallback;
-     *    do NOT bleed into other agents' chains which would re-prompt the
-     *    session with a model belonging to a completely different agent)
+     * 2. Agent name known but NO chain → return [] (no fallback; never
+     *    bleed into other agents' chains)
      * 3. Agent name unknown, current model known → search all chains for
      *    the model to infer which chain to use
      * 4. Nothing matches → flatten all chains as a last resort (only

package/dist/hooks/image-hook.d.ts

@@ -2,6 +2,7 @@ import { type MessageWithParts } from './types';
 export declare function processImageAttachments(args: {
     messages: MessageWithParts[];
     workDir: string;
+    imageRouting: 'auto' | 'direct';
     disabledAgents: Set<string>;
     log: (msg: string) => void;
 }): void;

package/dist/hooks/index.d.ts

@@ -5,11 +5,12 @@ export { createChatHeadersHook } from './chat-headers';
 export { createDeepworkCommandHook } from './deepwork';
 export { createDelegateTaskRetryHook } from './delegate-task-retry/hook';
 export { createFilterAvailableSkillsHook } from './filter-available-skills';
-export { ForegroundFallbackManager, isRateLimitError, } from './foreground-fallback';
+export { ForegroundFallbackManager, isFailoverError, isRetryableError, } from './foreground-fallback';
 export { processImageAttachments } from './image-hook';
 export { createJsonErrorRecoveryHook } from './json-error-recovery/hook';
 export { createLoopCommandHook } from './loop-command';
 export { createPhaseReminderHook } from './phase-reminder';
 export { createPostFileToolNudgeHook } from './post-file-tool-nudge';
 export { createReflectCommandHook } from './reflect';
+export { SessionLifecycle } from './session-lifecycle';
 export { createTaskSessionManagerHook } from './task-session-manager';

package/dist/hooks/phase-reminder/index.d.ts

@@ -6,13 +6,15 @@
  * of the user's actual turn.
  */
 import { PHASE_REMINDER } from '../../config/constants';
+import type { SessionLifecycle } from '../session-lifecycle';
 export { PHASE_REMINDER };
+export declare const PHASE_REMINDER_METADATA_KEY = "oh-my-opencode-slim.phaseReminder";
 /**
  * Creates the experimental.chat.messages.transform hook for phase reminder injection.
  * This hook runs right before sending to API, so it doesn't affect UI display.
  * Only injects for the orchestrator agent.
  */
-export declare function createPhaseReminderHook(): {
+export declare function createPhaseReminderHook(coordinator?: SessionLifecycle): {
     'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
         messages?: unknown;
     }) => Promise<void>;

package/dist/hooks/post-file-tool-nudge/index.d.ts

@@ -1,19 +1,25 @@
 /**
  * Post-tool nudge - queues a delegation reminder after file reads/writes.
  * Catches the "inspect/edit files → implement myself" anti-pattern.
+ *
+ * The reminder is ephemeral: recorded on tool execution, injected via
+ * system.transform, and consumed once. File tool output stays clean.
  */
-interface ToolExecuteAfterInput {
-    tool: string;
-    sessionID?: string;
-    callID?: string;
-}
-interface ToolExecuteAfterOutput {
-    output?: unknown;
-}
+import type { SessionLifecycle } from '../session-lifecycle';
 interface PostFileToolNudgeOptions {
     shouldInject?: (sessionID: string) => boolean;
+    coordinator?: SessionLifecycle;
 }
 export declare function createPostFileToolNudgeHook(options?: PostFileToolNudgeOptions): {
-    'tool.execute.after': (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+    'tool.execute.after': (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, _output: unknown) => Promise<void>;
+    'experimental.chat.system.transform': (input: {
+        sessionID?: string;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
 };
 export {};

package/dist/hooks/session-lifecycle.d.ts

@@ -0,0 +1,11 @@
+export declare class SessionLifecycle {
+    #private;
+    constructor(log: (msg: string, meta?: Record<string, unknown>) => void);
+    onSessionDeleted(callback: (sessionId: string) => void): void;
+    dispatchSessionDeleted(sessionId: string): void;
+    markPending(sessionId: string): void;
+    /** Atomic — only one caller gets true per markPending call. */
+    consumePending(sessionId: string): boolean;
+    hasPendingSession(sessionId: string): boolean;
+    clearSession(sessionId: string): void;
+}

package/dist/hooks/task-session-manager/index.d.ts

@@ -1,11 +1,23 @@
 import type { PluginInput } from '@opencode-ai/plugin';
-import { BackgroundJobBoard } from '../../utils';
+import { type BackgroundJobStore } from '../../utils';
+import type { SessionLifecycle } from '../session-lifecycle';
+export declare const BACKGROUND_JOB_BOARD_METADATA_KEY = "oh-my-opencode-slim.backgroundJobBoard";
 export declare function createTaskSessionManagerHook(_ctx: PluginInput, options: {
     maxSessionsPerAgent: number;
     readContextMinLines?: number;
     readContextMaxFiles?: number;
-    backgroundJobBoard?: BackgroundJobBoard;
+    backgroundJobBoard?: BackgroundJobStore;
     shouldManageSession: (sessionID: string) => boolean;
+    /** Register a session as orchestrator when the transform hook detects
+     *  an orchestrator message but the session isn't in the agent map yet. */
+    registerSessionAsOrchestrator?: (sessionID: string) => void;
+    /** Optional guard: when provided, idle events for a session that is
+     *  currently undergoing a foreground-fallback abort/re-prompt cycle
+     *  will NOT trigger idle reconciliation. prevents marking a still-
+     *  active child job as completed when the session was aborted for
+     *  model fallback rather than natural completion. */
+    isFallbackInProgress?: (sessionID: string) => boolean;
+    coordinator?: SessionLifecycle;
 }): {
     'tool.execute.before': (input: {
         tool: string;