oh-my-opencode 4.7.5 → 4.8.1

package/dist/features/team-mode/tools/lifecycle-test-fixture.d.ts

@@ -1,8 +1,8 @@
-import type { ToolContext } from "@opencode-ai/plugin/tool";
+import type { ToolContext, ToolResult } from "@opencode-ai/plugin/tool";
 import type { OpencodeClient } from "../../../tools/delegate-task/types";
 import type { BackgroundManager } from "../../background-agent/manager";
 import type { RuntimeState, TeamSpec } from "../types";
-export declare function parseToolResult<TValue>(value: string): TValue;
+export declare function parseToolResult<TValue>(value: ToolResult): TValue;
 export declare function createToolContext(sessionID: string): ToolContext;
 export declare function getLatestShutdownRequest(runtimeState: RuntimeState, memberName: string): RuntimeState["shutdownRequests"][number] | undefined;
 export declare function createSpec(): TeamSpec;
@@ -72,7 +72,7 @@ export declare const deleteTeamMock: import("bun:test").Mock<(teamRunId: string,
 }>>;
 export declare const requestShutdownOfMemberMock: import("bun:test").Mock<(teamRunId: string, targetMemberName: string, requesterName: string) => Promise<void>>;
 export declare const approveShutdownMock: import("bun:test").Mock<(teamRunId: string, memberName: string) => Promise<void>>;
