oh-my-opencode 3.5.3 → 3.5.4

package/dist/cli/run/runner.d.ts

@@ -1,4 +1,5 @@
 import type { RunOptions } from "./types";
 import { resolveRunAgent } from "./agent-resolver";
 export { resolveRunAgent };
+export declare function waitForEventProcessorShutdown(eventProcessor: Promise<void>, timeoutMs?: number): Promise<void>;
 export declare function run(options: RunOptions): Promise<number>;

package/dist/config/schema/background-task.d.ts

@@ -4,5 +4,6 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;

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

@@ -15,7 +15,6 @@ export declare const HookNameSchema: z.ZodEnum<{
     "directory-readme-injector": "directory-readme-injector";
     "empty-task-response-detector": "empty-task-response-detector";
     "think-mode": "think-mode";
-    "subagent-question-blocker": "subagent-question-blocker";
     "anthropic-context-window-limit-recovery": "anthropic-context-window-limit-recovery";
     "preemptive-compaction": "preemptive-compaction";
     "rules-injector": "rules-injector";

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

@@ -39,7 +39,6 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         "directory-readme-injector": "directory-readme-injector";
         "empty-task-response-detector": "empty-task-response-detector";
         "think-mode": "think-mode";
-        "subagent-question-blocker": "subagent-question-blocker";
         "anthropic-context-window-limit-recovery": "anthropic-context-window-limit-recovery";
         "preemptive-compaction": "preemptive-compaction";
         "rules-injector": "rules-injector";
@@ -1214,7 +1213,15 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         safe_hook_creation: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     auto_update: z.ZodOptional<z.ZodBoolean>;
-    skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        sources: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            path: z.ZodString;
+            recursive: z.ZodOptional<z.ZodBoolean>;
+            glob: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>>;
+        enable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$catchall<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         template: z.ZodOptional<z.ZodString>;
         from: z.ZodOptional<z.ZodString>;
@@ -1227,15 +1234,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
         disable: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>]>>, z.ZodObject<{
-        sources: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            path: z.ZodString;
-            recursive: z.ZodOptional<z.ZodBoolean>;
-            glob: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>]>>>>;
-        enable: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        disable: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>>]>>;
+    }, z.core.$strip>]>>>]>>;
     ralph_loop: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         default_max_iterations: z.ZodDefault<z.ZodNumber>;
@@ -1246,6 +1245,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     notification: z.ZodOptional<z.ZodObject<{
         force_enable: z.ZodOptional<z.ZodBoolean>;

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

@@ -32,7 +32,15 @@ export declare const SkillEntrySchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodO
     "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
     disable: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>]>;
-export declare const SkillsConfigSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+export declare const SkillsConfigSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+    sources: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+        glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    enable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     template: z.ZodOptional<z.ZodString>;
     from: z.ZodOptional<z.ZodString>;
@@ -45,14 +53,6 @@ export declare const SkillsConfigSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodSt
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
     disable: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>]>>, z.ZodObject<{
-    sources: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        path: z.ZodString;
-        recursive: z.ZodOptional<z.ZodBoolean>;
-        glob: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>]>>>>;
-    enable: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    disable: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-}, z.core.$strip>>]>;
+}, z.core.$strip>]>>>]>;
 export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
 export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;

package/dist/create-hooks.d.ts

