@heidi-dang/oh-my-opencode 3.10.0

package/dist/config/schema/ralph-loop.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const RalphLoopConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    default_max_iterations: z.ZodDefault<z.ZodNumber>;
+    state_dir: z.ZodOptional<z.ZodString>;
+    default_strategy: z.ZodDefault<z.ZodEnum<{
+        reset: "reset";
+        continue: "continue";
+    }>>;
+}, z.core.$strip>;
+export type RalphLoopConfig = z.infer<typeof RalphLoopConfigSchema>;

package/dist/config/schema/runtime-fallback.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const RuntimeFallbackConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    retry_on_errors: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    max_fallback_attempts: z.ZodOptional<z.ZodNumber>;
+    cooldown_seconds: z.ZodOptional<z.ZodNumber>;
+    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+    notify_on_fallback: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RuntimeFallbackConfig = z.infer<typeof RuntimeFallbackConfigSchema>;

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const SisyphusAgentConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    default_builder_enabled: z.ZodOptional<z.ZodBoolean>;
+    planner_enabled: z.ZodOptional<z.ZodBoolean>;
+    replace_plan: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SisyphusAgentConfig = z.infer<typeof SisyphusAgentConfigSchema>;

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const SisyphusTasksConfigSchema: z.ZodObject<{
+    storage_path: z.ZodOptional<z.ZodString>;
+    task_list_id: z.ZodOptional<z.ZodString>;
+    claude_code_compat: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const SisyphusConfigSchema: z.ZodObject<{
+    tasks: z.ZodOptional<z.ZodObject<{
+        storage_path: z.ZodOptional<z.ZodString>;
+        task_list_id: z.ZodOptional<z.ZodString>;
+        claude_code_compat: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SisyphusTasksConfig = z.infer<typeof SisyphusTasksConfigSchema>;
+export type SisyphusConfig = z.infer<typeof SisyphusConfigSchema>;

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

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export declare const SkillSourceSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+    glob: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export declare const SkillDefinitionSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    subtask: z.ZodOptional<z.ZodBoolean>;
+    "argument-hint": z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const SkillEntrySchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    subtask: z.ZodOptional<z.ZodBoolean>;
+    "argument-hint": z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>]>;
+export declare const SkillsConfigSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+    sources: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+        glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    enable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    subtask: z.ZodOptional<z.ZodBoolean>;
+    "argument-hint": z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>]>>>]>;
+export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
+export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;

package/dist/config/schema/start-work.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const StartWorkConfigSchema: z.ZodObject<{
+    auto_commit: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type StartWorkConfig = z.infer<typeof StartWorkConfigSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const TmuxLayoutSchema: z.ZodEnum<{
+    "main-horizontal": "main-horizontal";
+    "main-vertical": "main-vertical";
+    tiled: "tiled";
+    "even-horizontal": "even-horizontal";
+    "even-vertical": "even-vertical";
+}>;
+export declare const TmuxConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        "main-horizontal": "main-horizontal";
+        "main-vertical": "main-vertical";
+        tiled: "tiled";
+        "even-horizontal": "even-horizontal";
+        "even-vertical": "even-vertical";
+    }>>;
+    main_pane_size: z.ZodDefault<z.ZodNumber>;
+    main_pane_min_width: z.ZodDefault<z.ZodNumber>;
+    agent_pane_min_width: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
+export type TmuxLayout = z.infer<typeof TmuxLayoutSchema>;

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const WebsearchProviderSchema: z.ZodEnum<{
+    exa: "exa";
+    tavily: "tavily";
+}>;
+export declare const WebsearchConfigSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        exa: "exa";
+        tavily: "tavily";
+    }>>;
+}, z.core.$strip>;
+export type WebsearchProvider = z.infer<typeof WebsearchProviderSchema>;
+export type WebsearchConfig = z.infer<typeof WebsearchConfigSchema>;

package/dist/config/schema.d.ts