-export declare const rejectShutdownMock: import("bun:test").Mock<(teamRunId: string, memberName: string, reason: string) => Promise<void>>;
+export declare const rejectShutdownMock: import("bun:test").Mock<(teamRunId: string, memberName: string, _rejectorName: string, reason: string) => Promise<void>>;
 export declare const loadTeamSpecMock: import("bun:test").Mock<() => Promise<{
     version: 1;
     name: string;

package/dist/features/team-mode/tools/lifecycle.d.ts

@@ -1,37 +1,3 @@
-import { type ToolDefinition } from "@opencode-ai/plugin/tool";
-import type { TeamModeConfig } from "../../../config/schema/team-mode";
-import type { CategoriesConfig, AgentOverrides } from "../../../config/schema";
-import type { OpencodeClient } from "../../../tools/delegate-task/types";
-import type { BackgroundManager } from "../../background-agent/manager";
-import type { TmuxSessionManager } from "../../tmux-subagent/manager";
-import { loadTeamSpec } from "../team-registry/loader";
-import { createTeamRun } from "../team-runtime/create";
-import { approveShutdown, deleteTeam, rejectShutdown, requestShutdownOfMember } from "../team-runtime/shutdown";
-import { listActiveTeams, loadRuntimeState } from "../team-state-store/store";
-type TeamRuntimeStoreDeps = {
-    listActiveTeams: typeof listActiveTeams;
-    loadRuntimeState: typeof loadRuntimeState;
-};
-type TeamShutdownToolDeps = TeamRuntimeStoreDeps & {
-    deleteTeam: typeof deleteTeam;
-    requestShutdownOfMember: typeof requestShutdownOfMember;
-    approveShutdown: typeof approveShutdown;
-    rejectShutdown: typeof rejectShutdown;
-};
-export type TeamCreateExecutorConfig = {
-    userCategories?: CategoriesConfig;
-    sisyphusJuniorModel?: string;
-    agentOverrides?: AgentOverrides;
-};
-type TeamCreateToolDeps = {
-    createTeamRun: typeof createTeamRun;
-    loadTeamSpec: typeof loadTeamSpec;
-    listActiveTeams: typeof listActiveTeams;
-    loadRuntimeState: typeof loadRuntimeState;
-};
-export declare function createTeamCreateTool(config: TeamModeConfig, client: OpencodeClient, bgMgr: BackgroundManager, tmuxMgr?: TmuxSessionManager, executorConfig?: TeamCreateExecutorConfig, deps?: TeamCreateToolDeps): ToolDefinition;
-export declare function createTeamDeleteTool(config: TeamModeConfig, client: OpencodeClient, backgroundManager: BackgroundManager, tmuxMgr?: TmuxSessionManager, deps?: TeamShutdownToolDeps): ToolDefinition;
-export declare function createTeamShutdownRequestTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
-export declare function createTeamApproveShutdownTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
-export declare function createTeamRejectShutdownTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
-export {};
+export { createTeamCreateTool } from "./lifecycle-create-tool";
+export type { TeamCreateExecutorConfig } from "./lifecycle-inline-spec";
+export { createTeamApproveShutdownTool, createTeamDeleteTool, createTeamRejectShutdownTool, createTeamShutdownRequestTool, } from "./lifecycle-shutdown-tools";

package/dist/features/team-mode/tools/messaging-live-delivery-client.d.ts

@@ -0,0 +1,25 @@
+export type LiveDeliveryClient = {
+    session: {
+        promptAsync(input: {
+            path: {
+                id: string;
+            };
+            body: {
+                parts: Array<{
+                    type: "text";
+                    text: string;
+                }>;
+                agent?: string;
+                model?: {
+                    providerID: string;
+                    modelID: string;
+                };
+                variant?: string;
+            };
+            query?: {
+                directory: string;
+            };
+        }): Promise<unknown>;
+        status?: () => Promise<unknown>;
+    };
+};

package/dist/features/team-mode/tools/messaging-live-delivery-recipient.d.ts

@@ -0,0 +1,19 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import { buildEnvelope } from "../team-mailbox/poll";
+import type { Message, RuntimeState } from "../types";
+import type { LiveDeliveryClient } from "./messaging-live-delivery-client";
+import type { DeliveryReservation } from "./messaging-live-delivery-reservation";
+type RuntimeMember = RuntimeState["members"][number];
+type LiveDeliveryEnvelope = ReturnType<typeof buildEnvelope>;
+export declare function deliverLiveToRecipient(input: {
+    client: LiveDeliveryClient;
+    message: Message;
+    envelope: LiveDeliveryEnvelope;
+    teamRunId: string;
+    recipientName: string;
+    recipientMember: RuntimeMember;
+    reservation: DeliveryReservation;
+    config: TeamModeConfig;
+    directory: string;
+}): Promise<void>;
+export {};

package/dist/features/team-mode/tools/messaging-live-delivery-reservation.d.ts

@@ -0,0 +1,10 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import { type DeliveryReservation as TeamMailboxDeliveryReservation } from "../team-mailbox/reservation";
+export type DeliveryReservation = TeamMailboxDeliveryReservation;
+export type NullableDeliveryReservation = DeliveryReservation | null;
+export declare function releaseReservationSafely(reservation: NullableDeliveryReservation, input: {
+    teamRunId: string;
+    recipient: string;
+    messageId: string;
+}): Promise<void>;
+export declare function releaseReservationsForRecipients(teamRunId: string, recipientNames: readonly string[], messageId: string, config: TeamModeConfig): Promise<void>;

package/dist/features/team-mode/tools/messaging-live-delivery-state.d.ts

@@ -0,0 +1,5 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { RuntimeState } from "../types";
+import type { TeamSendMessageToolDeps } from "./messaging-runtime";
+export declare function markLiveDeliveryPending(teamRunId: string, recipientName: string, messageId: string, config: TeamModeConfig): Promise<void>;
+export declare function loadRuntimeStateForLiveDelivery(teamRunId: string, deliveredTo: readonly string[], messageId: string, config: TeamModeConfig, deps: TeamSendMessageToolDeps): Promise<RuntimeState | undefined>;

package/dist/features/team-mode/tools/messaging-live-delivery.d.ts

@@ -0,0 +1,6 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { Message } from "../types";
+import type { LiveDeliveryClient } from "./messaging-live-delivery-client";
+import type { TeamSendMessageToolDeps } from "./messaging-runtime";
+export type { LiveDeliveryClient } from "./messaging-live-delivery-client";
+export declare function deliverLive(client: LiveDeliveryClient, message: Message, teamRunId: string, deliveredTo: readonly string[], config: TeamModeConfig, directory: string, deps: TeamSendMessageToolDeps): Promise<void>;

package/dist/features/team-mode/tools/messaging-runtime.d.ts

@@ -0,0 +1,17 @@
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import { loadRuntimeState } from "../team-state-store/store";
+import type { Message, RuntimeState } from "../types";
+export type TeamRuntimeDetails = {
+    teamRunId: string;
+    isLead: boolean;
+    senderName: string;
+    activeMembers: string[];
+};
+export type TeamSendMessageToolDeps = {
+    loadRuntimeState: typeof loadRuntimeState;
+};
+export declare const defaultTeamSendMessageToolDeps: TeamSendMessageToolDeps;
+type RuntimeMember = RuntimeState["members"][number];
+export declare function shouldReserveRecipientMailbox(member: RuntimeMember, message: Message, senderName: string): boolean;
+export declare function resolveTeamRuntimeDetails(teamRunId: string, sessionID: string, config: TeamModeConfig, deps: TeamSendMessageToolDeps): Promise<TeamRuntimeDetails>;
+export {};

package/dist/features/team-mode/tools/messaging.d.ts

@@ -1,32 +1,7 @@
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { TeamModeConfig } from "../../../config/schema/team-mode";
-import { loadRuntimeState } from "../team-state-store/store";
-export type LiveDeliveryClient = {
-    session: {
-        promptAsync(input: {
-            path: {
-                id: string;
-            };
-            body: {
-                parts: Array<{
-                    type: "text";
-                    text: string;
-                }>;
-                agent?: string;
-                model?: {
-                    providerID: string;
-                    modelID: string;
-                };
-                variant?: string;
-            };
-            query?: {
-                directory: string;
-            };
-        }): Promise<unknown>;
-        status?: () => Promise<unknown>;
-    };
-};
-export type TeamSendMessageToolDeps = {
-    loadRuntimeState: typeof loadRuntimeState;
-};
+import { type LiveDeliveryClient } from "./messaging-live-delivery";
+import { type TeamSendMessageToolDeps } from "./messaging-runtime";
+export type { LiveDeliveryClient } from "./messaging-live-delivery";
+export type { TeamSendMessageToolDeps } from "./messaging-runtime";
 export declare function createTeamSendMessageTool(config: TeamModeConfig, client: LiveDeliveryClient, deps?: TeamSendMessageToolDeps): ToolDefinition;

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

@@ -26,6 +26,24 @@ export interface TmuxUtilDeps {
     executeAction: typeof executeAction;
     log: typeof sharedModule.log;
 }
+/**
+ * Options passed to TmuxSessionManager at construction time.
+ *
+ * Distinct from `TmuxUtilDeps` (low-level tmux util injection): these are
+ * external policy hooks the manager defers to without owning the policy.
+ */
+export interface TmuxSessionManagerOptions {
+    /**
+     * Predicate the manager calls in `onSessionCreated` to decide whether this
+     * session should be ignored entirely. Used to keep team-mode member sessions
+     * out of the subagent pane tracking, since team-layout-tmux owns their pane
+     * lifecycle separately and double-tracking causes pane double-close races
+     * and stale entries in the subagent panel.
+     *
+     * Defaults to `() => false` (track everything).
+     */
+    shouldSkipSession?: (sessionId: string) => boolean;
+}
 export declare class TmuxSessionManager {
     private client;
     private tmuxConfig;
@@ -45,6 +63,7 @@ export declare class TmuxSessionManager {
     private deferredAttachTickScheduled;
     private nullStateCount;
     private deps;
+    private shouldSkipSession;
     private pollingManager;
     private isolatedContainerPaneId;
     private isolatedWindowPaneId;
@@ -52,7 +71,7 @@ export declare class TmuxSessionManager {
     private staleSweepCompleted;
     private staleSweepInProgress;
     private isolatedSessionManagerId;
-    constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: Partial<TmuxUtilDeps>);
+    constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: Partial<TmuxUtilDeps>, options?: TmuxSessionManagerOptions);
     private isEnabled;
     private isIsolated;
     private getEffectiveSourcePaneId;

package/dist/features/tmux-subagent/session-created-handler.d.ts

@@ -1,7 +1,9 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { TmuxConfig } from "../../config/schema";
 import type { CapacityConfig, TrackedSession } from "./types";
+import { queryWindowState } from "./pane-state-querier";
 import { type SessionMapping } from "./decision-engine";
+import { executeActions } from "./action-executor";
 import type { SessionCreatedEvent } from "./session-created-event";
 type OpencodeClient = PluginInput["client"];
 export interface SessionCreatedHandlerDeps {
@@ -18,6 +20,8 @@ export interface SessionCreatedHandlerDeps {
     getSessionMappings: () => SessionMapping[];
     waitForSessionReady: (sessionId: string) => Promise<boolean>;
     startPolling: () => void;
+    queryWindowState?: typeof queryWindowState;
+    executeActions?: typeof executeActions;
 }
 export declare function handleSessionCreated(deps: SessionCreatedHandlerDeps, event: SessionCreatedEvent): Promise<void>;
 export {};

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

@@ -8,6 +8,7 @@ export interface TrackedSession {
     lastSeenAt: Date;
     closePending: boolean;
     closeRetryCount: number;
+    closeRetryCooldownUntil?: Date;
     lastMessageCount?: number;
     stableIdlePolls?: number;
     activityVersion?: number;

package/dist/hooks/anthropic-context-window-limit-recovery/message-builder.d.ts

@@ -3,7 +3,7 @@ export declare const PLACEHOLDER_TEXT = "[user interrupted]";
 type OpencodeClient = PluginInput["client"];
 export declare function sanitizeEmptyMessagesBeforeSummarize(sessionID: string, client?: OpencodeClient): Promise<number>;
 export declare function formatBytes(bytes: number): string;
-export declare function getLastAssistant(sessionID: string, client: any, directory: string): Promise<{
+export declare function getLastAssistant(sessionID: string, client: OpencodeClient, directory: string): Promise<{
     info: Record<string, unknown>;
     hasContent: boolean;
 } | null>;

package/dist/hooks/atlas/idle-completion-nudge.d.ts

@@ -0,0 +1,10 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BoulderState } from "../../features/boulder-state";
+import type { AtlasHookOptions, SessionState } from "./types";
+export declare function handleCompletedBoulderIdle(input: {
+    ctx: PluginInput;
+    options?: AtlasHookOptions;
+    sessionID: string;
+    sessionState: SessionState;
+    boulderState: BoulderState;
+}): Promise<void>;

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

@@ -0,0 +1,4 @@
+export declare const CONTINUATION_COOLDOWN_MS = 5000;
+export declare const FAILURE_BACKOFF_MS: number;
+export declare const MAX_CONSECUTIVE_PROMPT_FAILURES = 10;
+export declare const RETRY_DELAY_MS: number;

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

@@ -0,0 +1,23 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { AtlasHookOptions, SessionState } from "./types";
+export declare function hasRunningBackgroundTasks(sessionID: string, options?: AtlasHookOptions): boolean;
+export declare function injectContinuation(input: {
+    ctx: PluginInput;
+    sessionID: string;
+    sessionState: SessionState;
+    options?: AtlasHookOptions;
+    planName: string;
+    progress: {
+        total: number;
+        completed: number;
+    };
+    agent?: string;
+    worktreePath?: string;
+    idleSettleMs?: number;
+}): Promise<void>;
+export declare function scheduleRetry(input: {
+    ctx: PluginInput;
+    sessionID: string;
+    sessionState: SessionState;
+    options?: AtlasHookOptions;
+}): void;

package/dist/hooks/atlas/idle-session-eligibility.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function canContinueTrackedBoulderSession(input: {
+    client: PluginInput["client"];
+    sessionID: string;
+    sessionOrigin?: "direct" | "appended";
+    boulderSessionIDs: string[];
+    requiredAgent?: string;
+}): Promise<boolean>;

package/dist/hooks/atlas/tool-execute-after-direct-work.d.ts

@@ -0,0 +1,9 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ToolExecuteAfterInput, ToolExecuteAfterOutput } from "./types";
+export declare function handleDirectWorkToolAfter(input: {
+    ctx: PluginInput;
+    pendingFilePaths: Map<string, string>;
+    pendingPlanSnapshots?: Map<string, string>;
+    toolInput: ToolExecuteAfterInput;
+    toolOutput: ToolExecuteAfterOutput;
+}): Promise<boolean>;

package/dist/hooks/atlas/tool-execute-after-plan-tasks.d.ts

@@ -0,0 +1,3 @@
+export declare function isTrackedTaskChecked(planPath: string, taskKey: string): boolean;
+export declare function parseCheckedTopLevelTaskKeys(planContent: string): Set<string>;
+export declare function readCheckedTaskKeysFromPlan(planPath: string): Set<string>;

package/dist/hooks/atlas/tool-execute-after-subagent-completion.d.ts

@@ -0,0 +1,14 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { collectGitDiffStats, formatFileChanges } from "../../shared/git-worktree";
+import type { PendingTaskRef, SessionState, ToolExecuteAfterInput, ToolExecuteAfterOutput } from "./types";
+export declare function handleSubagentCompletionAfter(input: {
+    ctx: PluginInput;
+    pendingTaskRefs: Map<string, PendingTaskRef>;
+    autoCommit: boolean;
+    getState: (sessionID: string) => SessionState;
+    collectGitDiffStats: typeof collectGitDiffStats;
+    formatFileChanges: typeof formatFileChanges;
+    toolInput: ToolExecuteAfterInput;
+    toolOutput: ToolExecuteAfterOutput;
+    metadataSessionId: string | undefined;
+}): Promise<void>;

package/dist/hooks/auto-update-checker/hook/background-update-check.d.ts

@@ -23,6 +23,12 @@ type BackgroundUpdateCheckDeps = {
     syncCachePackageJsonToIntent: typeof syncCachePackageJsonToIntent;
     showUpdateAvailableToast: typeof showUpdateAvailableToast;
     showAutoUpdatedToast: typeof showAutoUpdatedToast;
+    /**
+     * Returns the workspace directory hosting the currently loaded plugin
+     * module, or `null` if the plugin is not running from a standard install
+     * layout. Used to detect OpenCode-managed sandboxes (see #4318).
+     */
+    getModuleHostingWorkspace: () => string | null;
 };
 type BackgroundUpdateCheckRunner = (ctx: PluginInput, autoUpdate: boolean, getToastMessage: (isUpdate: boolean, latestVersion?: string) => string) => Promise<void>;
 export declare function createBackgroundUpdateCheckRunner(overrides?: Partial<BackgroundUpdateCheckDeps>): BackgroundUpdateCheckRunner;

package/dist/hooks/auto-update-checker/hook/ignore-toast-error.d.ts

@@ -0,0 +1 @@
+export declare function ignoreToastError(error: unknown): void;

package/dist/hooks/hephaestus-agents-md-injector/hook.d.ts

@@ -0,0 +1,37 @@
+import type { AgentsMdCache } from "@oh-my-opencode/rules-engine";
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ContextLimitModelCacheState } from "../../shared/context-limit-resolver";
+type ChatMessageInput = {
+    readonly sessionID: string;
+    readonly agent?: string;
+};
+type OutputPart = {
+    readonly type: string;
+    text?: string;
+    readonly [key: string]: unknown;
+};
+type ChatMessageOutput = {
+    readonly message: Record<string, unknown>;
+    readonly parts: OutputPart[];
+};
+type EventInput = {
+    readonly event: {
+        readonly type: string;
+        readonly properties?: unknown;
+    };
+};
+type AgentsMdTruncator = {
+    readonly truncate: (sessionID: string, output: string) => Promise<{
+        readonly result: string;
+        readonly truncated: boolean;
+    }>;
+};
+type HephaestusAgentsMdInjectorOptions = {
+    readonly agentsMdCache?: AgentsMdCache;
+    readonly truncator?: AgentsMdTruncator;
+};
+export declare function createHephaestusAgentsMdInjectorHook(ctx: PluginInput, modelCacheState?: ContextLimitModelCacheState, options?: HephaestusAgentsMdInjectorOptions): {
+    "chat.message": (input: ChatMessageInput, output: ChatMessageOutput) => Promise<void>;
+    event: ({ event }: EventInput) => Promise<void>;
+};
+export {};

package/dist/hooks/hephaestus-agents-md-injector/index.d.ts

@@ -0,0 +1 @@
+export { createHephaestusAgentsMdInjectorHook } from "./hook";

package/dist/hooks/index.d.ts

@@ -29,6 +29,7 @@ export { createCategorySkillReminderHook } from "./category-skill-reminder";
 export { createRalphLoopHook, type RalphLoopHook } from "./ralph-loop";
 export { createNoSisyphusGptHook } from "./no-sisyphus-gpt";
 export { createNoHephaestusNonGptHook } from "./no-hephaestus-non-gpt";
+export { createHephaestusAgentsMdInjectorHook } from "./hephaestus-agents-md-injector";
 export { createAutoSlashCommandHook } from "./auto-slash-command";
 export { createEditErrorRecoveryHook } from "./edit-error-recovery";
 export { createPrometheusMdOnlyHook } from "./prometheus-md-only";

package/dist/hooks/json-error-recovery/hook.d.ts

@@ -1,5 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-export declare const JSON_ERROR_TOOL_EXCLUDE_LIST: readonly ["bash", "read", "glob", "grep", "webfetch", "look_at", "grep_app_searchgithub", "websearch_web_search_exa", "todowrite", "todoread"];
+export declare const JSON_ERROR_TOOL_EXCLUDE_LIST: readonly ["bash", "read", "glob", "grep", "webfetch", "look_at", "grep_app_searchgithub", "websearch_web_search_exa", "todowrite", "todoread", "task", "call_omo_agent", "background_output", "session_read", "session_search", "session_info", "session_list", "skill", "skill_mcp"];
 export declare const JSON_ERROR_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
 export declare const JSON_ERROR_REMINDER = "\n[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]\n\nYou sent invalid JSON arguments. The system could not parse your tool call.\nSTOP and do this NOW:\n\n1. LOOK at the error message above to see what was expected vs what you sent.\n2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).\n3. RETRY the tool call with valid JSON.\n\nDO NOT repeat the exact same invalid call.\n";
 export declare function createJsonErrorRecoveryHook(_ctx: PluginInput): {

package/dist/hooks/ralph-loop/command-arguments.d.ts

@@ -5,4 +5,5 @@ export type ParsedRalphLoopArguments = {
     completionPromise?: string;
     strategy?: RalphLoopStrategy;
 };
+export declare function isRalphLoopResumeArgument(rawArguments: string): boolean;
 export declare function parseRalphLoopArguments(rawArguments: string): ParsedRalphLoopArguments;

package/dist/hooks/ralph-loop/event-handler-activity.d.ts

@@ -0,0 +1,10 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopOptions } from "./types";
+import type { RalphLoopEventHandlerOptions } from "./event-handler-types";
+export declare const RAPID_IDLE_DEDUP_MS = 500;
+export declare function sleep(ms: number): Promise<void>;
+export declare function hasActiveBackgroundTasks(backgroundManager: RalphLoopOptions["backgroundManager"], sessionID: string): boolean;
+export declare function getRuntimeRetryActivitySessionID(eventType: string, props: Record<string, unknown> | undefined): string | undefined;
+export declare function isSyntheticIdle(props: Record<string, unknown> | undefined): boolean;
+export declare function isAbortError(error: unknown): boolean;
+export declare function latestUserMessageIsInProgress(ctx: PluginInput, options: RalphLoopEventHandlerOptions, sessionID: string, now: number): Promise<boolean>;

package/dist/hooks/ralph-loop/event-handler-completion.d.ts

@@ -0,0 +1,9 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+import type { RalphLoopEventHandlerOptions } from "./event-handler-types";
+export declare function handleCompletionIfDetected(ctx: PluginInput, options: RalphLoopEventHandlerOptions, input: {
+    readonly sessionID: string;
+    readonly state: RalphLoopState;
+    readonly verificationSessionID: string | undefined;
+    readonly runtimeErrorRetriedSessions: Map<string, number>;
+}): Promise<boolean>;

package/dist/hooks/ralph-loop/event-handler-continuation.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+import type { RalphLoopEventHandlerOptions } from "./event-handler-types";
+type ContinueSettledIterationInput = {
+    readonly sessionID: string;
+    readonly state: RalphLoopState;
+    readonly runtimeErrorRetriedSessions: Map<string, number>;
+    readonly afterRuntimeError: boolean;
+};
+export declare function stopIfLatestAssistantMadeNoProgress(ctx: PluginInput, options: RalphLoopEventHandlerOptions, input: {
+    readonly sessionID: string;
+    readonly state: RalphLoopState;
+    readonly afterRuntimeError?: boolean;
+}): Promise<boolean>;
+export declare function continueSettledIteration(ctx: PluginInput, options: RalphLoopEventHandlerOptions, input: ContinueSettledIterationInput): Promise<void>;
+export {};

package/dist/hooks/ralph-loop/event-handler-feedback.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+export declare function showToastBestEffort(ctx: PluginInput, body: {
+    title: string;
+    message: string;
+    variant: "warning" | "info";
+    duration: number;
+}): void;
+export declare function showMaxIterationsToast(ctx: PluginInput, state: RalphLoopState): void;
+export declare function showIterationToast(ctx: PluginInput, state: RalphLoopState): void;
+export declare function showNoProgressToast(ctx: PluginInput): void;
+export declare function showIterationCommitFailureToast(ctx: PluginInput): void;
+export declare function showDispatchFailureToast(ctx: PluginInput, result: {
+    readonly status: string;
+    readonly error?: unknown;
+}): void;

package/dist/hooks/ralph-loop/event-handler-idle.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+import type { RalphLoopEventHandlerOptions } from "./event-handler-types";
+export type EventHandlerRuntime = {
+    readonly inFlightSessions: Set<string>;
+    readonly runtimeErrorRetriedSessions: Map<string, number>;
+    readonly recentHandledSyntheticIdleAt: Map<string, number>;
+};
+export declare function getVerificationSessionID(state: RalphLoopState): string | undefined;
+export declare function matchesLoopSession(state: RalphLoopState, sessionID: string, verificationSessionID: string | undefined): {
+    readonly parent: boolean;
+    readonly verification: boolean;
+};
+export declare function maxIterationsReached(state: RalphLoopState): boolean;
+export declare function handleIdleEvent(ctx: PluginInput, options: RalphLoopEventHandlerOptions, runtime: EventHandlerRuntime, props: Record<string, unknown> | undefined, sessionID: string): Promise<void>;

package/dist/hooks/ralph-loop/event-handler-impl.d.ts

@@ -0,0 +1,10 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopEventHandlerOptions } from "./event-handler-types";
+type RalphLoopEvent = {
+    readonly type: string;
+    readonly properties?: unknown;
+};
+export declare function createRalphLoopEventHandlerImpl(ctx: PluginInput, options: RalphLoopEventHandlerOptions): ({ event }: {
+    readonly event: RalphLoopEvent;
+}) => Promise<void>;
+export {};

package/dist/hooks/ralph-loop/event-handler-runtime-error.d.ts

@@ -0,0 +1,4 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopEventHandlerOptions } from "./event-handler-types";
+import { type EventHandlerRuntime } from "./event-handler-idle";
+export declare function handleRuntimeErrorEvent(ctx: PluginInput, options: RalphLoopEventHandlerOptions, runtime: EventHandlerRuntime, props: Record<string, unknown> | undefined, sessionID: string): Promise<void>;

