oh-my-opencode 3.3.2 → 3.5.0

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

@@ -38,6 +38,7 @@ export declare class BackgroundManager {
     private processingKeys;
     private completionTimers;
     private idleDeferralTimers;
+    private notificationQueueByParent;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig, options?: {
         tmuxConfig?: TmuxConfig;
         onSubagentSessionCreated?: OnSubagentSessionCreated;
@@ -101,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.
@@ -123,5 +124,6 @@ export declare class BackgroundManager {
      * Should be called when the plugin is unloaded.
      */
     shutdown(): void;
+    private enqueueNotificationForParent;
 }
 export {};

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/background-session-creator.d.ts

@@ -0,0 +1,10 @@
+import type { OpencodeClient } from "../constants";
+import type { ConcurrencyManager } from "../concurrency";
+import type { LaunchInput } from "../types";
+export declare function createBackgroundSession(options: {
+    client: OpencodeClient;
+    input: LaunchInput;
+    parentDirectory: string;
+    concurrencyManager: ConcurrencyManager;
+    concurrencyKey: string;
+}): Promise<string>;

package/dist/features/background-agent/spawner/concurrency-key-from-launch-input.d.ts

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

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/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/spawner/tmux-callback-invoker.d.ts

@@ -0,0 +1,8 @@
+import type { OnSubagentSessionCreated } from "../constants";
+export declare function maybeInvokeTmuxCallback(options: {
+    onSubagentSessionCreated?: OnSubagentSessionCreated;
+    tmuxEnabled: boolean;
+    sessionID: string;
+    parentID: string;
+    title: string;
+}): 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-commands/templates/handoff.d.ts

@@ -0,0 +1 @@
+export declare const HANDOFF_TEMPLATE = "# Handoff Command\n\n## Purpose\n\nUse /handoff when:\n- The current session context is getting too long and quality is degrading\n- You want to start fresh while preserving essential context from this session\n- The context window is approaching capacity\n\nThis creates a detailed context summary that can be used to continue work in a new session.\n\n---\n\n# PHASE 0: VALIDATE REQUEST\n\nBefore proceeding, confirm:\n- [ ] There is meaningful work or context in this session to preserve\n- [ ] The user wants to create a handoff summary (not just asking about it)\n\nIf the session is nearly empty or has no meaningful context, inform the user there is nothing substantial to hand off.\n\n---\n\n# PHASE 1: GATHER PROGRAMMATIC CONTEXT\n\nExecute these tools to gather concrete data:\n\n1. session_read({ session_id: \"$SESSION_ID\" }) \u2014 full session history\n2. todoread() \u2014 current task progress\n3. Bash({ command: \"git diff --stat HEAD~10..HEAD\" }) \u2014 recent file changes\n4. Bash({ command: \"git status --porcelain\" }) \u2014 uncommitted changes\n\nSuggested execution order:\n\n```\nsession_read({ session_id: \"$SESSION_ID\" })\ntodoread()\nBash({ command: \"git diff --stat HEAD~10..HEAD\" })\nBash({ command: \"git status --porcelain\" })\n```\n\nAnalyze the gathered outputs to understand:\n- What the user asked for (exact wording)\n- What work was completed\n- What tasks remain incomplete (include todo state)\n- What decisions were made\n- What files were modified or discussed (include git diff/stat + status)\n- What patterns, constraints, or preferences were established\n\n---\n\n# PHASE 2: EXTRACT CONTEXT\n\nWrite the context summary from first person perspective (\"I did...\", \"I told you...\").\n\nFocus on:\n- Capabilities and behavior, not file-by-file implementation details\n- What matters for continuing the work\n- Avoiding excessive implementation details (variable names, storage keys, constants) unless critical\n- USER REQUESTS (AS-IS) must be verbatim (do not paraphrase)\n- EXPLICIT CONSTRAINTS must be verbatim only (do not invent)\n\nQuestions to consider when extracting:\n- What did I just do or implement?\n- What instructions did I already give which are still relevant (e.g. follow patterns in the codebase)?\n- What files did I tell you are important or that I am working on?\n- Did I provide a plan or spec that should be included?\n- What did I already tell you that is important (libraries, patterns, constraints, preferences)?\n- What important technical details did I discover (APIs, methods, patterns)?\n- What caveats, limitations, or open questions did I find?\n\n---\n\n# PHASE 3: FORMAT OUTPUT\n\nGenerate a handoff summary using this exact format:\n\n```\nHANDOFF CONTEXT\n===============\n\nUSER REQUESTS (AS-IS)\n---------------------\n- [Exact verbatim user requests - NOT paraphrased]\n\nGOAL\n----\n[One sentence describing what should be done next]\n\nWORK COMPLETED\n--------------\n- [First person bullet points of what was done]\n- [Include specific file paths when relevant]\n- [Note key implementation decisions]\n\nCURRENT STATE\n-------------\n- [Current state of the codebase or task]\n- [Build/test status if applicable]\n- [Any environment or configuration state]\n\nPENDING TASKS\n-------------\n- [Tasks that were planned but not completed]\n- [Next logical steps to take]\n- [Any blockers or issues encountered]\n- [Include current todo state from todoread()]\n\nKEY FILES\n---------\n- [path/to/file1] - [brief role description]\n- [path/to/file2] - [brief role description]\n(Maximum 10 files, prioritized by importance)\n- (Include files from git diff/stat and git status)\n\nIMPORTANT DECISIONS\n-------------------\n- [Technical decisions that were made and why]\n- [Trade-offs that were considered]\n- [Patterns or conventions established]\n\nEXPLICIT CONSTRAINTS\n--------------------\n- [Verbatim constraints only - from user or existing AGENTS.md]\n- If none, write: None\n\nCONTEXT FOR CONTINUATION\n------------------------\n- [What the next session needs to know to continue]\n- [Warnings or gotchas to be aware of]\n- [References to documentation if relevant]\n```\n\nRules for the summary:\n- Plain text with bullets\n- No markdown headers with # (use the format above with dashes)\n- No bold, italic, or code fences within content\n- Use workspace-relative paths for files\n- Keep it focused - only include what matters for continuation\n- Pick an appropriate length based on complexity\n- USER REQUESTS (AS-IS) and EXPLICIT CONSTRAINTS must be verbatim only\n\n---\n\n# PHASE 4: PROVIDE INSTRUCTIONS\n\nAfter generating the summary, instruct the user:\n\n```\n---\n\nTO CONTINUE IN A NEW SESSION:\n\n1. Press 'n' in OpenCode TUI to open a new session, or run 'opencode' in a new terminal\n2. Paste the HANDOFF CONTEXT above as your first message\n3. Add your request: \"Continue from the handoff context above. [Your next task]\"\n\nThe new session will have all context needed to continue seamlessly.\n```\n\n---\n\n# IMPORTANT CONSTRAINTS\n\n- DO NOT attempt to programmatically create new sessions (no API available to agents)\n- DO provide a self-contained summary that works without access to this session\n- DO include workspace-relative file paths\n- DO NOT include sensitive information (API keys, credentials, secrets)\n- DO NOT exceed 10 files in the KEY FILES section\n- DO keep the GOAL section to a single sentence or short paragraph\n\n---\n\n# EXECUTE NOW\n\nBegin by gathering programmatic context, then synthesize the handoff summary.\n";

package/dist/features/builtin-commands/types.d.ts

@@ -1,5 +1,5 @@
 import type { CommandDefinition } from "../claude-code-command-loader";
-export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation";
+export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff";
 export interface BuiltinCommandConfig {
     disabled_commands?: BuiltinCommandName[];
 }