@@ -0,0 +1,24 @@
+export * from "./schema/agent-names";
+export * from "./schema/agent-overrides";
+export * from "./schema/babysitting";
+export * from "./schema/background-task";
+export * from "./schema/browser-automation";
+export * from "./schema/categories";
+export * from "./schema/claude-code";
+export * from "./schema/comment-checker";
+export * from "./schema/commands";
+export * from "./schema/dynamic-context-pruning";
+export * from "./schema/experimental";
+export * from "./schema/fallback-models";
+export * from "./schema/git-master";
+export * from "./schema/hooks";
+export * from "./schema/notification";
+export * from "./schema/oh-my-opencode-config";
+export * from "./schema/ralph-loop";
+export * from "./schema/runtime-fallback";
+export * from "./schema/skills";
+export * from "./schema/sisyphus";
+export * from "./schema/sisyphus-agent";
+export * from "./schema/tmux";
+export * from "./schema/websearch";
+export { AnyMcpNameSchema, type AnyMcpName, McpNameSchema, type McpName } from "../mcp/types";

package/dist/create-hooks.d.ts

@@ -0,0 +1,65 @@
+import type { AvailableSkill } from "./agents/dynamic-agent-prompt-builder";
+import type { HookName, OhMyOpenCodeConfig } from "./config";
+import type { LoadedSkill } from "./features/opencode-skill-loader/types";
+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>;
+export declare function createHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    modelCacheState: ModelCacheState;
+    backgroundManager: BackgroundManager;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+    mergedSkills: LoadedSkill[];
+    availableSkills: AvailableSkill[];
+}): {
+    categorySkillReminder: ReturnType<typeof import("./hooks").createCategorySkillReminderHook> | null;
+    autoSlashCommand: ReturnType<typeof import("./hooks").createAutoSlashCommandHook> | null;
+    stopContinuationGuard: ReturnType<typeof import("./hooks").createStopContinuationGuardHook> | null;
+    compactionContextInjector: ReturnType<typeof import("./hooks").createCompactionContextInjector> | null;
+    compactionTodoPreserver: ReturnType<typeof import("./hooks").createCompactionTodoPreserverHook> | null;
+    todoContinuationEnforcer: ReturnType<typeof import("./hooks").createTodoContinuationEnforcer> | null;
+    unstableAgentBabysitter: ReturnType<typeof import("./plugin/unstable-agent-babysitter").createUnstableAgentBabysitter> | null;
+    backgroundNotificationHook: ReturnType<typeof import("./hooks").createBackgroundNotificationHook> | null;
+    atlasHook: ReturnType<typeof import("./hooks").createAtlasHook> | null;
+    claudeCodeHooks: ReturnType<typeof import("./hooks").createClaudeCodeHooksHook> | null;
+    keywordDetector: ReturnType<typeof import("./hooks").createKeywordDetectorHook> | null;
+    contextInjectorMessagesTransform: ReturnType<typeof import("./features/context-injector").createContextInjectorMessagesTransformHook>;
+    thinkingBlockValidator: ReturnType<typeof import("./hooks").createThinkingBlockValidatorHook> | null;
+    commentChecker: ReturnType<typeof import("./hooks").createCommentCheckerHooks> | null;
+    toolOutputTruncator: ReturnType<typeof import("./hooks").createToolOutputTruncatorHook> | null;
+    directoryAgentsInjector: ReturnType<typeof import("./hooks").createDirectoryAgentsInjectorHook> | null;
+    directoryReadmeInjector: ReturnType<typeof import("./hooks").createDirectoryReadmeInjectorHook> | null;
+    emptyTaskResponseDetector: ReturnType<typeof import("./hooks").createEmptyTaskResponseDetectorHook> | null;
+    rulesInjector: ReturnType<typeof import("./hooks").createRulesInjectorHook> | null;
+    tasksTodowriteDisabler: ReturnType<typeof import("./hooks").createTasksTodowriteDisablerHook> | null;
+    writeExistingFileGuard: ReturnType<typeof import("./hooks").createWriteExistingFileGuardHook> | null;
+    hashlineReadEnhancer: ReturnType<typeof import("./hooks").createHashlineReadEnhancerHook> | null;
+    jsonErrorRecovery: ReturnType<typeof import("./hooks").createJsonErrorRecoveryHook> | null;
+    readImageResizer: ReturnType<typeof import("./hooks").createReadImageResizerHook> | null;
+    contextWindowMonitor: ReturnType<typeof import("./hooks").createContextWindowMonitorHook> | null;
+    preemptiveCompaction: ReturnType<typeof import("./hooks").createPreemptiveCompactionHook> | null;
+    sessionRecovery: ReturnType<typeof import("./hooks").createSessionRecoveryHook> | null;
+    sessionNotification: ReturnType<typeof import("./hooks").createSessionNotification> | null;
+    thinkMode: ReturnType<typeof import("./hooks").createThinkModeHook> | null;
+    modelFallback: ReturnType<typeof import("./hooks").createModelFallbackHook> | null;
+    anthropicContextWindowLimitRecovery: ReturnType<typeof import("./hooks").createAnthropicContextWindowLimitRecoveryHook> | null;
+    autoUpdateChecker: ReturnType<typeof import("./hooks").createAutoUpdateCheckerHook> | null;
+    agentUsageReminder: ReturnType<typeof import("./hooks").createAgentUsageReminderHook> | null;
+    nonInteractiveEnv: ReturnType<typeof import("./hooks").createNonInteractiveEnvHook> | null;
+    interactiveBashSession: ReturnType<typeof import("./hooks").createInteractiveBashSessionHook> | null;
+    ralphLoop: ReturnType<typeof import("./hooks").createRalphLoopHook> | null;
+    editErrorRecovery: ReturnType<typeof import("./hooks").createEditErrorRecoveryHook> | null;
+    delegateTaskRetry: ReturnType<typeof import("./hooks").createDelegateTaskRetryHook> | null;
+    startWork: ReturnType<typeof import("./hooks").createStartWorkHook> | null;
+    prometheusMdOnly: ReturnType<typeof import("./hooks").createPrometheusMdOnlyHook> | null;
+    sisyphusJuniorNotepad: ReturnType<typeof import("./hooks").createSisyphusJuniorNotepadHook> | null;
+    noSisyphusGpt: ReturnType<typeof import("./hooks").createNoSisyphusGptHook> | null;
+    noHephaestusNonGpt: ReturnType<typeof import("./hooks").createNoHephaestusNonGptHook> | null;
+    questionLabelTruncator: ReturnType<typeof import("./hooks").createQuestionLabelTruncatorHook> | null;
+    taskResumeInfo: ReturnType<typeof import("./hooks").createTaskResumeInfoHook> | null;
+    anthropicEffort: ReturnType<typeof import("./hooks/anthropic-effort").createAnthropicEffortHook> | null;
+    runtimeFallback: ReturnType<typeof import("./hooks").createRuntimeFallbackHook> | null;
+};