package/dist/hooks/ralph-loop/event-handler-types.d.ts

@@ -0,0 +1,20 @@
+import type { RalphLoopOptions, IterationCommitExpectation, RalphLoopState } from "./types";
+export type LoopStateController = {
+    getState: () => RalphLoopState | null;
+    clear: () => boolean;
+    incrementIteration: (expected?: IterationCommitExpectation) => RalphLoopState | null;
+    setSessionID: (sessionID: string) => RalphLoopState | null;
+    markVerificationPending: (sessionID: string) => RalphLoopState | null;
+    setVerificationSessionID: (sessionID: string, verificationSessionID: string) => RalphLoopState | null;
+    restartAfterFailedVerification: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null;
+    clearVerificationState: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null;
+};
+export type RalphLoopEventHandlerOptions = {
+    directory: string;
+    apiTimeoutMs: number;
+    idleSettleMs: number;
+    getTranscriptPath: (sessionID: string) => string | undefined;
+    checkSessionExists?: RalphLoopOptions["checkSessionExists"];
+    backgroundManager?: RalphLoopOptions["backgroundManager"];
+    loopState: LoopStateController;
+};

package/dist/hooks/ralph-loop/loop-state-controller.d.ts

@@ -16,6 +16,7 @@ export declare function createLoopStateController(options: {
     clear(): boolean;
     incrementIteration(expected?: IterationCommitExpectation): RalphLoopState | null;
     setSessionID(sessionID: string): RalphLoopState | null;
+    resumeLoop(sessionID: string): RalphLoopState | null;
     setMessageCountAtStart(sessionID: string, messageCountAtStart: number, expectedStartedAt?: string): RalphLoopState | null;
     markVerificationPending(sessionID: string): RalphLoopState | null;
     setVerificationSessionID(sessionID: string, verificationSessionID: string): RalphLoopState | null;

package/dist/hooks/ralph-loop/ralph-loop-event-handler.d.ts

@@ -1,28 +1,8 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-import type { IterationCommitExpectation, RalphLoopOptions, RalphLoopState } from "./types";
-type LoopStateController = {
-    getState: () => RalphLoopState | null;
-    clear: () => boolean;
-    incrementIteration: (expected?: IterationCommitExpectation) => RalphLoopState | null;
-    setSessionID: (sessionID: string) => RalphLoopState | null;
-    markVerificationPending: (sessionID: string) => RalphLoopState | null;
-    setVerificationSessionID: (sessionID: string, verificationSessionID: string) => RalphLoopState | null;
-    restartAfterFailedVerification: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null;
-    clearVerificationState: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null;
-};
-type RalphLoopEventHandlerOptions = {
-    directory: string;
-    apiTimeoutMs: number;
-    idleSettleMs: number;
-    getTranscriptPath: (sessionID: string) => string | undefined;
-    checkSessionExists?: RalphLoopOptions["checkSessionExists"];
-    backgroundManager?: RalphLoopOptions["backgroundManager"];
-    loopState: LoopStateController;
-};
+import type { RalphLoopEventHandlerOptions } from "./event-handler-types";
 export declare function createRalphLoopEventHandler(ctx: PluginInput, options: RalphLoopEventHandlerOptions): ({ event }: {
-    event: {
-        type: string;
-        properties?: unknown;
+    readonly event: {
+        readonly type: string;
+        readonly properties?: unknown;
     };
 }) => Promise<void>;
-export {};

package/dist/hooks/ralph-loop/ralph-loop-hook.d.ts

@@ -14,6 +14,7 @@ export interface RalphLoopHook {
         ultrawork?: boolean;
         strategy?: "reset" | "continue";
     }) => boolean;
+    resumeLoop: (sessionID: string) => boolean;
     cancelLoop: (sessionID: string) => boolean;
     getState: () => RalphLoopState | null;
 }

package/dist/hooks/read-image-resizer/png-chunks.d.ts

@@ -0,0 +1,6 @@
+export interface PngChunk {
+    readonly type: string;
+    readonly data: Buffer;
+    readonly crc: Buffer;
+}
+export declare function readPngChunks(buffer: Buffer): PngChunk[];

package/dist/hooks/read-image-resizer/png-constants.d.ts

@@ -0,0 +1 @@
+export declare const PNG_SIGNATURE: Buffer<ArrayBuffer>;

package/dist/hooks/read-image-resizer/png-crc.d.ts

@@ -0,0 +1 @@
+export declare function crc32(data: Buffer): number;

package/dist/hooks/read-image-resizer/png-decoder.d.ts

@@ -0,0 +1 @@
+export declare function decodePngPixels(idatData: Buffer, width: number, height: number, bytesPerPixel: number): Buffer | null;