oh-my-opencode 3.11.2 → 3.12.0

package/dist/cli/install-validators.d.ts

@@ -29,4 +29,5 @@ export declare function detectedToInitialValues(detected: DetectedConfig): {
     opencodeZen: BooleanArg;
     zaiCodingPlan: BooleanArg;
     kimiForCoding: BooleanArg;
+    opencodeGo: BooleanArg;
 };

package/dist/cli/model-fallback-requirements.d.ts

@@ -1,3 +1,3 @@
-import type { ModelRequirement } from "../shared/model-requirements";
+import { type ModelRequirement } from "../shared/model-requirements";
 export declare const CLI_AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
 export declare const CLI_CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;

package/dist/cli/model-fallback-types.d.ts

@@ -8,6 +8,7 @@ export interface ProviderAvailability {
     copilot: boolean;
     zai: boolean;
     kimiForCoding: boolean;
+    opencodeGo: boolean;
     isMaxPlan: boolean;
 }
 export interface AgentConfig {

package/dist/cli/openai-only-model-catalog.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedOmoConfig, ProviderAvailability } from "./model-fallback-types";
+export declare function isOpenAiOnlyAvailability(availability: ProviderAvailability): boolean;
+export declare function applyOpenAiOnlyModelCatalog(config: GeneratedOmoConfig): GeneratedOmoConfig;

package/dist/cli/run/index.d.ts

@@ -1,5 +1,6 @@
 export { run } from "./runner";
 export { resolveRunAgent } from "./agent-resolver";
+export { resolveRunModel } from "./model-resolver";
 export { createServerConnection } from "./server-connection";
 export { resolveSession } from "./session-resolver";
 export { createJsonOutputManager } from "./json-output";

package/dist/cli/run/model-resolver.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveRunModel(modelString?: string): {
+    providerID: string;
+    modelID: string;
+} | undefined;

package/dist/cli/run/types.d.ts

