oh-my-opencode 3.7.4 → 3.8.0

package/dist/features/tmux-subagent/grid-planning.d.ts

@@ -1,4 +1,4 @@
-import type { TmuxPaneInfo } from "./types";
+import type { CapacityConfig, TmuxPaneInfo } from "./types";
 export interface GridCapacity {
     cols: number;
     rows: number;
@@ -14,6 +14,8 @@ export interface GridPlan {
     slotWidth: number;
     slotHeight: number;
 }
-export declare function calculateCapacity(windowWidth: number, windowHeight: number, minPaneWidth?: number, mainPaneWidth?: number): GridCapacity;
-export declare function computeGridPlan(windowWidth: number, windowHeight: number, paneCount: number, mainPaneWidth?: number, minPaneWidth?: number): GridPlan;
+type CapacityOptions = CapacityConfig | number | undefined;
+export declare function calculateCapacity(windowWidth: number, windowHeight: number, options?: CapacityOptions, mainPaneWidth?: number): GridCapacity;
+export declare function computeGridPlan(windowWidth: number, windowHeight: number, paneCount: number, options?: CapacityOptions, mainPaneWidth?: number): GridPlan;
 export declare function mapPaneToSlot(pane: TmuxPaneInfo, plan: GridPlan, mainPaneWidth: number): GridSlot;
+export {};

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

@@ -33,14 +33,26 @@ export declare class TmuxSessionManager {
     private sourcePaneId;
     private sessions;
     private pendingSessions;
+    private spawnQueue;
+    private deferredSessions;
+    private deferredQueue;
+    private deferredAttachInterval?;
+    private deferredAttachTickScheduled;
+    private nullStateCount;
     private deps;
     private pollingManager;
     constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: TmuxUtilDeps);
     private isEnabled;
     private getCapacityConfig;
     private getSessionMappings;
+    private enqueueDeferredSession;
+    private removeDeferredSession;
+    private startDeferredAttachLoop;
+    private stopDeferredAttachLoop;
+    private tryAttachDeferredSession;
     private waitForSessionReady;
     onSessionCreated(event: SessionCreatedEvent): Promise<void>;
+    private enqueueSpawn;
     onSessionDeleted(event: {
         sessionID: string;
     }): Promise<void>;

package/dist/features/tmux-subagent/pane-split-availability.d.ts

@@ -5,5 +5,4 @@ export declare function isSplittableAtCount(agentAreaWidth: number, paneCount: n
 export declare function findMinimalEvictions(agentAreaWidth: number, currentCount: number, minPaneWidth?: number): number | null;
 export declare function canSplitPane(pane: TmuxPaneInfo, direction: SplitDirection, minPaneWidth?: number): boolean;
 export declare function canSplitPaneAnyDirection(pane: TmuxPaneInfo, minPaneWidth?: number): boolean;
-export declare function canSplitPaneAnyDirectionWithMinWidth(pane: TmuxPaneInfo, minPaneWidth?: number): boolean;
 export declare function getBestSplitDirection(pane: TmuxPaneInfo, minPaneWidth?: number): SplitDirection | null;

package/dist/features/tmux-subagent/spawn-target-finder.d.ts

@@ -1,6 +1,6 @@
-import type { SplitDirection, WindowState } from "./types";
+import type { CapacityConfig, SplitDirection, WindowState } from "./types";
 export interface SpawnTarget {
     targetPaneId: string;
     splitDirection: SplitDirection;
 }
-export declare function findSpawnTarget(state: WindowState, minPaneWidth?: number): SpawnTarget | null;
+export declare function findSpawnTarget(state: WindowState, config: CapacityConfig): SpawnTarget | null;

package/dist/features/tmux-subagent/tmux-grid-constants.d.ts

@@ -1,3 +1,4 @@
+import type { CapacityConfig } from "./types";
 export declare const MAIN_PANE_RATIO = 0.5;
 export declare const MAX_COLS = 2;
 export declare const MAX_ROWS = 3;
@@ -5,3 +6,6 @@ export declare const MAX_GRID_SIZE = 4;
 export declare const DIVIDER_SIZE = 1;
 export declare const MIN_SPLIT_WIDTH: number;
 export declare const MIN_SPLIT_HEIGHT: number;
+export declare function getMainPaneSizePercent(config?: CapacityConfig): number;
+export declare function computeMainPaneWidth(windowWidth: number, config?: CapacityConfig): number;
+export declare function computeAgentAreaWidth(windowWidth: number, config?: CapacityConfig): number;

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

@@ -48,6 +48,8 @@ export interface SpawnDecision {
     reason?: string;
 }
 export interface CapacityConfig {
+    layout?: string;
+    mainPaneSize?: number;
     mainPaneMinWidth: number;
     agentPaneWidth: number;
 }

package/dist/hooks/hashline-edit-diff-enhancer/hook.d.ts

@@ -0,0 +1,28 @@
+interface HashlineEditDiffEnhancerConfig {
+    hashline_edit?: {
+        enabled: boolean;
+    };
+}
+type BeforeInput = {
+    tool: string;
+    sessionID: string;
+    callID: string;
+};
+type BeforeOutput = {
+    args: Record<string, unknown>;
+};
+type AfterInput = {
+    tool: string;
+    sessionID: string;
+    callID: string;
+};
+type AfterOutput = {
+    title: string;
+    output: string;
+    metadata: Record<string, unknown>;
+};
+export declare function createHashlineEditDiffEnhancerHook(config: HashlineEditDiffEnhancerConfig): {
+    "tool.execute.before": (input: BeforeInput, output: BeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: AfterInput, output: AfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/hashline-edit-diff-enhancer/index.d.ts

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

package/dist/hooks/index.d.ts

@@ -13,6 +13,7 @@ export { createDirectoryReadmeInjectorHook } from "./directory-readme-injector";
 export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
 export { createAnthropicContextWindowLimitRecoveryHook, type AnthropicContextWindowLimitRecoveryOptions } from "./anthropic-context-window-limit-recovery";
 export { createThinkModeHook } from "./think-mode";
+export { createModelFallbackHook, setPendingModelFallback, clearPendingModelFallback, type ModelFallbackState } from "./model-fallback/hook";
 export { createClaudeCodeHooksHook } from "./claude-code-hooks";
 export { createRulesInjectorHook } from "./rules-injector";
 export { createBackgroundNotificationHook } from "./background-notification";
@@ -25,9 +26,9 @@ export { createThinkingBlockValidatorHook } from "./thinking-block-validator";
 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 { createAutoSlashCommandHook } from "./auto-slash-command";
 export { createEditErrorRecoveryHook } from "./edit-error-recovery";
-export { createJsonErrorRecoveryHook } from "./json-error-recovery";
 export { createPrometheusMdOnlyHook } from "./prometheus-md-only";
 export { createSisyphusJuniorNotepadHook } from "./sisyphus-junior-notepad";
 export { createTaskResumeInfoHook } from "./task-resume-info";
@@ -41,6 +42,7 @@ export { createCompactionTodoPreserverHook } from "./compaction-todo-preserver";
 export { createUnstableAgentBabysitterHook } from "./unstable-agent-babysitter";
 export { createPreemptiveCompactionHook } from "./preemptive-compaction";
 export { createTasksTodowriteDisablerHook } from "./tasks-todowrite-disabler";
+export { createRuntimeFallbackHook, type RuntimeFallbackHook, type RuntimeFallbackOptions } from "./runtime-fallback";
 export { createWriteExistingFileGuardHook } from "./write-existing-file-guard";
 export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
-export { createUltraworkModelOverrideHook } from "./ultrawork-model-override";
+export { createJsonErrorRecoveryHook, JSON_ERROR_TOOL_EXCLUDE_LIST, JSON_ERROR_PATTERNS, JSON_ERROR_REMINDER } from "./json-error-recovery";

package/dist/hooks/model-fallback/hook.d.ts

@@ -0,0 +1,60 @@
+import type { FallbackEntry } from "../../shared/model-requirements";
+import type { ChatMessageInput, ChatMessageHandlerOutput } from "../../plugin/chat-message";
+type FallbackToast = (input: {
+    title: string;
+    message: string;
+    variant?: "info" | "success" | "warning" | "error";
+    duration?: number;
+}) => void | Promise<void>;
+type FallbackCallback = (input: {
+    sessionID: string;
+    providerID: string;
+    modelID: string;
+    variant?: string;
+}) => void | Promise<void>;
+export type ModelFallbackState = {
+    providerID: string;
+    modelID: string;
+    fallbackChain: FallbackEntry[];
+    attemptCount: number;
+    pending: boolean;
+};
+export declare function setSessionFallbackChain(sessionID: string, fallbackChain: FallbackEntry[] | undefined): void;
+export declare function clearSessionFallbackChain(sessionID: string): void;
+/**
+ * Sets a pending model fallback for a session.
+ * Called when a model error is detected in session.error handler.
+ */
+export declare function setPendingModelFallback(sessionID: string, agentName: string, currentProviderID: string, currentModelID: string): boolean;
+/**
+ * Gets the next fallback model for a session.
+ * Increments attemptCount each time called.
+ */
+export declare function getNextFallback(sessionID: string): {
+    providerID: string;
+    modelID: string;
+    variant?: string;
+} | null;
+/**
+ * Clears the pending fallback for a session.
+ * Called after fallback is successfully applied.
+ */
+export declare function clearPendingModelFallback(sessionID: string): void;
+/**
+ * Checks if there's a pending fallback for a session.
+ */
+export declare function hasPendingModelFallback(sessionID: string): boolean;
+/**
+ * Gets the current fallback state for a session (for debugging).
+ */
+export declare function getFallbackState(sessionID: string): ModelFallbackState | undefined;
+/**
+ * Creates a chat.message hook that applies model fallbacks when pending.
+ */
+export declare function createModelFallbackHook(args?: {
+    toast?: FallbackToast;
+    onApplied?: FallbackCallback;
+}): {
+    "chat.message": (input: ChatMessageInput, output: ChatMessageHandlerOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/no-hephaestus-non-gpt/hook.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createNoHephaestusNonGptHook(ctx: PluginInput): {
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    }, output?: {
+        message?: {
+            agent?: string;
+            [key: string]: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/no-hephaestus-non-gpt/index.d.ts

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

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

@@ -0,0 +1,8 @@
+export type RalphLoopStrategy = "reset" | "continue";
+export type ParsedRalphLoopArguments = {
+    prompt: string;
+    maxIterations?: number;
+    completionPromise?: string;
+    strategy?: RalphLoopStrategy;
+};
+export declare function parseRalphLoopArguments(rawArguments: string): ParsedRalphLoopArguments;

package/dist/hooks/ralph-loop/continuation-prompt-injector.d.ts

@@ -4,4 +4,5 @@ export declare function injectContinuationPrompt(ctx: PluginInput, options: {
     prompt: string;
     directory: string;
     apiTimeoutMs: number;
+    inheritFromSessionID?: string;
 }): Promise<void>;

package/dist/hooks/ralph-loop/iteration-continuation.d.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+type ContinuationOptions = {
+    directory: string;
+    apiTimeoutMs: number;
+    previousSessionID: string;
+    loopState: {
+        setSessionID: (sessionID: string) => RalphLoopState | null;
+    };
+};
+export declare function continueIteration(ctx: PluginInput, state: RalphLoopState, options: ContinuationOptions): Promise<void>;
+export {};

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

@@ -8,9 +8,11 @@ export declare function createLoopStateController(options: {
         maxIterations?: number;
         completionPromise?: string;
         ultrawork?: boolean;
+        strategy?: "reset" | "continue";
     }): boolean;
     cancelLoop(sessionID: string): boolean;
     getState(): RalphLoopState | null;
     clear(): boolean;
     incrementIteration(): RalphLoopState | null;
+    setSessionID(sessionID: string): RalphLoopState | null;
 };

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

@@ -9,6 +9,7 @@ type LoopStateController = {
     getState: () => RalphLoopState | null;
     clear: () => boolean;
     incrementIteration: () => RalphLoopState | null;
+    setSessionID: (sessionID: string) => RalphLoopState | null;
 };
 type RalphLoopEventHandlerOptions = {
     directory: string;

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

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

package/dist/hooks/ralph-loop/session-reset-strategy.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createIterationSession(ctx: PluginInput, parentSessionID: string, directory: string): Promise<string | null>;
+export declare function selectSessionInTui(client: PluginInput["client"], sessionID: string): Promise<boolean>;

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

@@ -8,6 +8,7 @@ export interface RalphLoopState {
     prompt: string;
     session_id?: string;
     ultrawork?: boolean;
+    strategy?: "reset" | "continue";
 }
 export interface RalphLoopOptions {
     config?: RalphLoopConfig;

package/dist/hooks/runtime-fallback/agent-resolver.d.ts

@@ -0,0 +1,5 @@
+export declare const AGENT_NAMES: string[];
+export declare const agentPattern: RegExp;
+export declare function detectAgentFromSession(sessionID: string): string | undefined;
+export declare function normalizeAgentName(agent: string | undefined): string | undefined;
+export declare function resolveAgentForSession(sessionID: string, eventAgent?: string): string | undefined;

package/dist/hooks/runtime-fallback/auto-retry.d.ts

@@ -0,0 +1,10 @@
+import type { HookDeps } from "./types";
+export declare function createAutoRetryHelpers(deps: HookDeps): {
+    abortSessionRequest: (sessionID: string, source: string) => Promise<void>;
+    clearSessionFallbackTimeout: (sessionID: string) => void;
+    scheduleSessionFallbackTimeout: (sessionID: string, resolvedAgent?: string) => void;
+    autoRetryWithFallback: (sessionID: string, newModel: string, resolvedAgent: string | undefined, source: string) => Promise<void>;
+    resolveAgentForSessionFromContext: (sessionID: string, eventAgent?: string) => Promise<string | undefined>;
+    cleanupStaleSessions: () => void;
+};
+export type AutoRetryHelpers = ReturnType<typeof createAutoRetryHelpers>;

package/dist/hooks/runtime-fallback/chat-message-handler.d.ts

@@ -0,0 +1,20 @@
+import type { HookDeps } from "./types";
+export declare function createChatMessageHandler(deps: HookDeps): (input: {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+}, output: {
+    message: {
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    };
+    parts?: Array<{
+        type: string;
+        text?: string;
+    }>;
+}) => Promise<void>;

package/dist/hooks/runtime-fallback/constants.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Runtime Fallback Hook - Constants
+ *
+ * Default values and configuration constants for the runtime fallback feature.
+ */
+import type { RuntimeFallbackConfig } from "../../config";
+/**
+ * Default configuration values for runtime fallback
+ */
+export declare const DEFAULT_CONFIG: Required<RuntimeFallbackConfig>;
+/**
+ * Error patterns that indicate rate limiting or temporary failures
+ * These are checked in addition to HTTP status codes
+ */
+export declare const RETRYABLE_ERROR_PATTERNS: RegExp[];
+/**
+ * Hook name for identification and logging
+ */
+export declare const HOOK_NAME = "runtime-fallback";

package/dist/hooks/runtime-fallback/error-classifier.d.ts

@@ -0,0 +1,17 @@
+export declare function getErrorMessage(error: unknown): string;
+export declare function extractStatusCode(error: unknown, retryOnErrors?: number[]): number | undefined;
+export declare function extractErrorName(error: unknown): string | undefined;
+export declare function classifyErrorType(error: unknown): string | undefined;
+export interface AutoRetrySignal {
+    signal: string;
+}
+export declare const AUTO_RETRY_PATTERNS: Array<(combined: string) => boolean>;
+export declare function extractAutoRetrySignal(info: Record<string, unknown> | undefined): AutoRetrySignal | undefined;
+export declare function containsErrorContent(parts: Array<{
+    type?: string;
+    text?: string;
+}> | undefined): {
+    hasError: boolean;
+    errorMessage?: string;
+};
+export declare function isRetryableError(error: unknown, retryOnErrors: number[]): boolean;

package/dist/hooks/runtime-fallback/event-handler.d.ts

@@ -0,0 +1,8 @@
+import type { HookDeps } from "./types";
+import type { AutoRetryHelpers } from "./auto-retry";
+export declare function createEventHandler(deps: HookDeps, helpers: AutoRetryHelpers): ({ event }: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}) => Promise<void>;

package/dist/hooks/runtime-fallback/fallback-models.d.ts

@@ -0,0 +1,2 @@
+import type { OhMyOpenCodeConfig } from "../../config";
+export declare function getFallbackModelsForSession(sessionID: string, agent: string | undefined, pluginConfig: OhMyOpenCodeConfig | undefined): string[];

package/dist/hooks/runtime-fallback/fallback-state.d.ts

@@ -0,0 +1,6 @@
+import type { FallbackState, FallbackResult } from "./types";
+import type { RuntimeFallbackConfig } from "../../config";
+export declare function createFallbackState(originalModel: string): FallbackState;
+export declare function isModelInCooldown(model: string, state: FallbackState, cooldownSeconds: number): boolean;
+export declare function findNextAvailableFallback(state: FallbackState, fallbackModels: string[], cooldownSeconds: number): string | undefined;
+export declare function prepareFallback(sessionID: string, state: FallbackState, fallbackModels: string[], config: Required<RuntimeFallbackConfig>): FallbackResult;

package/dist/hooks/runtime-fallback/hook.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RuntimeFallbackHook, RuntimeFallbackOptions } from "./types";
+export declare function createRuntimeFallbackHook(ctx: PluginInput, options?: RuntimeFallbackOptions): RuntimeFallbackHook;

package/dist/hooks/runtime-fallback/index.d.ts

@@ -0,0 +1,2 @@
+export { createRuntimeFallbackHook } from "./hook";
+export type { RuntimeFallbackHook, RuntimeFallbackOptions } from "./types";

package/dist/hooks/runtime-fallback/message-update-handler.d.ts

@@ -0,0 +1,5 @@
+import type { HookDeps } from "./types";
+import type { AutoRetryHelpers } from "./auto-retry";
+import { extractAutoRetrySignal } from "./error-classifier";
+export declare function hasVisibleAssistantResponse(extractAutoRetrySignalFn: typeof extractAutoRetrySignal): (ctx: HookDeps["ctx"], sessionID: string, _info: Record<string, unknown> | undefined) => Promise<boolean>;
+export declare function createMessageUpdateHandler(deps: HookDeps, helpers: AutoRetryHelpers): (props: Record<string, unknown> | undefined) => Promise<void>;

package/dist/hooks/runtime-fallback/types.d.ts

@@ -0,0 +1,59 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RuntimeFallbackConfig, OhMyOpenCodeConfig } from "../../config";
+export interface FallbackState {
+    originalModel: string;
+    currentModel: string;
+    fallbackIndex: number;
+    failedModels: Map<string, number>;
+    attemptCount: number;
+    pendingFallbackModel?: string;
+}
+export interface FallbackResult {
+    success: boolean;
+    newModel?: string;
+    error?: string;
+    maxAttemptsReached?: boolean;
+}
+export interface RuntimeFallbackOptions {
+    config?: RuntimeFallbackConfig;
+    pluginConfig?: OhMyOpenCodeConfig;
+    session_timeout_ms?: number;
+}
+export interface RuntimeFallbackHook {
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    "chat.message"?: (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    }, output: {
+        message: {
+            model?: {
+                providerID: string;
+                modelID: string;
+            };
+        };
+        parts?: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+}
+export interface HookDeps {
+    ctx: PluginInput;
+    config: Required<RuntimeFallbackConfig>;
+    options: RuntimeFallbackOptions | undefined;
+    pluginConfig: OhMyOpenCodeConfig | undefined;
+    sessionStates: Map<string, FallbackState>;
+    sessionLastAccess: Map<string, number>;
+    sessionRetryInFlight: Set<string>;
+    sessionAwaitingFallbackResult: Set<string>;
+    sessionFallbackTimeouts: Map<string, ReturnType<typeof setTimeout>>;
+}

package/dist/hooks/session-recovery/detect-error-type.d.ts

@@ -1,3 +1,4 @@
-export type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | "assistant_prefill_unsupported" | null;
+export type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | "assistant_prefill_unsupported" | "unavailable_tool" | null;
 export declare function extractMessageIndex(error: unknown): number | null;
+export declare function extractUnavailableToolName(error: unknown): string | null;
 export declare function detectErrorType(error: unknown): RecoveryErrorType;

package/dist/hooks/session-recovery/recover-unavailable-tool.d.ts

@@ -0,0 +1,5 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+import type { MessageData } from "./types";
+type Client = ReturnType<typeof createOpencodeClient>;
+export declare function recoverUnavailableTool(client: Client, sessionID: string, failedAssistantMsg: MessageData): Promise<boolean>;
+export {};

package/dist/hooks/todo-continuation-enforcer/continuation-injection.d.ts

@@ -9,4 +9,5 @@ export declare function injectContinuation(args: {
     skipAgents?: string[];
     resolvedInfo?: ResolvedMessageInfo;
     sessionStateStore: SessionStateStore;
+    isContinuationStopped?: (sessionID: string) => boolean;
 }): Promise<void>;

package/dist/hooks/todo-continuation-enforcer/countdown.d.ts

@@ -11,4 +11,5 @@ export declare function startCountdown(args: {
     backgroundManager?: BackgroundManager;
     skipAgents: string[];
     sessionStateStore: SessionStateStore;
+    isContinuationStopped?: (sessionID: string) => boolean;
 }): void;

package/dist/hooks/write-existing-file-guard/hook.d.ts

@@ -1,2 +1,3 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+export declare const MAX_TRACKED_PATHS_PER_SESSION = 1024;
 export declare function createWriteExistingFileGuardHook(ctx: PluginInput): Hooks;