package/dist/create-managers.d.ts

@@ -0,0 +1,20 @@
+import type { OhMyOpenCodeConfig } from "./config";
+import type { ModelCacheState } from "./plugin-state";
+import type { PluginContext, TmuxConfig } from "./plugin/types";
+import { BackgroundManager } from "./features/background-agent";
+import { SkillMcpManager } from "./features/skill-mcp-manager";
+import { TmuxSessionManager } from "./features/tmux-subagent";
+import { createConfigHandler } from "./plugin-handlers";
+export type Managers = {
+    tmuxSessionManager: TmuxSessionManager;
+    backgroundManager: BackgroundManager;
+    skillMcpManager: SkillMcpManager;
+    configHandler: ReturnType<typeof createConfigHandler>;
+};
+export declare function createManagers(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    tmuxConfig: TmuxConfig;
+    modelCacheState: ModelCacheState;
+    backgroundNotificationHookEnabled: boolean;
+}): Managers;

package/dist/create-tools.d.ts

@@ -0,0 +1,20 @@
+import type { AvailableCategory, AvailableSkill } from "./agents/dynamic-agent-prompt-builder";
+import type { OhMyOpenCodeConfig } from "./config";
+import type { BrowserAutomationProvider } from "./config/schema/browser-automation";
+import type { LoadedSkill } from "./features/opencode-skill-loader/types";
+import type { PluginContext, ToolsRecord } from "./plugin/types";
+import type { Managers } from "./create-managers";
+export type CreateToolsResult = {
+    filteredTools: ToolsRecord;
+    mergedSkills: LoadedSkill[];
+    availableSkills: AvailableSkill[];
+    availableCategories: AvailableCategory[];
+    browserProvider: BrowserAutomationProvider;
+    disabledSkills: Set<string>;
+    taskSystemEnabled: boolean;
+};
+export declare function createTools(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">;
+}): Promise<CreateToolsResult>;

package/dist/features/background-agent/background-task-notification-template.d.ts

@@ -0,0 +1,10 @@
+import type { BackgroundTask } from "./types";
+export type BackgroundTaskNotificationStatus = "COMPLETED" | "CANCELLED" | "INTERRUPTED";
+export declare function buildBackgroundTaskNotificationText(input: {
+    task: BackgroundTask;
+    duration: string;
+    statusText: BackgroundTaskNotificationStatus;
+    allComplete: boolean;
+    remainingCount: number;
+    completedTasks: BackgroundTask[];
+}): string;

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

