oh-my-opencode 3.4.0 → 3.5.1

package/dist/create-hooks.d.ts

@@ -0,0 +1,57 @@
+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";
+export type CreatedHooks = ReturnType<typeof createHooks>;
+export declare function createHooks(args: {
+    ctx: PluginContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    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>;
+    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;
+    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;
+    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;
+    questionLabelTruncator: ReturnType<typeof import("./hooks").createQuestionLabelTruncatorHook>;
+    subagentQuestionBlocker: ReturnType<typeof import("./hooks").createSubagentQuestionBlockerHook>;
+    taskResumeInfo: ReturnType<typeof import("./hooks").createTaskResumeInfoHook>;
+    anthropicEffort: ReturnType<typeof import("./hooks/anthropic-effort").createAnthropicEffortHook> | null;
+};

package/dist/create-managers.d.ts

@@ -0,0 +1,19 @@
+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;
+}): 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-event-handler.d.ts

@@ -0,0 +1,25 @@
+import type { BackgroundTask } from "./types";
+type Event = {
+    type: string;
+    properties?: Record<string, unknown>;
+};
+export declare function handleBackgroundEvent(args: {
+    event: Event;
+    findBySession: (sessionID: string) => BackgroundTask | undefined;
+    getAllDescendantTasks: (sessionID: string) => BackgroundTask[];
+    cancelTask: (taskId: string, options: {
+        source: string;
+        reason: string;
+        skipNotification: true;
+    }) => Promise<boolean>;
+    tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>;
+    validateSessionHasOutput: (sessionID: string) => Promise<boolean>;
+    checkSessionTodos: (sessionID: string) => Promise<boolean>;
+    idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    completionTimers: Map<string, ReturnType<typeof setTimeout>>;
+    tasks: Map<string, BackgroundTask>;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+    clearNotificationsForTask: (taskId: string) => void;
+    emitIdleEvent: (sessionID: string) => void;
+}): void;
+export {};

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

@@ -0,0 +1,25 @@
+import type { BackgroundTask, LaunchInput } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+import type { PluginInput } from "@opencode-ai/plugin";
+type QueueItem = {
+    task: BackgroundTask;
+    input: LaunchInput;
+};
+export declare function shutdownBackgroundManager(args: {
+    shutdownTriggered: {
+        value: boolean;
+    };
+    stopPolling: () => void;
+    tasks: Map<string, BackgroundTask>;
+    client: PluginInput["client"];
+    onShutdown?: () => void;
+    concurrencyManager: ConcurrencyManager;
+    completionTimers: Map<string, ReturnType<typeof setTimeout>>;
+    idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    notifications: Map<string, BackgroundTask[]>;
+    pendingByParent: Map<string, Set<string>>;
+    queuesByKey: Map<string, QueueItem[]>;
+    processingKeys: Set<string>;
+    unregisterProcessCleanup: () => void;
+}): void;
+export {};

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

@@ -0,0 +1,3 @@
+import type { BackgroundTask } from "./types";
+import type { ResultHandlerContext } from "./result-handler-context";
+export declare function tryCompleteTask(task: BackgroundTask, source: string, ctx: ResultHandlerContext): Promise<boolean>;

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/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,2 @@
+export declare function isAbortedSessionError(error: unknown): boolean;
+export declare function getErrorText(error: unknown): string;

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

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

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