@@ -3,6 +3,7 @@ export type { OpencodeClient };
 export interface RunOptions {
     message: string;
     agent?: string;
+    model?: string;
     timestamp?: boolean;
     verbose?: boolean;
     directory?: string;

package/dist/cli/types.d.ts

@@ -9,6 +9,7 @@ export interface InstallArgs {
     opencodeZen?: BooleanArg;
     zaiCodingPlan?: BooleanArg;
     kimiForCoding?: BooleanArg;
+    opencodeGo?: BooleanArg;
     skipAuth?: boolean;
 }
 export interface InstallConfig {
@@ -20,6 +21,7 @@ export interface InstallConfig {
     hasOpencodeZen: boolean;
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;
+    hasOpencodeGo: boolean;
 }
 export interface ConfigMergeResult {
     success: boolean;
@@ -36,4 +38,5 @@ export interface DetectedConfig {
     hasOpencodeZen: boolean;
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;
+    hasOpencodeGo: boolean;
 }

package/dist/config/schema/agent-names.d.ts

@@ -9,6 +9,7 @@ export declare const BuiltinAgentNameSchema: z.ZodEnum<{
     metis: "metis";
     momus: "momus";
     atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
     prometheus: "prometheus";
 }>;
 export declare const BuiltinSkillNameSchema: z.ZodEnum<{
@@ -28,10 +29,10 @@ export declare const OverridableAgentNameSchema: z.ZodEnum<{
     metis: "metis";
     momus: "momus";
     atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
     build: "build";
     plan: "plan";
     prometheus: "prometheus";
-    "sisyphus-junior": "sisyphus-junior";
     "OpenCode-Builder": "OpenCode-Builder";
 }>;
 export declare const AgentNameSchema: z.ZodEnum<{
@@ -44,6 +45,7 @@ export declare const AgentNameSchema: z.ZodEnum<{
     metis: "metis";
     momus: "momus";
     atlas: "atlas";
+    "sisyphus-junior": "sisyphus-junior";
     prometheus: "prometheus";
 }>;
 export type AgentName = z.infer<typeof AgentNameSchema>;

package/dist/config/schema/background-task.d.ts

@@ -3,8 +3,16 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     defaultConcurrency: z.ZodOptional<z.ZodNumber>;
     providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    maxDescendants: z.ZodOptional<z.ZodNumber>;
     staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
     messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
     syncPollTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxToolCalls: z.ZodOptional<z.ZodNumber>;
+    circuitBreaker: z.ZodOptional<z.ZodObject<{
+        maxToolCalls: z.ZodOptional<z.ZodNumber>;
+        windowSize: z.ZodOptional<z.ZodNumber>;
+        repetitionThresholdPercent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;

package/dist/config/schema/git-env-prefix.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const GIT_ENV_PREFIX_VALIDATION_MESSAGE = "git_env_prefix must be empty or use shell-safe env assignments like \"GIT_MASTER=1\"";
+export declare function isValidGitEnvPrefix(value: string): boolean;
+export declare function assertValidGitEnvPrefix(value: string): string;
+export declare const GitEnvPrefixSchema: z.ZodDefault<z.ZodString>;

package/dist/config/schema/git-master.d.ts

@@ -2,5 +2,6 @@ import { z } from "zod";
 export declare const GitMasterConfigSchema: z.ZodObject<{
     commit_footer: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
     include_co_authored_by: z.ZodDefault<z.ZodBoolean>;
+    git_env_prefix: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 export type GitMasterConfig = z.infer<typeof GitMasterConfigSchema>;

package/dist/config/schema/hooks.d.ts

@@ -3,6 +3,7 @@ export declare const HookNameSchema: z.ZodEnum<{
     atlas: "atlas";
     "ralph-loop": "ralph-loop";
     "start-work": "start-work";
+    "gpt-permission-continuation": "gpt-permission-continuation";
     "todo-continuation-enforcer": "todo-continuation-enforcer";
     "context-window-monitor": "context-window-monitor";
     "session-recovery": "session-recovery";

package/dist/config/schema/oh-my-opencode-config.d.ts

@@ -1336,9 +1336,17 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         defaultConcurrency: z.ZodOptional<z.ZodNumber>;
         providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxDescendants: z.ZodOptional<z.ZodNumber>;
         staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
         messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
         syncPollTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxToolCalls: z.ZodOptional<z.ZodNumber>;
+        circuitBreaker: z.ZodOptional<z.ZodObject<{
+            maxToolCalls: z.ZodOptional<z.ZodNumber>;
+            windowSize: z.ZodOptional<z.ZodNumber>;
+            repetitionThresholdPercent: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     notification: z.ZodOptional<z.ZodObject<{
         force_enable: z.ZodOptional<z.ZodBoolean>;
@@ -1349,6 +1357,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     git_master: z.ZodOptional<z.ZodObject<{
         commit_footer: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
         include_co_authored_by: z.ZodDefault<z.ZodBoolean>;
+        git_env_prefix: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     browser_automation_engine: z.ZodOptional<z.ZodObject<{
         provider: z.ZodDefault<z.ZodEnum<{

package/dist/config/schema.d.ts

@@ -10,6 +10,7 @@ export * from "./schema/commands";
 export * from "./schema/dynamic-context-pruning";
 export * from "./schema/experimental";
 export * from "./schema/fallback-models";
+export * from "./schema/git-env-prefix";
 export * from "./schema/git-master";
 export * from "./schema/hooks";
 export * from "./schema/notification";

package/dist/create-hooks.d.ts

@@ -5,6 +5,15 @@ import type { BackgroundManager } from "./features/background-agent";
 import type { PluginContext } from "./plugin/types";
 import type { ModelCacheState } from "./plugin-state";
 export type CreatedHooks = ReturnType<typeof createHooks>;
+type DisposableHook = {
+    dispose?: () => void;
+} | null | undefined;
+export type DisposableCreatedHooks = {
+    runtimeFallback?: DisposableHook;
+    todoContinuationEnforcer?: DisposableHook;
+    autoSlashCommand?: DisposableHook;
+};
+export declare function disposeCreatedHooks(hooks: DisposableCreatedHooks): void;
 export declare function createHooks(args: {
     ctx: PluginContext;
     pluginConfig: OhMyOpenCodeConfig;
@@ -15,8 +24,10 @@ export declare function createHooks(args: {
     mergedSkills: LoadedSkill[];
     availableSkills: AvailableSkill[];
 }): {
+    disposeHooks: () => void;
     categorySkillReminder: ReturnType<typeof import("./hooks").createCategorySkillReminderHook> | null;
     autoSlashCommand: ReturnType<typeof import("./hooks").createAutoSlashCommandHook> | null;
+    gptPermissionContinuation: ReturnType<typeof import("./hooks").createGptPermissionContinuationHook> | null;
     stopContinuationGuard: ReturnType<typeof import("./hooks").createStopContinuationGuardHook> | null;
     compactionContextInjector: ReturnType<typeof import("./hooks").createCompactionContextInjector> | null;
     compactionTodoPreserver: ReturnType<typeof import("./hooks").createCompactionTodoPreserverHook> | null;
@@ -63,3 +74,4 @@ export declare function createHooks(args: {
     anthropicEffort: ReturnType<typeof import("./hooks/anthropic-effort").createAnthropicEffortHook> | null;
     runtimeFallback: ReturnType<typeof import("./hooks").createRuntimeFallbackHook> | null;
 };
+export {};

package/dist/features/background-agent/compaction-aware-message-resolver.d.ts

@@ -1,3 +1,18 @@
 import type { StoredMessage } from "../hook-message-injector";
+type SessionMessage = {
+    info?: {
+        agent?: string;
+        model?: {
+            providerID?: string;
+            modelID?: string;
+            variant?: string;
+        };
+        providerID?: string;
+        modelID?: string;
+        tools?: StoredMessage["tools"];
+    };
+};
 export declare function isCompactionAgent(agent: string | undefined): boolean;
-export declare function findNearestMessageExcludingCompaction(messageDir: string): StoredMessage | null;
+export declare function resolvePromptContextFromSessionMessages(messages: SessionMessage[], sessionID?: string): StoredMessage | null;
+export declare function findNearestMessageExcludingCompaction(messageDir: string, sessionID?: string): StoredMessage | null;
+export {};

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

@@ -1,9 +1,13 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { BackgroundTask, LaunchInput } from "./types";
 export declare const TASK_TTL_MS: number;
+export declare const TERMINAL_TASK_TTL_MS: number;
 export declare const MIN_STABILITY_TIME_MS: number;
-export declare const DEFAULT_STALE_TIMEOUT_MS = 180000;
-export declare const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 600000;
+export declare const DEFAULT_STALE_TIMEOUT_MS = 1200000;
+export declare const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 1800000;
+export declare const DEFAULT_MAX_TOOL_CALLS = 200;
+export declare const DEFAULT_CIRCUIT_BREAKER_WINDOW_SIZE = 20;
+export declare const DEFAULT_CIRCUIT_BREAKER_REPETITION_THRESHOLD_PERCENT = 80;
 export declare const MIN_RUNTIME_BEFORE_STALE_MS = 30000;
 export declare const MIN_IDLE_TIME_MS = 5000;
 export declare const POLLING_INTERVAL_MS = 3000;

package/dist/features/background-agent/loop-detector.d.ts

@@ -0,0 +1,17 @@
+import type { BackgroundTaskConfig } from "../../config/schema";
+import type { ToolCallWindow } from "./types";
+export interface CircuitBreakerSettings {
+    maxToolCalls: number;
+    windowSize: number;
+    repetitionThresholdPercent: number;
+}
+export interface ToolLoopDetectionResult {
+    triggered: boolean;
+    toolName?: string;
+    repeatedCount?: number;
+    sampleSize?: number;
+    thresholdPercent?: number;
+}
+export declare function resolveCircuitBreakerSettings(config?: BackgroundTaskConfig): CircuitBreakerSettings;
+export declare function recordToolCall(window: ToolCallWindow | undefined, toolName: string, settings: CircuitBreakerSettings): ToolCallWindow;
+export declare function detectRepetitiveToolUse(window: ToolCallWindow | undefined): ToolLoopDetectionResult;

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

@@ -2,6 +2,7 @@ import type { PluginInput } from "@opencode-ai/plugin";
 import type { BackgroundTask, LaunchInput, ResumeInput } from "./types";
 import { TaskHistory } from "./task-history";
 import type { BackgroundTaskConfig, TmuxConfig } from "../../config/schema";
+import { type SubagentSpawnContext } from "./subagent-spawn-limits";
 interface EventProperties {
     sessionID?: string;
     info?: {
@@ -37,16 +38,31 @@ export declare class BackgroundManager {
     private queuesByKey;
     private processingKeys;
     private completionTimers;
+    private completedTaskSummaries;
     private idleDeferralTimers;
     private notificationQueueByParent;
+    private rootDescendantCounts;
+    private preStartDescendantReservations;
     private enableParentSessionNotifications;
     readonly taskHistory: TaskHistory;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig, options?: {
         tmuxConfig?: TmuxConfig;
         onSubagentSessionCreated?: OnSubagentSessionCreated;
-        onShutdown?: () => void;
+        onShutdown?: () => void | Promise<void>;
         enableParentSessionNotifications?: boolean;
     });
+    assertCanSpawn(parentSessionID: string): Promise<SubagentSpawnContext>;
+    reserveSubagentSpawn(parentSessionID: string): Promise<{
+        spawnContext: SubagentSpawnContext;
+        descendantCount: number;
+        commit: () => number;
+        rollback: () => void;
+    }>;
+    private registerRootDescendant;
+    private unregisterRootDescendant;
+    private markPreStartDescendantReservation;
+    private settlePreStartDescendantReservation;
+    private rollbackPreStartDescendantReservation;
     launch(input: LaunchInput): Promise<BackgroundTask>;
     private processKey;
     private startTask;
@@ -94,6 +110,8 @@ export declare class BackgroundManager {
      * Cleans up the parent entry if no pending tasks remain.
      */
     private cleanupPendingByParent;
+    private clearTaskHistoryWhenParentTasksGone;
+    private scheduleTaskRemoval;
     cancelTask(taskId: string, options?: {
         source?: string;
         reason?: string;
@@ -123,8 +141,6 @@ export declare class BackgroundManager {
      */
     private tryCompleteTask;
     private notifyParentSession;
-    private formatDuration;
-    private isAbortedSessionError;
     private hasRunningTasks;
     private pruneStaleTasksAndNotifications;
     private checkAndInterruptStaleTasks;
@@ -134,7 +150,7 @@ export declare class BackgroundManager {
      * Cancels all pending concurrency waiters and clears timers.
      * Should be called when the plugin is unloaded.
      */
-    shutdown(): void;
+    shutdown(): Promise<void>;
     private enqueueNotificationForParent;
 }
 export {};

package/dist/features/background-agent/process-cleanup.d.ts

@@ -1,5 +1,5 @@
 interface CleanupTarget {
-    shutdown(): void;
+    shutdown(): void | Promise<void>;
 }
 export declare function registerManagerForCleanup(manager: CleanupTarget): void;
 export declare function unregisterManagerForCleanup(manager: CleanupTarget): void;

package/dist/features/background-agent/remove-task-toast-tracking.d.ts

@@ -0,0 +1 @@
+export declare function removeTaskToastTracking(taskId: string): void;

package/dist/features/background-agent/subagent-spawn-limits.d.ts

@@ -0,0 +1,23 @@
+import type { BackgroundTaskConfig } from "../../config/schema";
+import type { OpencodeClient } from "./constants";
+export declare const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+export declare const DEFAULT_MAX_ROOT_SESSION_SPAWN_BUDGET = 50;
+export interface SubagentSpawnContext {
+    rootSessionID: string;
+    parentDepth: number;
+    childDepth: number;
+}
+export declare function getMaxSubagentDepth(config?: BackgroundTaskConfig): number;
+export declare function getMaxRootSessionSpawnBudget(config?: BackgroundTaskConfig): number;
+export declare function resolveSubagentSpawnContext(client: OpencodeClient, parentSessionID: string): Promise<SubagentSpawnContext>;
+export declare function createSubagentDepthLimitError(input: {
+    childDepth: number;
+    maxDepth: number;
+    parentSessionID: string;
+    rootSessionID: string;
+}): Error;
+export declare function createSubagentDescendantLimitError(input: {
+    rootSessionID: string;
+    descendantCount: number;
+    maxDescendants: number;
+}): Error;

package/dist/features/background-agent/task-history.d.ts

@@ -14,5 +14,6 @@ export declare class TaskHistory {
     record(parentSessionID: string | undefined, entry: TaskHistoryEntry): void;
     getByParentSession(parentSessionID: string): TaskHistoryEntry[];
     clearSession(parentSessionID: string): void;
+    clearAll(): void;
     formatForCompaction(parentSessionID: string): string | null;
 }

package/dist/features/background-agent/task-poller.d.ts

@@ -17,4 +17,5 @@ export declare function checkAndInterruptStaleTasks(args: {
     concurrencyManager: ConcurrencyManager;
     notifyParentSession: (task: BackgroundTask) => Promise<void>;
     sessionStatuses?: SessionStatusMap;
+    onTaskInterrupted?: (task: BackgroundTask) => void;
 }): Promise<void>;

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

@@ -1,8 +1,16 @@
 import type { FallbackEntry } from "../../shared/model-requirements";
+import type { SessionPermissionRule } from "../../shared/question-denied-session-permission";
 export type BackgroundTaskStatus = "pending" | "running" | "completed" | "error" | "cancelled" | "interrupt";
+export interface ToolCallWindow {
+    toolNames: string[];
+    windowSize: number;
+    thresholdPercent: number;
+}
 export interface TaskProgress {
     toolCalls: number;
     lastTool?: string;
+    toolCallWindow?: ToolCallWindow;
+    countedToolPartIDs?: string[];
     lastUpdate: Date;
     lastMessage?: string;
     lastMessageAt?: Date;
@@ -10,11 +18,13 @@ export interface TaskProgress {
 export interface BackgroundTask {
     id: string;
     sessionID?: string;
+    rootSessionID?: string;
     parentSessionID: string;
     parentMessageID: string;
     description: string;
     prompt: string;
     agent: string;
+    spawnDepth?: number;
     status: BackgroundTaskStatus;
     queuedAt?: Date;
     startedAt?: Date;
@@ -75,6 +85,7 @@ export interface LaunchInput {
     skills?: string[];
     skillContent?: string;
     category?: string;
+    sessionPermission?: SessionPermissionRule[];
 }
 export interface ResumeInput {
     sessionId: string;

package/dist/features/claude-code-agent-loader/claude-model-mapper.d.ts

@@ -0,0 +1,4 @@
+export declare function mapClaudeModelToOpenCode(model: string | undefined): {
+    providerID: string;
+    modelID: string;
+} | undefined;

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

@@ -1,3 +1,3 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare function loadUserAgents(): Record<string, AgentConfig>;
-export declare function loadProjectAgents(directory?: string): Record<string, AgentConfig>;
+import type { ClaudeCodeAgentConfig } from "./types";
+export declare function loadUserAgents(): Record<string, ClaudeCodeAgentConfig>;
+export declare function loadProjectAgents(directory?: string): Record<string, ClaudeCodeAgentConfig>;

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

@@ -1,14 +1,21 @@
 import type { AgentConfig } from "@opencode-ai/sdk";
 export type AgentScope = "user" | "project";
+export type ClaudeCodeAgentConfig = Omit<AgentConfig, "model"> & {
+    model?: string | {
+        providerID: string;
+        modelID: string;
+    };
+};
 export interface AgentFrontmatter {
     name?: string;
     description?: string;
     model?: string;
     tools?: string;
+    mode?: "subagent" | "primary" | "all";
 }
 export interface LoadedAgent {
     name: string;
     path: string;
-    config: AgentConfig;
+    config: ClaudeCodeAgentConfig;
     scope: AgentScope;
 }

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

@@ -1,3 +1,3 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
+import type { ClaudeCodeAgentConfig } from "../claude-code-agent-loader/types";
 import type { LoadedPlugin } from "./types";
-export declare function loadPluginAgents(plugins: LoadedPlugin[]): Record<string, AgentConfig>;
+export declare function loadPluginAgents(plugins: LoadedPlugin[]): Record<string, ClaudeCodeAgentConfig>;

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

@@ -1,6 +1,6 @@
-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 { ClaudeCodeAgentConfig } from "../claude-code-agent-loader/types";
 import type { HooksConfig, LoadedPlugin, PluginLoadError, PluginLoaderOptions } from "./types";
 export { discoverInstalledPlugins } from "./discovery";
 export { loadPluginCommands } from "./command-loader";
@@ -11,7 +11,7 @@ export { loadPluginHooksConfigs } from "./hook-loader";
 export interface PluginComponentsResult {
     commands: Record<string, CommandDefinition>;
     skills: Record<string, CommandDefinition>;
-    agents: Record<string, AgentConfig>;
+    agents: Record<string, ClaudeCodeAgentConfig>;
     mcpServers: Record<string, McpServerConfig>;
     hooksConfigs: HooksConfig[];
     plugins: LoadedPlugin[];

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

@@ -26,18 +26,37 @@ export interface InstalledPluginsDatabaseV1 {
     plugins: Record<string, PluginInstallation>;
 }
 /**
- * Installed plugins database v2 (current)
- * plugins stored as arrays
+ * Installed plugins database v2
+ * plugins stored as arrays keyed by plugin identifier
  */
 export interface InstalledPluginsDatabaseV2 {
     version: 2;
     plugins: Record<string, PluginInstallation[]>;
 }
+/**
+ * Installed plugins database v3 entry (current Claude Code format)
+ * A flat array of plugin entries, each containing name and marketplace fields
+ * used to construct the plugin key as "name@marketplace".
+ */
+export interface InstalledPluginEntryV3 {
+    name: string;
+    marketplace: string;
+    scope: PluginScope;
+    version: string;
+    installPath: string;
+    lastUpdated: string;
+    gitCommitSha?: string;
+}
 /**
  * Installed plugins database structure
  * Located at ~/.claude/plugins/installed_plugins.json
+ *
+ * Supports three formats:
+ * - v1: { version: 1, plugins: Record<string, PluginInstallation> }
+ * - v2: { version: 2, plugins: Record<string, PluginInstallation[]> }
+ * - v3: InstalledPluginEntryV3[] (flat array, current Claude Code format)
  */
-export type InstalledPluginsDatabase = InstalledPluginsDatabaseV1 | InstalledPluginsDatabaseV2;
+export type InstalledPluginsDatabase = InstalledPluginsDatabaseV1 | InstalledPluginsDatabaseV2 | InstalledPluginEntryV3[];
 /**
  * Plugin author information
  */

package/dist/features/opencode-skill-loader/git-master-template-injection.d.ts

@@ -1,2 +1,2 @@
-import type { GitMasterConfig } from "../../config/schema";
+import { type GitMasterConfig } from "../../config/schema";
 export declare function injectGitMasterConfig(template: string, config?: GitMasterConfig): string;

package/dist/features/skill-mcp-manager/types.d.ts

@@ -41,11 +41,15 @@ export interface ProcessCleanupHandler {
 export interface SkillMcpManagerState {
     clients: Map<string, ManagedClient>;
     pendingConnections: Map<string, Promise<Client>>;
+    disconnectedSessions: Map<string, number>;
     authProviders: Map<string, McpOAuthProvider>;
     cleanupRegistered: boolean;
     cleanupInterval: ReturnType<typeof setInterval> | null;
     cleanupHandlers: ProcessCleanupHandler[];
     idleTimeoutMs: number;
+    shutdownGeneration: number;
+    inFlightConnections: Map<string, number>;
+    disposed: boolean;
 }
 export interface SkillMcpClientConnectionParams {
     state: SkillMcpManagerState;

package/dist/features/tmux-subagent/index.d.ts

@@ -10,6 +10,7 @@ export * from "./session-status-parser";
 export * from "./session-message-count";
 export * from "./session-ready-waiter";
 export * from "./types";
+export * from "./pane-state-parser";
 export * from "./pane-state-querier";
 export * from "./decision-engine";
 export * from "./action-executor";

package/dist/features/tmux-subagent/manager.d.ts

@@ -45,6 +45,11 @@ export declare class TmuxSessionManager {
     private isEnabled;
     private getCapacityConfig;
     private getSessionMappings;
+    private removeTrackedSession;
+    private markSessionClosePending;
+    private queryWindowStateSafely;
+    private tryCloseTrackedSession;
+    private retryPendingCloses;
     private enqueueDeferredSession;
     private removeDeferredSession;
     private startDeferredAttachLoop;

package/dist/features/tmux-subagent/pane-state-parser.d.ts

@@ -0,0 +1,8 @@
+import type { TmuxPaneInfo } from "./types";
+type ParsedPaneState = {
+    windowWidth: number;
+    windowHeight: number;
+    panes: TmuxPaneInfo[];
+};
+export declare function parsePaneStateOutput(stdout: string): ParsedPaneState | null;
+export {};

package/dist/features/tmux-subagent/tracked-session-state.d.ts

@@ -0,0 +1,8 @@
+import type { TrackedSession } from "./types";
+export declare function createTrackedSession(params: {
+    sessionId: string;
+    paneId: string;
+    description: string;
+    now?: Date;
+}): TrackedSession;
+export declare function markTrackedSessionClosePending(tracked: TrackedSession): TrackedSession;

package/dist/features/tmux-subagent/types.d.ts

@@ -4,6 +4,8 @@ export interface TrackedSession {
     description: string;
     createdAt: Date;
     lastSeenAt: Date;
+    closePending: boolean;
+    closeRetryCount: number;
     lastMessageCount?: number;
     stableIdlePolls?: number;
 }

package/dist/hooks/atlas/boulder-session-lineage.d.ts

@@ -0,0 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function isSessionInBoulderLineage(input: {
+    client: PluginInput["client"];
+    sessionID: string;
+    boulderSessionIDs: string[];
+}): Promise<boolean>;

package/dist/hooks/atlas/final-wave-approval-gate.d.ts

@@ -0,0 +1,6 @@
+import type { SessionState } from "./types";
+export declare function shouldPauseForFinalWaveApproval(input: {
+    planPath: string;
+    taskOutput: string;
+    sessionState: SessionState;
+}): boolean;

package/dist/hooks/atlas/final-wave-plan-state.d.ts

@@ -0,0 +1,5 @@
+export type FinalWavePlanState = {
+    pendingImplementationTaskCount: number;
+    pendingFinalWaveTaskCount: number;
+};
+export declare function readFinalWavePlanState(planPath: string): FinalWavePlanState | null;

package/dist/hooks/atlas/idle-event.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { AtlasHookOptions, SessionState } from "./types";
+export declare function handleAtlasSessionIdle(input: {
+    ctx: PluginInput;
+    options?: AtlasHookOptions;
+    getState: (sessionID: string) => SessionState;
+    sessionID: string;
+}): Promise<void>;