@@ -0,0 +1,3 @@
+import type { StoredMessage } from "../hook-message-injector";
+export declare function isCompactionAgent(agent: string | undefined): boolean;
+export declare function findNearestMessageExcludingCompaction(messageDir: string): StoredMessage | null;

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

@@ -0,0 +1,27 @@
+import type { BackgroundTaskConfig } from "../../config/schema";
+export declare class ConcurrencyManager {
+    private config?;
+    private counts;
+    private queues;
+    constructor(config?: BackgroundTaskConfig);
+    getConcurrencyLimit(model: string): number;
+    acquire(model: string): Promise<void>;
+    release(model: string): void;
+    /**
+     * Cancel all waiting acquires for a model. Used during cleanup.
+     */
+    cancelWaiters(model: string): void;
+    /**
+     * Clear all state. Used during manager cleanup/shutdown.
+     * Cancels all pending waiters.
+     */
+    clear(): void;
+    /**
+     * Get current count for a model (for testing/debugging)
+     */
+    getCount(model: string): number;
+    /**
+     * Get queue length for a model (for testing/debugging)
+     */
+    getQueueLength(model: string): number;
+}

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

@@ -0,0 +1,45 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BackgroundTask, LaunchInput } from "./types";
+export declare const 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 MIN_RUNTIME_BEFORE_STALE_MS = 30000;
+export declare const MIN_IDLE_TIME_MS = 5000;
+export declare const POLLING_INTERVAL_MS = 3000;
+export declare const TASK_CLEANUP_DELAY_MS: number;
+export declare const TMUX_CALLBACK_DELAY_MS = 200;
+export type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit";
+export type OpencodeClient = PluginInput["client"];
+export interface MessagePartInfo {
+    sessionID?: string;
+    type?: string;
+    tool?: string;
+}
+export interface EventProperties {
+    sessionID?: string;
+    info?: {
+        id?: string;
+    };
+    [key: string]: unknown;
+}
+export interface BackgroundEvent {
+    type: string;
+    properties?: EventProperties;
+}
+export interface Todo {
+    content: string;
+    status: string;
+    priority: string;
+    id?: string;
+}
+export interface QueueItem {
+    task: BackgroundTask;
+    input: LaunchInput;
+}
+export interface SubagentSessionCreatedEvent {
+    sessionID: string;
+    parentID: string;
+    title: string;
+}
+export type OnSubagentSessionCreated = (event: SubagentSessionCreatedEvent) => Promise<void>;

package/dist/features/background-agent/duration-formatter.d.ts

@@ -0,0 +1 @@
+export declare function formatDuration(start: Date, end?: Date): string;

package/dist/features/background-agent/error-classifier.d.ts

@@ -0,0 +1,10 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isAbortedSessionError(error: unknown): boolean;
+export declare function getErrorText(error: unknown): string;
+export declare function extractErrorName(error: unknown): string | undefined;
+export declare function extractErrorMessage(error: unknown): string | undefined;
+interface EventPropertiesLike {
+    [key: string]: unknown;
+}
+export declare function getSessionErrorMessage(properties: EventPropertiesLike): string | undefined;
+export {};

package/dist/features/background-agent/fallback-retry-handler.d.ts

@@ -0,0 +1,16 @@
+import type { BackgroundTask } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+import type { OpencodeClient, QueueItem } from "./constants";
+export declare function tryFallbackRetry(args: {
+    task: BackgroundTask;
+    errorInfo: {
+        name?: string;
+        message?: string;
+    };
+    source: string;
+    concurrencyManager: ConcurrencyManager;
+    client: OpencodeClient;
+    idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    queuesByKey: Map<string, QueueItem[]>;
+    processKey: (key: string) => void;
+}): boolean;

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

@@ -0,0 +1,2 @@
+export * from "./types";
+export { BackgroundManager, type SubagentSessionCreatedEvent, type OnSubagentSessionCreated } from "./manager";

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

