oh-my-opencode-slim 2.1.0 → 2.1.1

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

@@ -1,4 +1,6 @@
 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.
@@ -6,12 +8,31 @@ import { z } from 'zod';
  * 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.ZodObject<{
-    model: z.ZodString;
+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.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.
@@ -22,8 +43,9 @@ export type CouncillorConfig = z.infer<typeof CouncillorConfigSchema>;
  */
 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;
+    variant: string | undefined;
+    prompt: string | undefined;
+    models: CouncillorModelEntry[];
 }>, Record<string, Record<string, unknown>>>>;
 export type CouncilPreset = z.infer<typeof CouncilPresetSchema>;
 /**
@@ -44,7 +66,7 @@ export declare const CouncillorExecutionModeSchema: z.ZodDefault<z.ZodEnum<{
  *   "council": {
  *     "presets": {
  *       "default": {
- *         "alpha": { "model": "openai/gpt-5.4-mini" },
+ *         "alpha": { "model": "openai/gpt-5.6-luna" },
  *         "beta":  { "model": "openai/gpt-5.3-codex" },
  *         "gamma": { "model": "google/gemini-3-pro" }
  *       }
@@ -58,8 +80,9 @@ export declare const CouncillorExecutionModeSchema: z.ZodDefault<z.ZodEnum<{
 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;
+        variant: string | undefined;
+        prompt: string | undefined;
+        models: CouncillorModelEntry[];
     }>, Record<string, Record<string, unknown>>>>>;
     timeout: z.ZodDefault<z.ZodNumber>;
     default_preset: z.ZodDefault<z.ZodString>;
@@ -72,8 +95,9 @@ export declare const CouncilConfigSchema: z.ZodPipe<z.ZodObject<{
 }, z.core.$strip>, z.ZodTransform<{
     presets: Record<string, Record<string, {
         model: string;
-        variant?: string | undefined;
-        prompt?: string | undefined;
+        variant: string | undefined;
+        prompt: string | undefined;
+        models: CouncillorModelEntry[];
     }>>;
     timeout: number;
     default_preset: string;
@@ -84,8 +108,9 @@ export declare const CouncilConfigSchema: z.ZodPipe<z.ZodObject<{
 }, {
     presets: Record<string, Record<string, {
         model: string;
-        variant?: string | undefined;
-        prompt?: string | undefined;
+        variant: string | undefined;
+        prompt: string | undefined;
+        models: CouncillorModelEntry[];
     }>>;
     timeout: number;
     default_preset: string;

package/dist/config/schema.d.ts

@@ -177,7 +177,9 @@ export declare const FailoverConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     timeoutMs: z.ZodDefault<z.ZodNumber>;
     retryDelayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
     retry_on_empty: z.ZodDefault<z.ZodBoolean>;
+    runtimeOverride: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export type FailoverConfig = z.infer<typeof FailoverConfigSchema>;
 export declare const CompanionConfigSchema: z.ZodObject<{
@@ -337,13 +339,16 @@ export declare const PluginConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         timeoutMs: z.ZodDefault<z.ZodNumber>;
         retryDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
         retry_on_empty: z.ZodDefault<z.ZodBoolean>;
+        runtimeOverride: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
     council: z.ZodOptional<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;
+            variant: string | undefined;
+            prompt: string | undefined;
+            models: import("./council-schema").CouncillorModelEntry[];
         }>, Record<string, Record<string, unknown>>>>>;
         timeout: z.ZodDefault<z.ZodNumber>;
         default_preset: z.ZodDefault<z.ZodString>;
@@ -356,8 +361,9 @@ export declare const PluginConfigSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodTransform<{
         presets: Record<string, Record<string, {
             model: string;
-            variant?: string | undefined;
-            prompt?: string | undefined;
+            variant: string | undefined;
+            prompt: string | undefined;
+            models: import("./council-schema").CouncillorModelEntry[];
         }>>;
         timeout: number;
         default_preset: string;
@@ -368,8 +374,9 @@ export declare const PluginConfigSchema: z.ZodObject<{
     }, {
         presets: Record<string, Record<string, {
             model: string;
-            variant?: string | undefined;
-            prompt?: string | undefined;
+            variant: string | undefined;
+            prompt: string | undefined;
+            models: import("./council-schema").CouncillorModelEntry[];
         }>>;
         timeout: number;
         default_preset: string;

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/foreground-fallback/index.d.ts

@@ -14,6 +14,7 @@
  * 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 isRateLimitError(error: unknown): boolean;
 /**
@@ -31,6 +32,15 @@ export declare class ForegroundFallbackManager {
      */
     private readonly chains;
     private readonly enabled;
+    /** Consecutive 429s tolerated on the same model before swap/abort. */
+    private readonly maxRetries;
+    /**
+     * When true (default), a runtime model outside the configured chain
+     * still triggers fallback on rate-limit errors. When false, out-of-chain
+     * runtime picks are respected and the error surfaces instead. Models
+     * that are members of the chain always fall back regardless.
+     */
+    private readonly runtimeOverride;
     /** sessionID → last observed model string ("providerID/modelID") */
     private readonly sessionModel;
     /** sessionID → agent name (populated from message.updated info.agent field) */
@@ -45,18 +55,42 @@ 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;
     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, 
+    /**
+     * When true (default), a runtime model outside the configured chain
+     * still triggers fallback on rate-limit errors. When false, out-of-chain
+     * runtime picks are respected and the error surfaces instead. Models
+     * that are members of the chain always fall back regardless.
+     */
+    runtimeOverride?: boolean);
     /**
      * 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 the session.status retry path — each retry counts toward the
+     *  budget and only triggers fallback after maxRetries - 1 absorptions.
+     *  Non-retry paths (session.error / message.updated) use shouldIntervene(),
+     *  which bypasses the counter on first occurrence. */
+    private checkRetryBudget;
+    /** For non-retry paths (session.error, message.updated): intervene immediately
+     *  unless the session is already in a retry window (has prior retries). */
+    private shouldIntervene;
     private tryFallback;
     /**
      * Determine the fallback chain to use for a session.

package/dist/hooks/index.d.ts

@@ -12,4 +12,5 @@ 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;