@@ -102,9 +102,9 @@ export declare class BackgroundManager {
      */
     getRunningTasks(): BackgroundTask[];
     /**
-     * Get all completed tasks still in memory (for compaction hook)
+     * Get all non-running tasks still in memory (for compaction hook)
      */
-    getCompletedTasks(): BackgroundTask[];
+    getNonRunningTasks(): BackgroundTask[];
     /**
      * Safely complete a task with race condition protection.
      * Returns true if task was successfully completed, false if already completed by another path.

package/dist/features/background-agent/message-dir.d.ts

@@ -0,0 +1 @@
+export { getMessageDir } from "./message-storage-locator";

package/dist/features/background-agent/message-storage-locator.d.ts

@@ -0,0 +1 @@
+export declare function getMessageDir(sessionID: string): string | null;

package/dist/features/background-agent/notification-builder.d.ts

@@ -0,0 +1,8 @@
+import type { BackgroundTask } from "./types";
+export declare function buildBackgroundTaskNotificationText(args: {
+    task: BackgroundTask;
+    duration: string;
+    allComplete: boolean;
+    remainingCount: number;
+    completedTasks: BackgroundTask[];
+}): string;

package/dist/features/background-agent/notification-tracker.d.ts

@@ -0,0 +1,6 @@
+import type { BackgroundTask } from "./types";
+export declare function markForNotification(notifications: Map<string, BackgroundTask[]>, task: BackgroundTask): void;
+export declare function getPendingNotifications(notifications: Map<string, BackgroundTask[]>, sessionID: string): BackgroundTask[];
+export declare function clearNotifications(notifications: Map<string, BackgroundTask[]>, sessionID: string): void;
+export declare function clearNotificationsForTask(notifications: Map<string, BackgroundTask[]>, taskId: string): void;
+export declare function cleanupPendingByParent(pendingByParent: Map<string, Set<string>>, task: BackgroundTask): void;

package/dist/features/background-agent/notify-parent-session.d.ts

@@ -0,0 +1,10 @@
+import type { BackgroundTask } from "./types";
+import type { OpencodeClient } from "./opencode-client";
+export declare function notifyParentSession(args: {
+    task: BackgroundTask;
+    tasks: Map<string, BackgroundTask>;
+    pendingByParent: Map<string, Set<string>>;
+    completionTimers: Map<string, ReturnType<typeof setTimeout>>;
+    clearNotificationsForTask: (taskId: string) => void;
+    client: OpencodeClient;
+}): Promise<void>;

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/parent-session-context-resolver.d.ts

@@ -0,0 +1,14 @@
+import type { OpencodeClient } from "./constants";
+import type { BackgroundTask } from "./types";
+type AgentModel = {
+    providerID: string;
+    modelID: string;
+};
+export declare function resolveParentSessionAgentAndModel(input: {
+    client: OpencodeClient;
+    task: BackgroundTask;
+}): Promise<{
+    agent?: string;
+    model?: AgentModel;
+}>;
+export {};

package/dist/features/background-agent/parent-session-notifier.d.ts

@@ -0,0 +1,3 @@
+import type { BackgroundTask } from "./types";
+import type { ResultHandlerContext } from "./result-handler-context";
+export declare function notifyParentSession(task: BackgroundTask, ctx: ResultHandlerContext): Promise<void>;

package/dist/features/background-agent/poll-running-tasks.d.ts

@@ -0,0 +1,13 @@
+import type { BackgroundTask } from "./types";
+import type { OpencodeClient } from "./opencode-client";
+export declare function pollRunningTasks(args: {
+    tasks: Iterable<BackgroundTask>;
+    client: OpencodeClient;
+    pruneStaleTasksAndNotifications: () => void;
+    checkAndInterruptStaleTasks: () => Promise<void>;
+    validateSessionHasOutput: (sessionID: string) => Promise<boolean>;
+    checkSessionTodos: (sessionID: string) => Promise<boolean>;
+    tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>;
+    hasRunningTasks: () => boolean;
+    stopPolling: () => void;
+}): Promise<void>;

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

@@ -0,0 +1,2 @@
+export type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit";
+export declare function registerProcessSignal(signal: ProcessCleanupEvent, handler: () => void, exitAfter: boolean): () => void;

package/dist/features/background-agent/result-handler-context.d.ts

@@ -0,0 +1,8 @@
+import type { OpencodeClient } from "./constants";
+import type { ConcurrencyManager } from "./concurrency";
+import type { TaskStateManager } from "./state";
+export interface ResultHandlerContext {
+    client: OpencodeClient;
+    concurrencyManager: ConcurrencyManager;
+    state: TaskStateManager;
+}

package/dist/features/background-agent/result-handler.d.ts

@@ -1,15 +1,7 @@
-import type { BackgroundTask } from "./types";
-import type { OpencodeClient } from "./constants";
-import type { ConcurrencyManager } from "./concurrency";
-import type { TaskStateManager } from "./state";
-export interface ResultHandlerContext {
-    client: OpencodeClient;
-    concurrencyManager: ConcurrencyManager;
-    state: TaskStateManager;
-}
-export declare function checkSessionTodos(client: OpencodeClient, sessionID: string): Promise<boolean>;
-export declare function validateSessionHasOutput(client: OpencodeClient, sessionID: string): Promise<boolean>;
-export declare function formatDuration(start: Date, end?: Date): string;
-export declare function getMessageDir(sessionID: string): string | null;
-export declare function tryCompleteTask(task: BackgroundTask, source: string, ctx: ResultHandlerContext): Promise<boolean>;
-export declare function notifyParentSession(task: BackgroundTask, ctx: ResultHandlerContext): Promise<void>;
+export type { ResultHandlerContext } from "./result-handler-context";
+export { formatDuration } from "./duration-formatter";
+export { getMessageDir } from "./message-storage-locator";
+export { checkSessionTodos } from "./session-todo-checker";
+export { validateSessionHasOutput } from "./session-output-validator";
+export { tryCompleteTask } from "./background-task-completer";
+export { notifyParentSession } from "./parent-session-notifier";

package/dist/features/background-agent/session-output-validator.d.ts

@@ -0,0 +1,2 @@
+import type { OpencodeClient } from "./constants";
+export declare function validateSessionHasOutput(client: OpencodeClient, sessionID: string): Promise<boolean>;

package/dist/features/background-agent/session-todo-checker.d.ts

@@ -0,0 +1,2 @@
+import type { OpencodeClient } from "./constants";
+export declare function checkSessionTodos(client: OpencodeClient, sessionID: string): Promise<boolean>;

package/dist/features/background-agent/session-validator.d.ts

@@ -0,0 +1,7 @@
+import type { OpencodeClient } from "./opencode-client";
+/**
+ * Validates that a session has actual assistant/tool output before marking complete.
+ * Prevents premature completion when session.idle fires before agent responds.
+ */
+export declare function validateSessionHasOutput(client: OpencodeClient, sessionID: string): Promise<boolean>;
+export declare function checkSessionTodos(client: OpencodeClient, sessionID: string): Promise<boolean>;

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

@@ -0,0 +1,11 @@
+import type { BackgroundTask } from "../types";
+import type { ConcurrencyManager } from "../concurrency";
+import type { OpencodeClient, OnSubagentSessionCreated } from "../constants";
+export interface SpawnerContext {
+    client: OpencodeClient;
+    directory: string;
+    concurrencyManager: ConcurrencyManager;
+    tmuxEnabled: boolean;
+    onSubagentSessionCreated?: OnSubagentSessionCreated;
+    onTaskError: (task: BackgroundTask, error: Error) => void;
+}

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

@@ -0,0 +1,2 @@
+import type { BackgroundTask, LaunchInput } from "../types";
+export declare function createTask(input: LaunchInput): BackgroundTask;

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

@@ -0,0 +1,3 @@
+import type { BackgroundTask, ResumeInput } from "../types";
+import type { SpawnerContext } from "./spawner-context";
+export declare function resumeTask(task: BackgroundTask, input: ResumeInput, ctx: Pick<SpawnerContext, "client" | "concurrencyManager" | "onTaskError">): Promise<void>;

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

@@ -0,0 +1,3 @@
+import type { QueueItem } from "../constants";
+import type { SpawnerContext } from "./spawner-context";
+export declare function startTask(item: QueueItem, ctx: SpawnerContext): Promise<void>;

package/dist/features/background-agent/stale-task-pruner.d.ts

@@ -0,0 +1,9 @@
+import type { BackgroundTask } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+export declare function pruneStaleState(args: {
+    tasks: Map<string, BackgroundTask>;
+    notifications: Map<string, BackgroundTask[]>;
+    concurrencyManager: ConcurrencyManager;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+    clearNotificationsForTask: (taskId: string) => void;
+}): void;

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

@@ -12,7 +12,7 @@ export declare class TaskStateManager {
     getTasksByParentSession(sessionID: string): BackgroundTask[];
     getAllDescendantTasks(sessionID: string): BackgroundTask[];
     getRunningTasks(): BackgroundTask[];
-    getCompletedTasks(): BackgroundTask[];
+    getNonRunningTasks(): BackgroundTask[];
     hasRunningTasks(): boolean;
     getConcurrencyKeyFromInput(input: LaunchInput): string;
     getConcurrencyKeyFromTask(task: BackgroundTask): string;

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

@@ -0,0 +1,27 @@
+import type { BackgroundTask } from "./types";
+import type { LaunchInput } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+import type { OpencodeClient } from "./opencode-client";
+type QueueItem = {
+    task: BackgroundTask;
+    input: LaunchInput;
+};
+export declare function cancelBackgroundTask(args: {
+    taskId: string;
+    options?: {
+        source?: string;
+        reason?: string;
+        abortSession?: boolean;
+        skipNotification?: boolean;
+    };
+    tasks: Map<string, BackgroundTask>;
+    queuesByKey: Map<string, QueueItem[]>;
+    completionTimers: Map<string, ReturnType<typeof setTimeout>>;
+    idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    concurrencyManager: ConcurrencyManager;
+    client: OpencodeClient;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+    markForNotification: (task: BackgroundTask) => void;
+    notifyParentSession: (task: BackgroundTask) => Promise<void>;
+}): Promise<boolean>;
+export {};

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

@@ -0,0 +1,13 @@
+import type { BackgroundTask } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+import type { OpencodeClient } from "./opencode-client";
+export declare function tryCompleteBackgroundTask(args: {
+    task: BackgroundTask;
+    source: string;
+    concurrencyManager: ConcurrencyManager;
+    idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    client: OpencodeClient;
+    markForNotification: (task: BackgroundTask) => void;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+    notifyParentSession: (task: BackgroundTask) => Promise<void>;
+}): Promise<boolean>;

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

@@ -0,0 +1,15 @@
+import type { BackgroundTask } from "./types";
+import type { LaunchInput } from "./types";
+type QueueItem = {
+    task: BackgroundTask;
+    input: LaunchInput;
+};
+export declare function launchBackgroundTask(args: {
+    input: LaunchInput;
+    tasks: Map<string, BackgroundTask>;
+    pendingByParent: Map<string, Set<string>>;
+    queuesByKey: Map<string, QueueItem[]>;
+    getConcurrencyKeyFromInput: (input: LaunchInput) => string;
+    processKey: (key: string) => void;
+}): BackgroundTask;
+export {};

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

@@ -0,0 +1,16 @@
+import type { BackgroundTaskConfig } from "../../config/schema";
+import type { BackgroundTask } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+import type { OpencodeClient } from "./opencode-client";
+export declare function pruneStaleTasksAndNotifications(args: {
+    tasks: Map<string, BackgroundTask>;
+    notifications: Map<string, BackgroundTask[]>;
+    onTaskPruned: (taskId: string, task: BackgroundTask, errorMessage: string) => void;
+}): void;
+export declare function checkAndInterruptStaleTasks(args: {
+    tasks: Iterable<BackgroundTask>;
+    client: OpencodeClient;
+    config: BackgroundTaskConfig | undefined;
+    concurrencyManager: ConcurrencyManager;
+    notifyParentSession: (task: BackgroundTask) => Promise<void>;
+}): Promise<void>;

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

@@ -0,0 +1,7 @@
+import type { BackgroundTask } from "./types";
+export declare function getTasksByParentSession(tasks: Iterable<BackgroundTask>, sessionID: string): BackgroundTask[];
+export declare function getAllDescendantTasks(tasksByParent: (sessionID: string) => BackgroundTask[], sessionID: string): BackgroundTask[];
+export declare function findTaskBySession(tasks: Iterable<BackgroundTask>, sessionID: string): BackgroundTask | undefined;
+export declare function getRunningTasks(tasks: Iterable<BackgroundTask>): BackgroundTask[];
+export declare function getNonRunningTasks(tasks: Iterable<BackgroundTask>): BackgroundTask[];
+export declare function hasRunningTasks(tasks: Iterable<BackgroundTask>): boolean;

package/dist/features/background-agent/task-queue-processor.d.ts

@@ -0,0 +1,14 @@
+import type { BackgroundTask } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+type QueueItem = {
+    task: BackgroundTask;
+    input: import("./types").LaunchInput;
+};
+export declare function processConcurrencyKeyQueue(args: {
+    key: string;
+    queuesByKey: Map<string, QueueItem[]>;
+    processingKeys: Set<string>;
+    concurrencyManager: ConcurrencyManager;
+    startTask: (item: QueueItem) => Promise<void>;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,14 @@
+import type { BackgroundTask, ResumeInput } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+import type { OpencodeClient } from "./opencode-client";
+export declare function resumeBackgroundTask(args: {
+    input: ResumeInput;
+    findBySession: (sessionID: string) => BackgroundTask | undefined;
+    client: OpencodeClient;
+    concurrencyManager: ConcurrencyManager;
+    pendingByParent: Map<string, Set<string>>;
+    startPolling: () => void;
+    markForNotification: (task: BackgroundTask) => void;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+    notifyParentSession: (task: BackgroundTask) => Promise<void>;
+}): Promise<BackgroundTask>;

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

@@ -0,0 +1,27 @@
+import type { BackgroundTask } from "./types";
+import type { LaunchInput } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+import type { OpencodeClient } from "./opencode-client";
+type QueueItem = {
+    task: BackgroundTask;
+    input: LaunchInput;
+};
+export declare function startQueuedTask(args: {
+    item: QueueItem;
+    client: OpencodeClient;
+    defaultDirectory: string;
+    tmuxEnabled: boolean;
+    onSubagentSessionCreated?: (event: {
+        sessionID: string;
+        parentID: string;
+        title: string;
+    }) => Promise<void>;
+    startPolling: () => void;
+    getConcurrencyKeyFromInput: (input: LaunchInput) => string;
+    concurrencyManager: ConcurrencyManager;
+    findBySession: (sessionID: string) => BackgroundTask | undefined;
+    markForNotification: (task: BackgroundTask) => void;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+    notifyParentSession: (task: BackgroundTask) => Promise<void>;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,18 @@
+import type { BackgroundTask } from "./types";
+import type { ConcurrencyManager } from "./concurrency";
+export declare function trackExternalTask(args: {
+    input: {
+        taskId: string;
+        sessionID: string;
+        parentSessionID: string;
+        description: string;
+        agent?: string;
+        parentAgent?: string;
+        concurrencyKey?: string;
+    };
+    tasks: Map<string, BackgroundTask>;
+    pendingByParent: Map<string, Set<string>>;
+    concurrencyManager: ConcurrencyManager;
+    startPolling: () => void;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+}): Promise<BackgroundTask>;

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

@@ -1,4 +1,4 @@
-export type BackgroundTaskStatus = "pending" | "running" | "completed" | "error" | "cancelled";
+export type BackgroundTaskStatus = "pending" | "running" | "completed" | "error" | "cancelled" | "interrupt";
 export interface TaskProgress {
     toolCalls: number;
     lastTool?: string;

package/dist/features/builtin-skills/skills/git-master-skill-metadata.d.ts

@@ -0,0 +1,2 @@
+export declare const GIT_MASTER_SKILL_NAME = "git-master";
+export declare const GIT_MASTER_SKILL_DESCRIPTION = "MUST USE for ANY git operations. Atomic commits, rebase/squash, history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with task(category='quick', load_skills=['git-master'], ...) to save context. Triggers: 'commit', 'rebase', 'squash', 'who wrote', 'when was X added', 'find the commit that'.";

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

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

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

@@ -0,0 +1,3 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { LoadedPlugin } from "./types";
+export declare function loadPluginCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition>;

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

@@ -0,0 +1,2 @@
+import type { PluginLoadResult, PluginLoaderOptions } from "./types";
+export declare function discoverInstalledPlugins(options?: PluginLoaderOptions): PluginLoadResult;

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

@@ -0,0 +1,2 @@
+import type { HooksConfig, LoadedPlugin } from "./types";
+export declare function loadPluginHooksConfigs(plugins: LoadedPlugin[]): HooksConfig[];

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

@@ -1,3 +1,10 @@
 export * from "./types";
 export * from "./loader";
+export * from "./discovery";
+export * from "./plugin-path-resolver";
+export * from "./command-loader";
+export * from "./skill-loader";
+export * from "./agent-loader";
+export * from "./mcp-server-loader";
+export * from "./hook-loader";
 export type { PluginLoaderOptions, ClaudeSettings } from "./types";

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

@@ -1,13 +1,13 @@
 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 { LoadedPlugin, PluginLoadResult, PluginLoadError, HooksConfig, PluginLoaderOptions } from "./types";
-export declare function discoverInstalledPlugins(options?: PluginLoaderOptions): PluginLoadResult;
-export declare function loadPluginCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition>;
-export declare function loadPluginSkillsAsCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition>;
-export declare function loadPluginAgents(plugins: LoadedPlugin[]): Record<string, AgentConfig>;
-export declare function loadPluginMcpServers(plugins: LoadedPlugin[]): Promise<Record<string, McpServerConfig>>;
-export declare function loadPluginHooksConfigs(plugins: LoadedPlugin[]): HooksConfig[];
+import type { HooksConfig, LoadedPlugin, PluginLoadError, PluginLoaderOptions } from "./types";
+export { discoverInstalledPlugins } from "./discovery";
+export { loadPluginCommands } from "./command-loader";
+export { loadPluginSkillsAsCommands } from "./skill-loader";
+export { loadPluginAgents } from "./agent-loader";
+export { loadPluginMcpServers } from "./mcp-server-loader";
+export { loadPluginHooksConfigs } from "./hook-loader";
 export interface PluginComponentsResult {
     commands: Record<string, CommandDefinition>;
     skills: Record<string, CommandDefinition>;

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

@@ -0,0 +1,3 @@
+import type { McpServerConfig } from "../claude-code-mcp-loader/types";
+import type { LoadedPlugin } from "./types";
+export declare function loadPluginMcpServers(plugins: LoadedPlugin[]): Promise<Record<string, McpServerConfig>>;

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

@@ -0,0 +1,2 @@
+export declare function resolvePluginPath(path: string, pluginRoot: string): string;
+export declare function resolvePluginPaths<T>(obj: T, pluginRoot: string): T;