oh-my-opencode-slim 2.0.5 → 2.1.1

package/dist/cli/providers.d.ts

@@ -3,28 +3,28 @@ export declare const GENERATED_PRESETS: readonly ["openai", "opencode-go"];
 export declare const MODEL_MAPPINGS: {
     readonly openai: {
         readonly orchestrator: {
-            readonly model: "openai/gpt-5.5";
+            readonly model: "openai/gpt-5.6-terra";
             readonly variant: "medium";
         };
         readonly oracle: {
-            readonly model: "openai/gpt-5.5";
+            readonly model: "openai/gpt-5.6-sol";
             readonly variant: "high";
         };
         readonly librarian: {
-            readonly model: "openai/gpt-5.4-mini";
+            readonly model: "openai/gpt-5.6-luna";
             readonly variant: "low";
         };
         readonly explorer: {
-            readonly model: "openai/gpt-5.4-mini";
+            readonly model: "openai/gpt-5.6-luna";
             readonly variant: "low";
         };
         readonly designer: {
-            readonly model: "openai/gpt-5.4-mini";
+            readonly model: "openai/gpt-5.6-luna";
             readonly variant: "medium";
         };
         readonly fixer: {
-            readonly model: "openai/gpt-5.5";
-            readonly variant: "low";
+            readonly model: "openai/gpt-5.6-luna";
+            readonly variant: "medium";
         };
     };
     readonly kimi: {
@@ -104,24 +104,20 @@ export declare const MODEL_MAPPINGS: {
     };
     readonly 'opencode-go': {
         readonly orchestrator: {
-            readonly model: "opencode-go/glm-5.1";
+            readonly model: "opencode-go/glm-5.2";
         };
         readonly oracle: {
-            readonly model: "opencode-go/deepseek-v4-pro";
+            readonly model: "opencode-go/qwen3.7-max";
             readonly variant: "max";
         };
-        readonly council: {
-            readonly model: "opencode-go/deepseek-v4-pro";
-            readonly variant: "high";
-        };
         readonly librarian: {
-            readonly model: "opencode-go/minimax-m2.7";
+            readonly model: "opencode-go/deepseek-v4-flash";
         };
         readonly explorer: {
-            readonly model: "opencode-go/minimax-m2.7";
+            readonly model: "opencode-go/deepseek-v4-flash";
         };
         readonly designer: {
-            readonly model: "opencode-go/kimi-k2.6";
+            readonly model: "opencode-go/kimi-k2.7-code";
             readonly variant: "medium";
         };
         readonly fixer: {

package/dist/cli/skills.d.ts

@@ -3,7 +3,7 @@
  * 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 */
+    /** Skill name - must match the name OpenCode uses for permission checks */
     name: string;
     /** List of agents that should auto-allow this skill */
     allowedAgents: string[];
@@ -12,7 +12,7 @@ export interface PermissionOnlySkill {
 }
 /**
  * Skills managed externally (not installed by this plugin's CLI).
- * Entries here only affect agent permission grants — nothing is installed.
+ * Entries here only affect agent permission grants - nothing is installed.
  */
 export declare const PERMISSION_ONLY_SKILLS: PermissionOnlySkill[];
 /**

package/dist/companion/manager.d.ts

@@ -17,8 +17,17 @@ export declare class CompanionManager {
     private readonly busyAgentSessions;
     private readonly config?;
     private companionProcess;
+    private wasSpawner;
+    private spawnedCompanionPid;
     constructor(sessionId: string, cwd: string, config?: CompanionConfig);
     onLoad(): void;
+    /**
+     * Register this manager behind a single process `exit` listener. Re-inits for
+     * the same OpenCode session dispose the superseded manager immediately so its
+     * detached child does not survive until process exit.
+     */
+    private registerActiveManager;
+    private static disposeActiveManagers;
     /**
      * Feed every session.status event here, with the agent name resolved
      * from sessionAgentMap. Orchestrator sessions drive overall status;
@@ -33,6 +42,7 @@ export declare class CompanionManager {
     onWaitingInput(): void;
     onInputResolved(): void;
     onExit(): void;
+    private removeOwnedPidFileIfNoSessionsRemain;
     /** One entry per running agent instance (two fixers → two cells). */
     private activeAgents;
     private flush;

package/dist/config/constants.d.ts

@@ -15,7 +15,8 @@ export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;
 export declare const MAX_POLL_TIME_MS: number;
 export declare const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
 export declare const PHASE_REMINDER_TEXT = "!IMPORTANT! Scheduler workflow: plan lanes/dependencies \u2192 dispatch background specialists \u2192 track task IDs \u2192 wait for hook-driven completion \u2192 reconcile terminal results \u2192 verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!";
-export declare const PHASE_REMINDER = "<internal_reminder>!IMPORTANT! Scheduler workflow: plan lanes/dependencies \u2192 dispatch background specialists \u2192 track task IDs \u2192 wait for hook-driven completion \u2192 reconcile terminal results \u2192 verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!</internal_reminder>";
+export declare function formatSystemReminder(text: string): string;
+export declare const PHASE_REMINDER: string;
 export declare const WRITABLE_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- Prefer dedicated file tools for normal code work: glob/grep/ast_grep_search for discovery, read for file contents, and edit/write/apply_patch for targeted source changes.\n- Use bash for execution and automation: git, package managers, tests, builds, scripts, diagnostics, and shell-native filesystem operations.\n- Shell is acceptable for bulk or mechanical filesystem changes when it is clearer or safer than many individual edits (for example: truncate generated logs, remove build artifacts, batch rename/move files), especially when the user explicitly asks for that shell operation.\n- Before destructive or broad shell operations, verify the target set and quote paths. Prefer a dry-run/listing first when practical.\n- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.";
 export declare const READONLY_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- READ-ONLY: inspect and report; do not modify files.\n- Prefer dedicated file tools for codebase inspection: glob/grep/ast_grep_search for discovery and read for file contents.\n- Bash is allowed for non-mutating diagnostics and shell-native inspection when it is the clearest tool, but not for modifying files.\n- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.";
 export declare const NO_SHELL_READONLY_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- READ-ONLY: inspect and report; do not modify files.\n- Use glob/grep/ast_grep_search for discovery and read for file contents.\n- Do not use bash or shell commands.";

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

@@ -76,10 +76,13 @@ export declare function loadPluginConfig(directory: string, options?: LoadPlugin
  * then falls back to the root prompts directory.
  *
  * @param agentName - Name of the agent (e.g., "orchestrator", "explorer")
- * @param preset - Optional preset name for preset-scoped prompt lookup
+ * @param optionsOrPreset - Optional preset name or options configuration
  * @returns Object with prompt and/or appendPrompt if files exist
  */
-export declare function loadAgentPrompt(agentName: string, preset?: string): {
+export declare function loadAgentPrompt(agentName: string, optionsOrPreset?: string | {
+    preset?: string;
+    projectDirectory?: string;
+}): {
     prompt?: string;
     appendPrompt?: string;
 };

package/dist/config/schema.d.ts

@@ -66,6 +66,7 @@ export declare const MultiplexerTypeSchema: z.ZodEnum<{
     auto: "auto";
     tmux: "tmux";
     zellij: "zellij";
+    herdr: "herdr";
     none: "none";
 }>;
 export type MultiplexerType = z.infer<typeof MultiplexerTypeSchema>;
@@ -95,6 +96,7 @@ export declare const MultiplexerConfigSchema: z.ZodObject<{
         auto: "auto";
         tmux: "tmux";
         zellij: "zellij";
+        herdr: "herdr";
         none: "none";
     }>>;
     layout: z.ZodDefault<z.ZodEnum<{
@@ -175,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<{
@@ -247,6 +251,7 @@ export type AcpAgentsConfig = z.infer<typeof AcpAgentsConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
     preset: z.ZodOptional<z.ZodString>;
     setDefaultAgent: z.ZodOptional<z.ZodBoolean>;
+    compactSidebar: z.ZodOptional<z.ZodBoolean>;
     autoUpdate: z.ZodOptional<z.ZodBoolean>;
     presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -285,6 +290,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
             auto: "auto";
             tmux: "tmux";
             zellij: "zellij";
+            herdr: "herdr";
             none: "none";
         }>>;
         layout: z.ZodDefault<z.ZodEnum<{
@@ -333,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>;
@@ -352,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;
@@ -364,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/auto-update-checker/skill-sync.d.ts

@@ -2,8 +2,66 @@ export interface SkillSyncResult {
     installed: string[];
     skippedExisting: string[];
     failed: string[];
+    staged: string[];
+    adopted: string[];
+    customized: string[];
 }
+export interface SkillManifestEntry {
+    status: 'managed' | 'customized' | 'deleted' | 'conflict';
+    packageVersion: string;
+    sourceHash: string;
+    lastManagedHash: string;
+    lastSeenHash: string;
+    stagedPath?: string;
+    updatedAt: string;
+}
+export interface SkillsManifest {
+    schemaVersion: number;
+    updatedAt: string;
+    skills: Record<string, SkillManifestEntry>;
+}
+interface ManagedSkillSource {
+    name: string;
+    sourcePath: string;
+}
+interface SkillSyncOptions {
+    skills?: ManagedSkillSource[];
+}
+/**
+ * Hashes of historically managed versions of skills.
+ * When a release changes skill content, this table must be populated
+ * from the published npm package tarballs to allow upgrading existing users.
+ *
+ * How to populate:
+ * 1. Download previous releases of the npm package: `npm pack oh-my-opencode-slim@<version>`
+ * 2. Compute directory hash for each legacy skill directory inside the unpacked tarball:
+ *    `import { computeDirectoryHash } from './skill-sync';`
+ *    `const hash = computeDirectoryHash('path/to/extracted/package/src/skills/<skill-name>');`
+ * 3. Append the hash to the skill's string array below:
+ *    ```typescript
+ *    export const LEGACY_MANAGED_SKILL_HASHES: Record<string, string[]> = {
+ *      'simplify': ['hash1', 'hash2'],
+ *      'codemap': ['hash3']
+ *    };
+ *    ```
+ */
+export declare const LEGACY_MANAGED_SKILL_HASHES: Record<string, string[]>;
+/**
+ * Computes a deterministic SHA-256 hash of a directory's files.
+ */
+export declare function computeDirectoryHash(dirPath: string): string;
+/**
+ * Acquires a simple lock under .oh-my-opencode-slim.
+ * Avoids stealing active locks purely by time; writes owner metadata
+ * and only steals dead same-host pid if detectable.
+ */
+export declare function acquireLock(lockDir: string): boolean;
+/**
+ * Releases the lock.
+ */
+export declare function releaseLock(lockDir: string): void;
 /**
  * Synchronizes bundled skills from the newly installed package root to OpenCode config skills directory.
  */
-export declare function syncBundledSkillsFromPackage(packageRoot: string): SkillSyncResult;
+export declare function syncBundledSkillsFromPackage(packageRoot: string, options?: SkillSyncOptions): SkillSyncResult;
+export {};

package/dist/hooks/filter-available-skills/index.d.ts

@@ -5,7 +5,6 @@
  */
 import type { PluginInput } from '@opencode-ai/plugin';
 import { type PluginConfig } from '../../config';
-import type { MessageWithParts } from '../types';
 type SkillRule = 'allow' | 'ask' | 'deny';
 declare function filterAvailableSkillsText(text: string, permissionRules: Record<string, SkillRule>): string;
 /**
@@ -14,7 +13,7 @@ declare function filterAvailableSkillsText(text: string, permissionRules: Record
  */
 export declare function createFilterAvailableSkillsHook(_ctx: PluginInput, config: PluginConfig): {
     'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
-        messages: MessageWithParts[];
+        messages?: unknown;
     }) => Promise<void>;
 };
 export { filterAvailableSkillsText };

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

@@ -6,7 +6,7 @@
  *   1. Looks up the next untried model in the agent's configured chain
  *   2. Aborts the rate-limited prompt via client.session.abort()
  *   3. Re-queues the last user message via client.session.promptAsync()
- *      with the new model — promptAsync returns immediately so we never
+ *      with the new model - promptAsync returns immediately so we never
  *      block the event handler waiting for a full LLM response.
  *
  * This mirrors the same fallback loop used for delegated sessions, but operates
@@ -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) */
@@ -41,18 +51,46 @@ export declare class ForegroundFallbackManager {
     private readonly inProgress;
     /** sessionID → timestamp of last trigger (for deduplication) */
     private readonly lastTrigger;
+    /** sessionID → model in use when lastTrigger was set; dedup is bypassed
+     *  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/image-hook.d.ts

@@ -1,4 +1,4 @@
-import type { MessageWithParts } from './types';
+import { type MessageWithParts } from './types';
 export declare function processImageAttachments(args: {
     messages: MessageWithParts[];
     workDir: string;

package/dist/hooks/index.d.ts

@@ -8,7 +8,9 @@ export { createFilterAvailableSkillsHook } from './filter-available-skills';
 export { ForegroundFallbackManager, isRateLimitError, } 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/loop-command/index.d.ts

@@ -0,0 +1,13 @@
+export declare function createLoopCommandHook(): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+};

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

@@ -6,15 +6,16 @@
  * of the user's actual turn.
  */
 import { PHASE_REMINDER } from '../../config/constants';
-import type { MessageWithParts } from '../types';
+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: MessageWithParts[];
+        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,12 +1,23 @@
 import type { PluginInput } from '@opencode-ai/plugin';
-import { BackgroundJobBoard } from '../../utils';
-import type { MessageWithParts } from '../types';
+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;
@@ -24,7 +35,7 @@ export declare function createTaskSessionManagerHook(_ctx: PluginInput, options:
         metadata?: unknown;
     }) => Promise<void>;
     'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
-        messages: MessageWithParts[];
+        messages?: unknown;
     }) => Promise<void>;
     event: (input: {
         event: {