@@ -0,0 +1,140 @@
+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";
+interface EventProperties {
+    sessionID?: string;
+    info?: {
+        id?: string;
+    };
+    [key: string]: unknown;
+}
+interface Event {
+    type: string;
+    properties?: EventProperties;
+}
+export interface SubagentSessionCreatedEvent {
+    sessionID: string;
+    parentID: string;
+    title: string;
+}
+export type OnSubagentSessionCreated = (event: SubagentSessionCreatedEvent) => Promise<void>;
+export declare class BackgroundManager {
+    private tasks;
+    private notifications;
+    private pendingNotifications;
+    private pendingByParent;
+    private client;
+    private directory;
+    private pollingInterval?;
+    private pollingInFlight;
+    private concurrencyManager;
+    private shutdownTriggered;
+    private config?;
+    private tmuxEnabled;
+    private onSubagentSessionCreated?;
+    private onShutdown?;
+    private queuesByKey;
+    private processingKeys;
+    private completionTimers;
+    private idleDeferralTimers;
+    private notificationQueueByParent;
+    private enableParentSessionNotifications;
+    readonly taskHistory: TaskHistory;
+    constructor(ctx: PluginInput, config?: BackgroundTaskConfig, options?: {
+        tmuxConfig?: TmuxConfig;
+        onSubagentSessionCreated?: OnSubagentSessionCreated;
+        onShutdown?: () => void;
+        enableParentSessionNotifications?: boolean;
+    });
+    launch(input: LaunchInput): Promise<BackgroundTask>;
+    private processKey;
+    private startTask;
+    getTask(id: string): BackgroundTask | undefined;
+    getTasksByParentSession(sessionID: string): BackgroundTask[];
+    getAllDescendantTasks(sessionID: string): BackgroundTask[];
+    findBySession(sessionID: string): BackgroundTask | undefined;
+    private getConcurrencyKeyFromInput;
+    /**
+     * Track a task created elsewhere (e.g., from task) for notification tracking.
+     * This allows tasks created by other tools to receive the same toast/prompt notifications.
+     */
+    trackTask(input: {
+        taskId: string;
+        sessionID: string;
+        parentSessionID: string;
+        description: string;
+        agent?: string;
+        parentAgent?: string;
+        concurrencyKey?: string;
+    }): Promise<BackgroundTask>;
+    resume(input: ResumeInput): Promise<BackgroundTask>;
+    private checkSessionTodos;
+    handleEvent(event: Event): void;
+    private tryFallbackRetry;
+    markForNotification(task: BackgroundTask): void;
+    getPendingNotifications(sessionID: string): BackgroundTask[];
+    clearNotifications(sessionID: string): void;
+    queuePendingNotification(sessionID: string | undefined, notification: string): void;
+    injectPendingNotificationsIntoChatMessage(output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+            [key: string]: unknown;
+        }>;
+    }, sessionID: string): void;
+    /**
+     * Validates that a session has actual assistant/tool output before marking complete.
+     * Prevents premature completion when session.idle fires before agent responds.
+     */
+    private validateSessionHasOutput;
+    private clearNotificationsForTask;
+    /**
+     * Remove task from pending tracking for its parent session.
+     * Cleans up the parent entry if no pending tasks remain.
+     */
+    private cleanupPendingByParent;
+    cancelTask(taskId: string, options?: {
+        source?: string;
+        reason?: string;
+        abortSession?: boolean;
+        skipNotification?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Cancels a pending task by removing it from queue and marking as cancelled.
+     * Does NOT abort session (no session exists yet) or release concurrency slot (wasn't acquired).
+     */
+    cancelPendingTask(taskId: string): boolean;
+    private startPolling;
+    private stopPolling;
+    private registerProcessCleanup;
+    private unregisterProcessCleanup;
+    /**
+     * Get all running tasks (for compaction hook)
+     */
+    getRunningTasks(): BackgroundTask[];
+    /**
+     * Get all non-running tasks still in memory (for compaction hook)
+     */
+    getNonRunningTasks(): BackgroundTask[];
+    /**
+     * Safely complete a task with race condition protection.
+     * Returns true if task was successfully completed, false if already completed by another path.
+     */
+    private tryCompleteTask;
+    private notifyParentSession;
+    private formatDuration;
+    private isAbortedSessionError;
+    private hasRunningTasks;
+    private pruneStaleTasksAndNotifications;
+    private checkAndInterruptStaleTasks;
+    private pollRunningTasks;
+    /**
+     * Shutdown the manager gracefully.
+     * Cancels all pending concurrency waiters and clears timers.
+     * Should be called when the plugin is unloaded.
+     */
+    shutdown(): void;
+    private enqueueNotificationForParent;
+}
+export {};

package/dist/features/background-agent/opencode-client.d.ts

@@ -0,0 +1,2 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export type OpencodeClient = PluginInput["client"];

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

@@ -0,0 +1,8 @@
+interface CleanupTarget {
+    shutdown(): void;
+}
+export declare function registerManagerForCleanup(manager: CleanupTarget): void;
+export declare function unregisterManagerForCleanup(manager: CleanupTarget): void;
+/** @internal — test-only reset for module-level singleton state */
+export declare function _resetForTesting(): void;
+export {};

package/dist/features/background-agent/session-idle-event-handler.d.ts

@@ -0,0 +1,10 @@
+import type { BackgroundTask } from "./types";
+export declare function handleSessionIdleBackgroundEvent(args: {
+    properties: Record<string, unknown>;
+    findBySession: (sessionID: string) => BackgroundTask | undefined;
+    idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    validateSessionHasOutput: (sessionID: string) => Promise<boolean>;
+    checkSessionTodos: (sessionID: string) => Promise<boolean>;
+    tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>;
+    emitIdleEvent: (sessionID: string) => void;
+}): void;

package/dist/features/background-agent/spawner/parent-directory-resolver.d.ts

@@ -0,0 +1,6 @@
+import type { OpencodeClient } from "../constants";
+export declare function resolveParentDirectory(options: {
+    client: OpencodeClient;
+    parentSessionID: string;
+    defaultDirectory: string;
+}): Promise<string>;

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

@@ -0,0 +1,14 @@
+import type { BackgroundTask, LaunchInput, ResumeInput } from "./types";
+import type { OpencodeClient, OnSubagentSessionCreated, QueueItem } from "./constants";
+import type { ConcurrencyManager } from "./concurrency";
+export interface SpawnerContext {
+    client: OpencodeClient;
+    directory: string;
+    concurrencyManager: ConcurrencyManager;
+    tmuxEnabled: boolean;
+    onSubagentSessionCreated?: OnSubagentSessionCreated;
+    onTaskError: (task: BackgroundTask, error: Error) => void;
+}
+export declare function createTask(input: LaunchInput): BackgroundTask;
+export declare function startTask(item: QueueItem, ctx: SpawnerContext): Promise<void>;
+export declare function resumeTask(task: BackgroundTask, input: ResumeInput, ctx: Pick<SpawnerContext, "client" | "concurrencyManager" | "onTaskError">): Promise<void>;

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

@@ -0,0 +1,35 @@
+import type { BackgroundTask, LaunchInput } from "./types";
+import type { QueueItem } from "./constants";
+export declare class TaskStateManager {
+    readonly tasks: Map<string, BackgroundTask>;
+    readonly notifications: Map<string, BackgroundTask[]>;
+    readonly pendingByParent: Map<string, Set<string>>;
+    readonly queuesByKey: Map<string, QueueItem[]>;
+    readonly processingKeys: Set<string>;
+    readonly completionTimers: Map<string, ReturnType<typeof setTimeout>>;
+    getTask(id: string): BackgroundTask | undefined;
+    findBySession(sessionID: string): BackgroundTask | undefined;
+    getTasksByParentSession(sessionID: string): BackgroundTask[];
+    getAllDescendantTasks(sessionID: string): BackgroundTask[];
+    getRunningTasks(): BackgroundTask[];
+    getNonRunningTasks(): BackgroundTask[];
+    hasRunningTasks(): boolean;
+    getConcurrencyKeyFromInput(input: LaunchInput): string;
+    getConcurrencyKeyFromTask(task: BackgroundTask): string;
+    addTask(task: BackgroundTask): void;
+    removeTask(taskId: string): void;
+    trackPendingTask(parentSessionID: string, taskId: string): void;
+    cleanupPendingByParent(task: BackgroundTask): void;
+    markForNotification(task: BackgroundTask): void;
+    getPendingNotifications(sessionID: string): BackgroundTask[];
+    clearNotifications(sessionID: string): void;
+    clearNotificationsForTask(taskId: string): void;
+    addToQueue(key: string, item: QueueItem): void;
+    getQueue(key: string): QueueItem[] | undefined;
+    removeFromQueue(key: string, taskId: string): boolean;
+    setCompletionTimer(taskId: string, timer: ReturnType<typeof setTimeout>): void;
+    clearCompletionTimer(taskId: string): void;
+    clearAllCompletionTimers(): void;
+    clear(): void;
+    cancelPendingTask(taskId: string): boolean;
+}