@@ -51,7 +51,6 @@ export declare function createHooks(args: {
     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/features/background-agent/constants.d.ts

@@ -3,6 +3,7 @@ import type { BackgroundTask, LaunchInput } from "./types";
 export declare const TASK_TTL_MS: number;
 export declare const MIN_STABILITY_TIME_MS: number;
 export declare const DEFAULT_STALE_TIMEOUT_MS = 180000;
+export declare const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 600000;
 export declare const MIN_RUNTIME_BEFORE_STALE_MS = 30000;
 export declare const MIN_IDLE_TIME_MS = 5000;
 export declare const POLLING_INTERVAL_MS = 3000;

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

@@ -1,4 +1,5 @@
 export * from "./types";
 export { BackgroundManager, type SubagentSessionCreatedEvent, type OnSubagentSessionCreated } from "./manager";
+export { TaskHistory, type TaskHistoryEntry } from "./task-history";
 export { ConcurrencyManager } from "./concurrency";
 export { TaskStateManager } from "./state";

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

@@ -1,5 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { BackgroundTask, LaunchInput, ResumeInput } from "./types";
+import { TaskHistory } from "./task-history";
 import type { BackgroundTaskConfig, TmuxConfig } from "../../config/schema";
 interface EventProperties {
     sessionID?: string;
@@ -39,6 +40,7 @@ export declare class BackgroundManager {
     private completionTimers;
     private idleDeferralTimers;
     private notificationQueueByParent;
+    readonly taskHistory: TaskHistory;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig, options?: {
         tmuxConfig?: TmuxConfig;
         onSubagentSessionCreated?: OnSubagentSessionCreated;

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

@@ -4,7 +4,9 @@ export declare function pollRunningTasks(args: {
     tasks: Iterable<BackgroundTask>;
     client: OpencodeClient;
     pruneStaleTasksAndNotifications: () => void;
-    checkAndInterruptStaleTasks: () => Promise<void>;
+    checkAndInterruptStaleTasks: (statuses: Record<string, {
+        type: string;
+    }>) => Promise<void>;
     validateSessionHasOutput: (sessionID: string) => Promise<boolean>;
     checkSessionTodos: (sessionID: string) => Promise<boolean>;
     tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>;

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

@@ -0,0 +1,18 @@
+import type { BackgroundTaskStatus } from "./types";
+export interface TaskHistoryEntry {
+    id: string;
+    sessionID?: string;
+    agent: string;
+    description: string;
+    status: BackgroundTaskStatus;
+    category?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+export declare class TaskHistory {
+    private entries;
+    record(parentSessionID: string | undefined, entry: TaskHistoryEntry): void;
+    getByParentSession(parentSessionID: string): TaskHistoryEntry[];
+    clearSession(parentSessionID: string): void;
+    formatForCompaction(parentSessionID: string): string | null;
+}

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

@@ -7,10 +7,14 @@ export declare function pruneStaleTasksAndNotifications(args: {
     notifications: Map<string, BackgroundTask[]>;
     onTaskPruned: (taskId: string, task: BackgroundTask, errorMessage: string) => void;
 }): void;
+export type SessionStatusMap = Record<string, {
+    type: string;
+}>;
 export declare function checkAndInterruptStaleTasks(args: {
     tasks: Iterable<BackgroundTask>;
     client: OpencodeClient;
     config: BackgroundTaskConfig | undefined;
     concurrencyManager: ConcurrencyManager;
     notifyParentSession: (task: BackgroundTask) => Promise<void>;
+    sessionStatuses?: SessionStatusMap;
 }): Promise<void>;

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

@@ -36,6 +36,8 @@ export interface BackgroundTask {
     concurrencyGroup?: string;
     /** Parent session's agent name for notification */
     parentAgent?: string;
+    /** Parent session's tool restrictions for notification prompts */
+    parentTools?: Record<string, boolean>;
     /** Marks if the task was launched from an unstable agent/category */
     isUnstableAgent?: boolean;
     /** Category used for this task (e.g., 'quick', 'visual-engineering') */
@@ -56,6 +58,7 @@ export interface LaunchInput {
         modelID: string;
     };
     parentAgent?: string;
+    parentTools?: Record<string, boolean>;
     model?: {
         providerID: string;
         modelID: string;
@@ -76,4 +79,5 @@ export interface ResumeInput {
         modelID: string;
     };
     parentAgent?: string;
+    parentTools?: Record<string, boolean>;
 }

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

@@ -1,3 +1,3 @@
 import type { AgentConfig } from "@opencode-ai/sdk";
 export declare function loadUserAgents(): Record<string, AgentConfig>;
-export declare function loadProjectAgents(): Record<string, AgentConfig>;
+export declare function loadProjectAgents(directory?: string): Record<string, AgentConfig>;

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

@@ -1,6 +1,6 @@
 import type { CommandDefinition } from "./types";
 export declare function loadUserCommands(): Promise<Record<string, CommandDefinition>>;
-export declare function loadProjectCommands(): Promise<Record<string, CommandDefinition>>;
+export declare function loadProjectCommands(directory?: string): Promise<Record<string, CommandDefinition>>;
 export declare function loadOpencodeGlobalCommands(): Promise<Record<string, CommandDefinition>>;
-export declare function loadOpencodeProjectCommands(): Promise<Record<string, CommandDefinition>>;
-export declare function loadAllCommands(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeProjectCommands(directory?: string): Promise<Record<string, CommandDefinition>>;
+export declare function loadAllCommands(directory?: string): Promise<Record<string, CommandDefinition>>;

package/dist/features/opencode-skill-loader/config-source-discovery.d.ts

@@ -0,0 +1,7 @@
+import type { SkillsConfig } from "../../config/schema";
+import type { LoadedSkill } from "./types";
+export declare function normalizePathForGlob(path: string): string;
+export declare function discoverConfigSourceSkills(options: {
+    config: SkillsConfig | undefined;
+    configDir: string;
+}): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/index.d.ts

@@ -12,3 +12,4 @@ export * from "./skill-discovery";
 export * from "./skill-resolution-options";
 export * from "./loaded-skill-template-extractor";
 export * from "./skill-template-resolver";
+export * from "./config-source-discovery";

package/dist/features/opencode-skill-loader/loader.d.ts

@@ -1,16 +1,19 @@
 import type { CommandDefinition } from "../claude-code-command-loader/types";
 import type { LoadedSkill } from "./types";
 export declare function loadUserSkills(): Promise<Record<string, CommandDefinition>>;
-export declare function loadProjectSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadProjectSkills(directory?: string): Promise<Record<string, CommandDefinition>>;
 export declare function loadOpencodeGlobalSkills(): Promise<Record<string, CommandDefinition>>;
-export declare function loadOpencodeProjectSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeProjectSkills(directory?: string): Promise<Record<string, CommandDefinition>>;
 export interface DiscoverSkillsOptions {
     includeClaudeCodePaths?: boolean;
+    directory?: string;
 }
-export declare function discoverAllSkills(): Promise<LoadedSkill[]>;
+export declare function discoverAllSkills(directory?: string): Promise<LoadedSkill[]>;
 export declare function discoverSkills(options?: DiscoverSkillsOptions): Promise<LoadedSkill[]>;
 export declare function getSkillByName(name: string, options?: DiscoverSkillsOptions): Promise<LoadedSkill | undefined>;
 export declare function discoverUserClaudeSkills(): Promise<LoadedSkill[]>;
-export declare function discoverProjectClaudeSkills(): Promise<LoadedSkill[]>;
+export declare function discoverProjectClaudeSkills(directory?: string): Promise<LoadedSkill[]>;
 export declare function discoverOpencodeGlobalSkills(): Promise<LoadedSkill[]>;
-export declare function discoverOpencodeProjectSkills(): Promise<LoadedSkill[]>;
+export declare function discoverOpencodeProjectSkills(directory?: string): Promise<LoadedSkill[]>;
+export declare function discoverProjectAgentsSkills(directory?: string): Promise<LoadedSkill[]>;
+export declare function discoverGlobalAgentsSkills(): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/merger.d.ts

@@ -4,4 +4,4 @@ import type { BuiltinSkill } from "../builtin-skills/types";
 export interface MergeSkillsOptions {
     configDir?: string;
 }
-export declare function mergeSkills(builtinSkills: BuiltinSkill[], config: SkillsConfig | undefined, userClaudeSkills: LoadedSkill[], userOpencodeSkills: LoadedSkill[], projectClaudeSkills: LoadedSkill[], projectOpencodeSkills: LoadedSkill[], options?: MergeSkillsOptions): LoadedSkill[];
+export declare function mergeSkills(builtinSkills: BuiltinSkill[], config: SkillsConfig | undefined, configSourceSkills: LoadedSkill[], userClaudeSkills: LoadedSkill[], userOpencodeSkills: LoadedSkill[], projectClaudeSkills: LoadedSkill[], projectOpencodeSkills: LoadedSkill[], options?: MergeSkillsOptions): LoadedSkill[];

package/dist/features/opencode-skill-loader/skill-resolution-options.d.ts

@@ -3,4 +3,6 @@ export interface SkillResolutionOptions {
     gitMasterConfig?: GitMasterConfig;
     browserProvider?: BrowserAutomationProvider;
     disabledSkills?: Set<string>;
+    /** Project directory to discover project-level skills from. Falls back to process.cwd() if not provided. */
+    directory?: string;
 }

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

@@ -14,6 +14,6 @@ export interface GridPlan {
     slotWidth: number;
     slotHeight: number;
 }
-export declare function calculateCapacity(windowWidth: number, windowHeight: number): GridCapacity;
+export declare function calculateCapacity(windowWidth: number, windowHeight: number, minPaneWidth?: number): GridCapacity;
 export declare function computeGridPlan(windowWidth: number, windowHeight: number, paneCount: number): GridPlan;
 export declare function mapPaneToSlot(pane: TmuxPaneInfo, plan: GridPlan, mainPaneWidth: number): GridSlot;

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

@@ -1,8 +1,8 @@
 import type { SplitDirection, TmuxPaneInfo } from "./types";
 export declare function getColumnCount(paneCount: number): number;
 export declare function getColumnWidth(agentAreaWidth: number, paneCount: number): number;
-export declare function isSplittableAtCount(agentAreaWidth: number, paneCount: number): boolean;
-export declare function findMinimalEvictions(agentAreaWidth: number, currentCount: number): number | null;
-export declare function canSplitPane(pane: TmuxPaneInfo, direction: SplitDirection): boolean;
+export declare function isSplittableAtCount(agentAreaWidth: number, paneCount: number, minPaneWidth?: number): boolean;
+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): boolean;
 export declare function getBestSplitDirection(pane: TmuxPaneInfo): SplitDirection | null;

package/dist/features/tmux-subagent/spawn-action-decider.d.ts

@@ -1,4 +1,4 @@
 import type { CapacityConfig, PaneAction, SpawnDecision, WindowState } from "./types";
 import { type SessionMapping } from "./oldest-agent-pane";
-export declare function decideSpawnActions(state: WindowState, sessionId: string, description: string, _config: CapacityConfig, sessionMappings: SessionMapping[]): SpawnDecision;
+export declare function decideSpawnActions(state: WindowState, sessionId: string, description: string, config: CapacityConfig, sessionMappings: SessionMapping[]): SpawnDecision;
 export declare function decideCloseAction(state: WindowState, sessionId: string, sessionMappings: SessionMapping[]): PaneAction | null;

package/dist/hooks/claude-code-hooks/transcript.d.ts

@@ -2,17 +2,14 @@ import type { TranscriptEntry } from "./types";
 export declare function getTranscriptPath(sessionId: string): string;
 export declare function appendTranscriptEntry(sessionId: string, entry: TranscriptEntry): void;
 /**
- * Build Claude Code compatible transcript from session messages
- *
- * PORT FROM DISABLED: This calls client.session.messages() API to fetch
- * the full session history and builds a JSONL file in Claude Code format.
- *
- * @param client OpenCode client instance
- * @param sessionId Session ID
- * @param directory Working directory
- * @param currentToolName Current tool being executed (added as last entry)
- * @param currentToolInput Current tool input
- * @returns Temp file path (caller must call deleteTempTranscript!)
+ * Clear transcript cache for a specific session or all sessions.
+ * Call on session.deleted to prevent memory accumulation.
+ */
+export declare function clearTranscriptCache(sessionId?: string): void;
+/**
+ * Build Claude Code compatible transcript from session messages.
+ * Uses per-session cache to avoid redundant session.messages() API calls.
+ * First call fetches and caches; subsequent calls reuse cached base entries.
  */
 export declare function buildTranscriptFromSession(client: {
     session: {
@@ -28,7 +25,5 @@ export declare function buildTranscriptFromSession(client: {
 }, sessionId: string, directory: string, currentToolName: string, currentToolInput: Record<string, unknown>): Promise<string | null>;
 /**
  * Delete temp transcript file (call in finally block)
- *
- * PORT FROM DISABLED: Cleanup mechanism to avoid disk accumulation
  */
 export declare function deleteTempTranscript(path: string | null): void;

package/dist/hooks/compaction-context-injector/hook.d.ts

@@ -1 +1,2 @@
-export declare function createCompactionContextInjector(): () => string;
+import type { BackgroundManager } from "../../features/background-agent";
+export declare function createCompactionContextInjector(backgroundManager?: BackgroundManager): (sessionID?: string) => string;

package/dist/hooks/index.d.ts

@@ -33,7 +33,6 @@ export { createStartWorkHook } from "./start-work";
 export { createAtlasHook } from "./atlas";
 export { createDelegateTaskRetryHook } from "./delegate-task-retry";
 export { createQuestionLabelTruncatorHook } from "./question-label-truncator";
-export { createSubagentQuestionBlockerHook } from "./subagent-question-blocker";
 export { createStopContinuationGuardHook, type StopContinuationGuard } from "./stop-continuation-guard";
 export { createCompactionContextInjector } from "./compaction-context-injector";
 export { createCompactionTodoPreserverHook } from "./compaction-todo-preserver";

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

@@ -6,16 +6,13 @@
  * 2. GPT 5.2 models → gpt5.2.ts
  * 3. Everything else (Claude, etc.) → default.ts
  */
+import { isGptModel } from "../../../agents/types";
 /**
  * Checks if agent is a planner-type agent.
  * Planners don't need ultrawork injection (they ARE the planner).
  */
 export declare function isPlannerAgent(agentName?: string): boolean;
-/**
- * Checks if model is GPT 5.2 series.
- * GPT models benefit from specific prompting patterns.
- */
-export declare function isGptModel(modelID?: string): boolean;
+export { isGptModel };
 /** Ultrawork message source type */
 export type UltraworkSource = "planner" | "gpt" | "default";
 /**

package/dist/hooks/think-mode/switcher.d.ts

@@ -56,8 +56,7 @@ export declare const THINKING_CONFIGS: {
             readonly "zai-coding-plan": {
                 readonly extra_body: {
                     readonly thinking: {
-                        readonly type: "enabled";
-                        readonly clear_thinking: false;
+                        readonly type: "disabled";
                     };
                 };
             };

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

@@ -5,3 +5,4 @@ export declare const COUNTDOWN_SECONDS = 2;
 export declare const TOAST_DURATION_MS = 900;
 export declare const COUNTDOWN_GRACE_PERIOD_MS = 500;
 export declare const ABORT_WINDOW_MS = 3000;
+export declare const CONTINUATION_COOLDOWN_MS = 30000;

package/dist/hooks/todo-continuation-enforcer/session-state.d.ts

@@ -5,5 +5,6 @@ export interface SessionStateStore {
     cancelCountdown: (sessionID: string) => void;
     cleanup: (sessionID: string) => void;
     cancelAllCountdowns: () => void;
+    shutdown: () => void;
 }
 export declare function createSessionStateStore(): SessionStateStore;

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

@@ -28,6 +28,8 @@ export interface SessionState {
     isRecovering?: boolean;
     countdownStartedAt?: number;
     abortDetectedAt?: number;
+    lastInjectedAt?: number;
+    inFlight?: boolean;
 }
 export interface MessageInfo {
     id?: string;