oh-my-opencode 3.12.3 → 3.13.1

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

@@ -3,7 +3,6 @@ export declare const HookNameSchema: z.ZodEnum<{
     atlas: "atlas";
     "ralph-loop": "ralph-loop";
     "start-work": "start-work";
-    "gpt-permission-continuation": "gpt-permission-continuation";
     "todo-continuation-enforcer": "todo-continuation-enforcer";
     "context-window-monitor": "context-window-monitor";
     "session-recovery": "session-recovery";
@@ -49,5 +48,6 @@ export declare const HookNameSchema: z.ZodEnum<{
     "hashline-read-enhancer": "hashline-read-enhancer";
     "read-image-resizer": "read-image-resizer";
     "todo-description-override": "todo-description-override";
+    "webfetch-redirect-guard": "webfetch-redirect-guard";
 }>;
 export type HookName = z.infer<typeof HookNameSchema>;

package/dist/config/schema/oh-my-opencode-config.d.ts

@@ -1351,6 +1351,37 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     notification: z.ZodOptional<z.ZodObject<{
         force_enable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    openclaw: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        gateways: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodDefault<z.ZodEnum<{
+                command: "command";
+                http: "http";
+            }>>;
+            url: z.ZodOptional<z.ZodString>;
+            method: z.ZodDefault<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            command: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        hooks: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            gateway: z.ZodString;
+            instruction: z.ZodString;
+        }, z.core.$strip>>>;
+        replyListener: z.ZodOptional<z.ZodObject<{
+            discordBotToken: z.ZodOptional<z.ZodString>;
+            discordChannelId: z.ZodOptional<z.ZodString>;
+            discordMention: z.ZodOptional<z.ZodString>;
+            authorizedDiscordUserIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            telegramBotToken: z.ZodOptional<z.ZodString>;
+            telegramChatId: z.ZodOptional<z.ZodString>;
+            pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+            rateLimitPerMinute: z.ZodDefault<z.ZodNumber>;
+            maxMessageLength: z.ZodDefault<z.ZodNumber>;
+            includePrefix: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     babysitting: z.ZodOptional<z.ZodObject<{
         timeout_ms: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;

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

@@ -0,0 +1,64 @@
+import { z } from "zod";
+export declare const OpenClawGatewaySchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<{
+        command: "command";
+        http: "http";
+    }>>;
+    url: z.ZodOptional<z.ZodString>;
+    method: z.ZodDefault<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    command: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const OpenClawHookSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    gateway: z.ZodString;
+    instruction: z.ZodString;
+}, z.core.$strip>;
+export declare const OpenClawReplyListenerConfigSchema: z.ZodObject<{
+    discordBotToken: z.ZodOptional<z.ZodString>;
+    discordChannelId: z.ZodOptional<z.ZodString>;
+    discordMention: z.ZodOptional<z.ZodString>;
+    authorizedDiscordUserIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    telegramBotToken: z.ZodOptional<z.ZodString>;
+    telegramChatId: z.ZodOptional<z.ZodString>;
+    pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+    rateLimitPerMinute: z.ZodDefault<z.ZodNumber>;
+    maxMessageLength: z.ZodDefault<z.ZodNumber>;
+    includePrefix: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const OpenClawConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    gateways: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodDefault<z.ZodEnum<{
+            command: "command";
+            http: "http";
+        }>>;
+        url: z.ZodOptional<z.ZodString>;
+        method: z.ZodDefault<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        command: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    hooks: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        gateway: z.ZodString;
+        instruction: z.ZodString;
+    }, z.core.$strip>>>;
+    replyListener: z.ZodOptional<z.ZodObject<{
+        discordBotToken: z.ZodOptional<z.ZodString>;
+        discordChannelId: z.ZodOptional<z.ZodString>;
+        discordMention: z.ZodOptional<z.ZodString>;
+        authorizedDiscordUserIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        telegramBotToken: z.ZodOptional<z.ZodString>;
+        telegramChatId: z.ZodOptional<z.ZodString>;
+        pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+        rateLimitPerMinute: z.ZodDefault<z.ZodNumber>;
+        maxMessageLength: z.ZodDefault<z.ZodNumber>;
+        includePrefix: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OpenClawConfig = z.infer<typeof OpenClawConfigSchema>;
+export type OpenClawGateway = z.infer<typeof OpenClawGatewaySchema>;
+export type OpenClawHook = z.infer<typeof OpenClawHookSchema>;
+export type OpenClawReplyListenerConfig = z.infer<typeof OpenClawReplyListenerConfigSchema>;

package/dist/create-hooks.d.ts

@@ -27,7 +27,6 @@ export declare function createHooks(args: {
     disposeHooks: () => void;
     categorySkillReminder: ReturnType<typeof import("./hooks").createCategorySkillReminderHook> | null;
     autoSlashCommand: ReturnType<typeof import("./hooks").createAutoSlashCommandHook> | null;
-    gptPermissionContinuation: ReturnType<typeof import("./hooks").createGptPermissionContinuationHook> | null;
     stopContinuationGuard: ReturnType<typeof import("./hooks").createStopContinuationGuardHook> | null;
     compactionContextInjector: ReturnType<typeof import("./hooks").createCompactionContextInjector> | null;
     compactionTodoPreserver: ReturnType<typeof import("./hooks").createCompactionTodoPreserverHook> | null;
@@ -51,6 +50,7 @@ export declare function createHooks(args: {
     jsonErrorRecovery: ReturnType<typeof import("./hooks").createJsonErrorRecoveryHook> | null;
     readImageResizer: ReturnType<typeof import("./hooks").createReadImageResizerHook> | null;
     todoDescriptionOverride: ReturnType<typeof import("./hooks").createTodoDescriptionOverrideHook> | null;
+    webfetchRedirectGuard: ReturnType<typeof import("./hooks").createWebFetchRedirectGuardHook> | null;
     contextWindowMonitor: ReturnType<typeof import("./hooks").createContextWindowMonitorHook> | null;
     preemptiveCompaction: ReturnType<typeof import("./hooks").createPreemptiveCompactionHook> | null;
     sessionRecovery: ReturnType<typeof import("./hooks").createSessionRecoveryHook> | null;

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

@@ -3,9 +3,9 @@ import type { BackgroundTask, LaunchInput } from "./types";
 export declare const TASK_TTL_MS: number;
 export declare const TERMINAL_TASK_TTL_MS: number;
 export declare const MIN_STABILITY_TIME_MS: number;
-export declare const DEFAULT_STALE_TIMEOUT_MS = 1200000;
-export declare const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 1800000;
-export declare const DEFAULT_MAX_TOOL_CALLS = 200;
+export declare const DEFAULT_STALE_TIMEOUT_MS = 2700000;
+export declare const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 3600000;
+export declare const DEFAULT_MAX_TOOL_CALLS = 4000;
 export declare const DEFAULT_CIRCUIT_BREAKER_CONSECUTIVE_THRESHOLD = 20;
 export declare const DEFAULT_CIRCUIT_BREAKER_ENABLED = true;
 export declare const MIN_RUNTIME_BEFORE_STALE_MS = 30000;

package/dist/features/boulder-state/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./types";
 export * from "./constants";
 export * from "./storage";
+export * from "./top-level-task";

package/dist/features/boulder-state/storage.d.ts

@@ -3,12 +3,21 @@
  *
  * Handles reading/writing boulder.json for active plan tracking.
  */
-import type { BoulderState, PlanProgress } from "./types";
+import type { BoulderState, PlanProgress, TaskSessionState } from "./types";
 export declare function getBoulderFilePath(directory: string): string;
 export declare function readBoulderState(directory: string): BoulderState | null;
 export declare function writeBoulderState(directory: string, state: BoulderState): boolean;
 export declare function appendSessionId(directory: string, sessionId: string): BoulderState | null;
 export declare function clearBoulderState(directory: string): boolean;
+export declare function getTaskSessionState(directory: string, taskKey: string): TaskSessionState | null;
+export declare function upsertTaskSessionState(directory: string, input: {
+    taskKey: string;
+    taskLabel: string;
+    taskTitle: string;
+    sessionId: string;
+    agent?: string;
+    category?: string;
+}): BoulderState | null;
 /**
  * Find Prometheus plan files for this project.
  * Prometheus stores plans at: {project}/.sisyphus/plans/{name}.md

package/dist/features/boulder-state/top-level-task.d.ts

@@ -0,0 +1,2 @@
+import type { TopLevelTaskRef } from "./types";
+export declare function readCurrentTopLevelTask(planPath: string): TopLevelTaskRef | null;

package/dist/features/boulder-state/types.d.ts

@@ -17,6 +17,8 @@ export interface BoulderState {
     agent?: string;
     /** Absolute path to the git worktree root where work happens */
     worktree_path?: string;
+    /** Preferred reusable subagent sessions keyed by current top-level plan task */
+    task_sessions?: Record<string, TaskSessionState>;
 }
 export interface PlanProgress {
     /** Total number of checkboxes */
@@ -26,3 +28,29 @@ export interface PlanProgress {
     /** Whether all tasks are done */
     isComplete: boolean;
 }
+export interface TaskSessionState {
+    /** Stable identifier for the current top-level plan task (e.g. todo:1 / final-wave:F1) */
+    task_key: string;
+    /** Original task label from the plan file */
+    task_label: string;
+    /** Full task title from the plan file */
+    task_title: string;
+    /** Preferred reusable subagent session */
+    session_id: string;
+    /** Agent associated with the task session, when known */
+    agent?: string;
+    /** Category associated with the task session, when known */
+    category?: string;
+    /** Last update timestamp */
+    updated_at: string;
+}
+export interface TopLevelTaskRef {
+    /** Stable identifier for the current top-level plan task */
+    key: string;
+    /** Task section in the Prometheus plan */
+    section: "todo" | "final-wave";
+    /** Original label token (e.g. 1 / F1) */
+    label: string;
+    /** Full task title extracted from the checkbox line */
+    title: string;
+}

package/dist/hooks/atlas/boulder-continuation-injector.d.ts

@@ -9,6 +9,8 @@ export declare function injectBoulderContinuation(input: {
     total: number;
     agent?: string;
     worktreePath?: string;
+    preferredTaskSessionId?: string;
+    preferredTaskTitle?: string;
     backgroundManager?: BackgroundManager;
     sessionState: SessionState;
 }): Promise<void>;

package/dist/hooks/atlas/subagent-session-id.d.ts

@@ -1 +1,7 @@
-export declare function extractSessionIdFromOutput(output: string): string;
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function extractSessionIdFromOutput(output: string): string | undefined;
+export declare function validateSubagentSessionId(input: {
+    client: PluginInput["client"];
+    sessionID?: string;
+    lineageSessionIDs: string[];
+}): Promise<string | undefined>;

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

@@ -1,9 +1,10 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-import type { SessionState } from "./types";
+import type { PendingTaskRef, SessionState } from "./types";
 import type { ToolExecuteAfterInput, ToolExecuteAfterOutput } from "./types";
 export declare function createToolExecuteAfterHandler(input: {
     ctx: PluginInput;
     pendingFilePaths: Map<string, string>;
+    pendingTaskRefs: Map<string, PendingTaskRef>;
     autoCommit: boolean;
     getState: (sessionID: string) => SessionState;
 }): (toolInput: ToolExecuteAfterInput, toolOutput: ToolExecuteAfterOutput) => Promise<void>;

package/dist/hooks/atlas/tool-execute-before.d.ts

@@ -1,7 +1,9 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { PendingTaskRef } from "./types";
 export declare function createToolExecuteBeforeHandler(input: {
     ctx: PluginInput;
     pendingFilePaths: Map<string, string>;
+    pendingTaskRefs: Map<string, PendingTaskRef>;
 }): (toolInput: {
     tool: string;
     sessionID?: string;

package/dist/hooks/atlas/types.d.ts

@@ -1,5 +1,6 @@
 import type { AgentOverrides } from "../../config";
 import type { BackgroundManager } from "../../features/background-agent";
+import type { TopLevelTaskRef } from "../../features/boulder-state";
 export type ModelInfo = {
     providerID: string;
     modelID: string;
@@ -8,7 +9,6 @@ export interface AtlasHookOptions {
     directory: string;
     backgroundManager?: BackgroundManager;
     isContinuationStopped?: (sessionID: string) => boolean;
-    shouldSkipContinuation?: (sessionID: string) => boolean;
     agentOverrides?: AgentOverrides;
     /** Enable auto-commit after each atomic task completion (default: true) */
     autoCommit?: boolean;
@@ -23,6 +23,18 @@ export interface ToolExecuteAfterOutput {
     output: string;
     metadata: Record<string, unknown>;
 }
+export type TrackedTopLevelTaskRef = Pick<TopLevelTaskRef, "key" | "label" | "title">;
+export type PendingTaskRef = {
+    kind: "track";
+    task: TrackedTopLevelTaskRef;
+} | {
+    kind: "skip";
+    reason: "explicit_resume";
+} | {
+    kind: "skip";
+    reason: "ambiguous_task_key";
+    task: TrackedTopLevelTaskRef;
+};
 export interface SessionState {
     lastEventWasAbortError?: boolean;
     lastContinuationInjectedAt?: number;

package/dist/hooks/index.d.ts

@@ -27,7 +27,6 @@ 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 { createGptPermissionContinuationHook, type GptPermissionContinuationHook } from "./gpt-permission-continuation";
 export { createAutoSlashCommandHook } from "./auto-slash-command";
 export { createEditErrorRecoveryHook } from "./edit-error-recovery";
 export { createPrometheusMdOnlyHook } from "./prometheus-md-only";
@@ -49,3 +48,4 @@ export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
 export { createJsonErrorRecoveryHook, JSON_ERROR_TOOL_EXCLUDE_LIST, JSON_ERROR_PATTERNS, JSON_ERROR_REMINDER } from "./json-error-recovery";
 export { createReadImageResizerHook } from "./read-image-resizer";
 export { createTodoDescriptionOverrideHook } from "./todo-description-override";
+export { createWebFetchRedirectGuardHook } from "./webfetch-redirect-guard";

package/dist/hooks/keyword-detector/constants.d.ts

@@ -1,6 +1,6 @@
 export declare const CODE_BLOCK_PATTERN: RegExp;
 export declare const INLINE_CODE_PATTERN: RegExp;
-export { isPlannerAgent, getUltraworkMessage } from "./ultrawork";
+export { isPlannerAgent, isNonOmoAgent, getUltraworkMessage } from "./ultrawork";
 export { SEARCH_PATTERN, SEARCH_MESSAGE } from "./search";
 export { ANALYZE_PATTERN, ANALYZE_MESSAGE } from "./analyze";
 export type KeywordDetector = {

package/dist/hooks/keyword-detector/ultrawork/index.d.ts

@@ -7,7 +7,7 @@
  * 3. Gemini models → gemini.ts
  * 4. Default (Claude, etc.) → default.ts (optimized for Claude series)
  */
-export { isPlannerAgent, isGptModel, isGeminiModel, getUltraworkSource, } from "./source-detector";
+export { isPlannerAgent, isNonOmoAgent, isGptModel, isGeminiModel, getUltraworkSource, } from "./source-detector";
 export type { UltraworkSource } from "./source-detector";
 export { ULTRAWORK_PLANNER_SECTION, getPlannerUltraworkMessage, } from "./planner";
 export { ULTRAWORK_GPT_MESSAGE, getGptUltraworkMessage } from "./gpt";

package/dist/hooks/keyword-detector/ultrawork/source-detector.d.ts

@@ -13,6 +13,11 @@ import { isGptModel, isGeminiModel } from "../../../agents/types";
  * Planners don't need ultrawork injection (they ARE the planner).
  */
 export declare function isPlannerAgent(agentName?: string): boolean;
+/**
+ * Checks if agent is a non-OMO agent (e.g., OpenCode's built-in Builder/Plan).
+ * Non-OMO agents should not receive keyword injection (search-mode, analyze-mode, etc.).
+ */
+export declare function isNonOmoAgent(agentName?: string): boolean;
 export { isGptModel, isGeminiModel };
 /** Ultrawork message source type */
 export type UltraworkSource = "planner" | "gpt" | "gemini" | "default";

package/dist/hooks/openclaw.d.ts

@@ -0,0 +1,11 @@
+import type { PluginContext } from "../plugin/types";
+import type { OhMyOpenCodeConfig } from "../config";
+export declare function createOpenClawHook(ctx: PluginContext, pluginConfig: OhMyOpenCodeConfig): {
+    event: (input: any) => Promise<void>;
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+} | null;

package/dist/hooks/preemptive-compaction-degradation-monitor.d.ts

@@ -0,0 +1,55 @@
+import type { OhMyOpenCodeConfig } from "../config";
+interface CompactionTargetState {
+    providerID: string;
+    modelID: string;
+}
+interface ClientLike {
+    session: {
+        summarize: (input: {
+            path: {
+                id: string;
+            };
+            body: {
+                providerID: string;
+                modelID: string;
+            };
+            query: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+        messages: (input: {
+            path: {
+                id: string;
+            };
+            query?: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+    };
+    tui: {
+        showToast: (input: {
+            body: {
+                title: string;
+                message: string;
+                variant: "warning";
+                duration: number;
+            };
+        }) => Promise<unknown>;
+    };
+}
+export interface AssistantCompactionMessageInfo {
+    sessionID: string;
+    id?: string;
+}
+export declare function createPostCompactionDegradationMonitor(args: {
+    client: ClientLike;
+    directory: string;
+    pluginConfig: OhMyOpenCodeConfig;
+    tokenCache: Map<string, CompactionTargetState>;
+    compactionInProgress: Set<string>;
+}): {
+    clear: (sessionID: string) => void;
+    onSessionCompacted: (sessionID: string) => void;
+    onAssistantMessageUpdated: (info: AssistantCompactionMessageInfo) => Promise<void>;
+};
+export {};

package/dist/hooks/preemptive-compaction-no-text-tail.d.ts

@@ -0,0 +1,18 @@
+export declare function isStepOnlyNoTextParts(parts: unknown): boolean;
+export declare function resolveNoTextTailFromSession(args: {
+    client: {
+        session: {
+            messages: (input: {
+                path: {
+                    id: string;
+                };
+                query?: {
+                    directory: string;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+    sessionID: string;
+    messageID?: string;
+    directory: string;
+}): Promise<boolean>;

package/dist/hooks/session-recovery/storage/thinking-prepend.d.ts

@@ -1,5 +1,30 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { MessageData, StoredPart } from "../types";
+import { log, isSqliteBackend, patchPart } from "../../../shared";
 type OpencodeClient = PluginInput["client"];
-export declare function prependThinkingPart(sessionID: string, messageID: string): boolean;
-export declare function prependThinkingPartAsync(client: OpencodeClient, sessionID: string, messageID: string): Promise<boolean>;
+type StoredSignedThinkingPart = StoredPart & {
+    type: "thinking" | "redacted_thinking";
+    signature: string;
+};
+type SDKMessagePart = NonNullable<MessageData["parts"]>[number];
+type SDKSignedThinkingPart = SDKMessagePart & {
+    id: string;
+    type: "thinking" | "redacted_thinking";
+    signature: string;
+};
+type ThinkingPrependDeps = {
+    isSqliteBackend: typeof isSqliteBackend;
+    patchPart: typeof patchPart;
+    log: typeof log;
+    findLastThinkingPart: typeof findLastThinkingPart;
+    findLastThinkingPartFromSDK: typeof findLastThinkingPartFromSDK;
+    readTargetPartIDs: typeof readTargetPartIDs;
+    readTargetPartIDsFromSDK: typeof readTargetPartIDsFromSDK;
+};
+declare function readTargetPartIDs(messageID: string): string[];
+declare function readTargetPartIDsFromSDK(client: OpencodeClient, sessionID: string, messageID: string): Promise<string[]>;
+declare function findLastThinkingPart(sessionID: string, beforeMessageID: string): StoredSignedThinkingPart | null;
+export declare function prependThinkingPart(sessionID: string, messageID: string, deps?: ThinkingPrependDeps): boolean;
+declare function findLastThinkingPartFromSDK(client: OpencodeClient, sessionID: string, beforeMessageID: string): Promise<SDKSignedThinkingPart | null>;
+export declare function prependThinkingPartAsync(client: OpencodeClient, sessionID: string, messageID: string, deps?: ThinkingPrependDeps): Promise<boolean>;
 export {};

package/dist/hooks/todo-continuation-enforcer/compaction-guard.d.ts

@@ -1,2 +1,4 @@
 import type { SessionState } from "./types";
+export declare function armCompactionGuard(state: SessionState, now: number): number;
+export declare function acknowledgeCompactionGuard(state: SessionState, compactionEpoch: number | undefined): boolean;
 export declare function isCompactionGuardActive(state: SessionState, now: number): boolean;

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

@@ -7,7 +7,6 @@ export declare function createTodoContinuationHandler(args: {
     backgroundManager?: BackgroundManager;
     skipAgents?: string[];
     isContinuationStopped?: (sessionID: string) => boolean;
-    shouldSkipContinuation?: (sessionID: string) => boolean;
 }): (input: {
     event: {
         type: string;

package/dist/hooks/todo-continuation-enforcer/idle-event.d.ts

@@ -8,5 +8,4 @@ export declare function handleSessionIdle(args: {
     backgroundManager?: BackgroundManager;
     skipAgents?: string[];
     isContinuationStopped?: (sessionID: string) => boolean;
-    shouldSkipContinuation?: (sessionID: string) => boolean;
 }): Promise<void>;

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

@@ -4,7 +4,6 @@ export interface TodoContinuationEnforcerOptions {
     backgroundManager?: BackgroundManager;
     skipAgents?: string[];
     isContinuationStopped?: (sessionID: string) => boolean;
-    shouldSkipContinuation?: (sessionID: string) => boolean;
 }
 export interface TodoContinuationEnforcer {
     handler: (input: {
@@ -37,6 +36,8 @@ export interface SessionState {
     stagnationCount: number;
     consecutiveFailures: number;
     recentCompactionAt?: number;
+    recentCompactionEpoch?: number;
+    acknowledgedCompactionEpoch?: number;
 }
 export interface MessageInfo {
     id?: string;

package/dist/hooks/webfetch-redirect-guard/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_WEBFETCH_TIMEOUT_MS = 30000;
+export declare const MAX_WEBFETCH_TIMEOUT_MS = 120000;
+export declare const MAX_WEBFETCH_REDIRECTS = 10;
+export declare const WEBFETCH_REDIRECT_GUARD_STALE_TIMEOUT_MS: number;
+export declare const WEBFETCH_REDIRECT_ERROR_PATTERNS: readonly [RegExp, RegExp];
+export declare const WEBFETCH_REDIRECT_STATUSES: Set<number>;

package/dist/hooks/webfetch-redirect-guard/hook.d.ts

@@ -0,0 +1,19 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type ToolExecuteInput = {
+    tool: string;
+    sessionID: string;
+    callID: string;
+};
+type ToolExecuteBeforeOutput = {
+    args: Record<string, unknown>;
+};
+type ToolExecuteAfterOutput = {
+    title: string;
+    output: string;
+    metadata: Record<string, unknown>;
+};
+export declare function createWebFetchRedirectGuardHook(_ctx: PluginInput): {
+    "tool.execute.before": (input: ToolExecuteInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteAfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/webfetch-redirect-guard/index.d.ts

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

package/dist/hooks/webfetch-redirect-guard/redirect-resolution.d.ts

@@ -0,0 +1,16 @@
+export type WebFetchFormat = "markdown" | "text" | "html";
+type RedirectResolutionParams = {
+    url: string;
+    format: WebFetchFormat;
+    timeoutSeconds?: number;
+};
+export type RedirectResolutionResult = {
+    type: "resolved";
+    url: string;
+} | {
+    type: "exceeded";
+    url: string;
+    maxRedirects: number;
+};
+export declare function resolveWebFetchRedirects(params: RedirectResolutionParams): Promise<RedirectResolutionResult>;
+export {};