oh-my-opencode 4.7.4 → 4.8.0

package/dist/cli/install-codex/codex-cache-bins.d.ts

@@ -0,0 +1,21 @@
+type LinkPlatform = NodeJS.Platform;
+export declare function linkCachedPluginBins(input: {
+    readonly binDir: string;
+    readonly pluginRoot: string;
+    readonly platform?: LinkPlatform;
+}): Promise<readonly {
+    name: string;
+    path: string;
+    target: string;
+}[]>;
+export declare function linkRootRuntimeBin(input: {
+    readonly binDir: string;
+    readonly codexHome: string;
+    readonly repoRoot: string;
+    readonly platform?: LinkPlatform;
+}): Promise<{
+    readonly name: string;
+    readonly path: string;
+    readonly target: string;
+} | null>;
+export {};

package/dist/cli/install-codex/codex-cache-fs.d.ts

@@ -0,0 +1,3 @@
+export declare function exists(path: string): Promise<boolean>;
+export declare function isNodeErrorWithCode(error: unknown): error is NodeJS.ErrnoException;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/cli/install-codex/codex-cache-install.d.ts

@@ -0,0 +1,13 @@
+import type { InstalledPlugin, RunCommand } from "./types";
+type RenameDirectory = (fromPath: string, toPath: string) => Promise<void>;
+export declare function installCachedPlugin(input: {
+    readonly buildSource?: boolean;
+    readonly codexHome: string;
+    readonly marketplaceName: string;
+    readonly name: string;
+    readonly renameDirectory?: RenameDirectory;
+    readonly sourcePath: string;
+    readonly version: string;
+    readonly runCommand: RunCommand;
+}): Promise<InstalledPlugin>;
+export {};

package/dist/cli/install-codex/codex-cache-mcp-manifest.d.ts

@@ -0,0 +1,2 @@
+export declare function rewriteCachedMcpManifest(pluginRoot: string, sourceRoot?: string): Promise<void>;
+export declare function rewriteCachedManifestRoot(pluginRoot: string, fromRoot: string, toRoot: string): Promise<void>;

package/dist/cli/install-codex/codex-cache-prune.d.ts

@@ -0,0 +1,10 @@
+export declare function pruneMarketplaceCache(input: {
+    readonly codexHome: string;
+    readonly marketplaceName: string;
+    readonly keepPluginNames: readonly string[];
+}): Promise<void>;
+export declare function pruneMarketplacePluginCaches(input: {
+    readonly codexHome: string;
+    readonly marketplaceName: string;
+    readonly pluginNames: readonly string[];
+}): Promise<void>;

package/dist/cli/install-codex/codex-cache.d.ts

@@ -1,32 +1,4 @@
-import type { InstalledPlugin, RunCommand } from "./types";
-type LinkPlatform = NodeJS.Platform;
-export declare function installCachedPlugin(input: {
-    readonly buildSource?: boolean;
-    readonly codexHome: string;
-    readonly marketplaceName: string;
-    readonly name: string;
-    readonly sourcePath: string;
-    readonly version: string;
-    readonly runCommand: RunCommand;
-}): Promise<InstalledPlugin>;
-export declare function pruneMarketplaceCache(input: {
-    readonly codexHome: string;
-    readonly marketplaceName: string;
-    readonly keepPluginNames: readonly string[];
-}): Promise<void>;
-export declare function pruneMarketplacePluginCaches(input: {
-    readonly codexHome: string;
-    readonly marketplaceName: string;
-    readonly pluginNames: readonly string[];
-}): Promise<void>;
-export declare function linkCachedPluginBins(input: {
-    readonly binDir: string;
-    readonly pluginRoot: string;
-    readonly platform?: LinkPlatform;
-}): Promise<readonly {
-    name: string;
-    path: string;
-    target: string;
-}[]>;
-export declare function rewriteCachedMcpManifest(pluginRoot: string, sourceRoot?: string): Promise<void>;
-export {};
+export { linkCachedPluginBins, linkRootRuntimeBin } from "./codex-cache-bins";
+export { installCachedPlugin } from "./codex-cache-install";
+export { rewriteCachedMcpManifest } from "./codex-cache-mcp-manifest";
+export { pruneMarketplaceCache, pruneMarketplacePluginCaches } from "./codex-cache-prune";

package/dist/cli/install-codex/codex-cached-marketplace-manifest.d.ts

@@ -0,0 +1,6 @@
+import type { InstalledPlugin } from "./types";
+export declare function writeCachedMarketplaceManifest(input: {
+    readonly marketplaceName: string;
+    readonly marketplaceRoot: string;
+    readonly plugins: readonly InstalledPlugin[];
+}): Promise<void>;

package/dist/cli/install-codex/codex-config-agents.d.ts

@@ -0,0 +1,3 @@
+import type { CodexAgentConfig } from "./types";
+export declare function removeStaleManagedAgentBlocks(config: string, keepAgentNames: Set<string>): string;
+export declare function ensureAgentConfig(config: string, agentConfig: CodexAgentConfig): string;

package/dist/cli/install-codex/codex-config-features.d.ts

@@ -0,0 +1 @@
+export declare function ensureFeatureEnabled(config: string, featureName: string): string;

package/dist/cli/install-codex/codex-config-marketplaces.d.ts

@@ -0,0 +1,6 @@
+import type { CodexMarketplaceSource } from "./types";
+export declare function legacyMarketplaceNames(marketplaceName: string): readonly string[];
+export declare function removeMarketplaceBlock(config: string, marketplaceName: string): string;
+export declare function removeStaleMarketplacePluginBlocks(config: string, marketplaceName: string, keepPluginNames: Set<string>): string;
+export declare function removeStaleMarketplaceHookStateBlocks(config: string, marketplaceName: string, keepPluginNames: Set<string>): string;
+export declare function ensureMarketplaceBlock(config: string, marketplaceName: string, source: CodexMarketplaceSource): string;

package/dist/cli/install-codex/codex-config-plugins.d.ts

@@ -0,0 +1,8 @@
+import type { CodexInstallPlatform, TrustedHookState } from "./types";
+export declare function ensurePluginEnabled(config: string, pluginKey: string): string;
+export declare function ensureOmoBuiltinMcpPolicies(config: string, input: {
+    readonly marketplaceName: string;
+    readonly pluginNames: readonly string[];
+    readonly platform?: CodexInstallPlatform;
+}): string;
+export declare function ensureHookTrusted(config: string, state: TrustedHookState): string;

package/dist/cli/install-codex/codex-config-toml-sections.d.ts

@@ -0,0 +1,9 @@
+export interface TomlSection {
+    readonly header: string | null;
+    readonly text: string;
+}
+export declare function removeTomlSections(config: string, shouldRemove: (header: string) => boolean): string;
+export declare function splitTomlSections(config: string): readonly TomlSection[];
+export declare function parsePluginHeaderKey(header: string): string | null;
+export declare function parseAgentHeaderName(header: string): string | null;
+export declare function parseJsonString(value: string): string | null;

package/dist/cli/install-codex/codex-process.d.ts

@@ -1,2 +1,7 @@
 import type { RunCommand } from "./types";
+export type RunCommandInvocation = {
+    readonly command: string;
+    readonly args: readonly string[];
+};
+export declare function resolveRunCommandInvocation(command: string, args: readonly string[], platform?: NodeJS.Platform): RunCommandInvocation;
 export declare const defaultRunCommand: RunCommand;

package/dist/cli/install-codex/index.d.ts

@@ -5,7 +5,7 @@ export { runCodexInstaller } from "./install-codex";
 export { detectCodexInstallation, formatCodexInstallationWarning } from "./codex-installation-detection";
 export { cleanupCodexLight, cleanupCodexLightConfigText } from "./codex-cleanup";
 export { readMarketplace, readPluginManifest, resolvePluginSource, validatePathSegment } from "./codex-marketplace";
-export { installCachedPlugin, linkCachedPluginBins, pruneMarketplaceCache, rewriteCachedMcpManifest } from "./codex-cache";
+export { installCachedPlugin, linkCachedPluginBins, linkRootRuntimeBin, pruneMarketplaceCache, rewriteCachedMcpManifest } from "./codex-cache";
 export { updateCodexConfig } from "./codex-config-toml";
 export { trustedHookStatesForPlugin } from "./codex-hook-trust";
 export { defaultRunCommand } from "./codex-process";

package/dist/cli/install-codex/lazycodex-version-stamp.d.ts

@@ -0,0 +1,19 @@
+export interface DistributionManifest {
+    readonly name: string;
+    readonly version: string;
+}
+export declare function readDistributionManifest(repoRoot: string): Promise<DistributionManifest | undefined>;
+export declare function resolveLazyCodexPluginVersion(input: {
+    readonly manifestVersion?: string;
+    readonly marketplaceName: string;
+    readonly pluginName: string;
+    readonly distributionManifest?: DistributionManifest;
+}): string;
+export declare function stampLazyCodexPluginVersion(input: {
+    readonly pluginRoot: string;
+    readonly version: string;
+}): Promise<void>;
+export declare function writeLazyCodexInstallSnapshot(input: {
+    readonly pluginRoot: string;
+    readonly distributionManifest?: DistributionManifest;
+}): Promise<void>;

package/dist/cli/install-codex/link-cached-plugin-agents.d.ts

@@ -4,9 +4,13 @@ export interface LinkedAgent {
     readonly target: string;
 }
 type LinkPlatform = NodeJS.Platform;
+export declare function capturePreservedAgentReasoning(input: {
+    readonly codexHome: string;
+}): Promise<ReadonlyMap<string, string>>;
 export declare function linkCachedPluginAgents(input: {
     readonly codexHome: string;
     readonly pluginRoot: string;
     readonly platform?: LinkPlatform;
+    readonly preservedReasoning?: ReadonlyMap<string, string>;
 }): Promise<readonly LinkedAgent[]>;
 export {};

package/dist/cli/install-validators.d.ts

@@ -30,5 +30,8 @@ export declare function detectedToInitialValues(detected: DetectedConfig): {
     zaiCodingPlan: BooleanArg;
     kimiForCoding: BooleanArg;
     opencodeGo: BooleanArg;
+    bailianCodingPlan: BooleanArg;
+    minimaxCnCodingPlan: BooleanArg;
+    minimaxCodingPlan: BooleanArg;
     vercelAiGateway: BooleanArg;
 };

package/dist/cli/model-fallback-types.d.ts

@@ -10,6 +10,9 @@ export interface ProviderAvailability {
     zai: boolean;
     kimiForCoding: boolean;
     opencodeGo: boolean;
+    bailianCodingPlan: boolean;
+    minimaxCnCodingPlan: boolean;
+    minimaxCodingPlan: boolean;
     vercelAiGateway: boolean;
     isMaxPlan: boolean;
 }

package/dist/cli/run/event-handlers.d.ts

@@ -1,11 +1,4 @@
-import type { RunContext, EventPayload } from "./types";
-import type { EventState } from "./event-state";
-export declare function handleSessionIdle(ctx: RunContext, payload: EventPayload, state: EventState): void;
-export declare function handleSessionStatus(ctx: RunContext, payload: EventPayload, state: EventState): void;
-export declare function handleSessionError(ctx: RunContext, payload: EventPayload, state: EventState): void;
-export declare function handleMessagePartUpdated(ctx: RunContext, payload: EventPayload, state: EventState): void;
-export declare function handleMessagePartDelta(ctx: RunContext, payload: EventPayload, state: EventState): void;
-export declare function handleMessageUpdated(ctx: RunContext, payload: EventPayload, state: EventState): void;
-export declare function handleToolExecute(ctx: RunContext, payload: EventPayload, state: EventState): void;
-export declare function handleToolResult(ctx: RunContext, payload: EventPayload, state: EventState): void;
-export declare function handleTuiToast(_ctx: RunContext, payload: EventPayload, state: EventState): void;
+export { handleSessionError, handleSessionIdle, handleSessionStatus } from "./event-session-handlers";
+export { handleMessagePartDelta, handleMessagePartUpdated, handleMessageUpdated } from "./event-message-handlers";
+export { handleToolExecute, handleToolResult } from "./event-tool-handlers";
+export { handleTuiToast } from "./event-toast-handlers";

package/dist/cli/run/event-message-handlers.d.ts

@@ -0,0 +1,5 @@
+import type { EventState } from "./event-state";
+import type { EventPayload, RunContext } from "./types";
+export declare function handleMessagePartUpdated(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleMessagePartDelta(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleMessageUpdated(ctx: RunContext, payload: EventPayload, state: EventState): void;

package/dist/cli/run/event-session-handlers.d.ts

@@ -0,0 +1,5 @@
+import type { EventState } from "./event-state";
+import type { EventPayload, RunContext } from "./types";
+export declare function handleSessionIdle(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleSessionStatus(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleSessionError(ctx: RunContext, payload: EventPayload, state: EventState): void;

package/dist/cli/run/event-session-ids.d.ts

@@ -0,0 +1,24 @@
+export declare function getSessionId(props?: {
+    sessionID?: string;
+    sessionId?: string;
+}): string | undefined;
+export declare function getInfoSessionId(props?: {
+    info?: {
+        sessionID?: string;
+        sessionId?: string;
+    };
+}): string | undefined;
+export declare function getPartSessionId(props?: {
+    part?: {
+        sessionID?: string;
+        sessionId?: string;
+    };
+}): string | undefined;
+export declare function getPartMessageId(props?: {
+    part?: {
+        messageID?: string;
+    };
+}): string | undefined;
+export declare function getDeltaMessageId(props?: {
+    messageID?: string;
+}): string | undefined;

package/dist/cli/run/event-think-block.d.ts

@@ -0,0 +1,3 @@
+import type { EventState } from "./event-state";
+export declare function ensureThinkBlockOpen(state: EventState): void;
+export declare function closeThinkBlockIfNeeded(state: EventState): void;

package/dist/cli/run/event-toast-handlers.d.ts

@@ -0,0 +1,3 @@
+import type { EventState } from "./event-state";
+import type { EventPayload, RunContext } from "./types";
+export declare function handleTuiToast(_ctx: RunContext, payload: EventPayload, state: EventState): void;

package/dist/cli/run/event-tool-handlers.d.ts

@@ -0,0 +1,4 @@
+import type { EventState } from "./event-state";
+import type { EventPayload, RunContext } from "./types";
+export declare function handleToolExecute(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleToolResult(ctx: RunContext, payload: EventPayload, state: EventState): void;

package/dist/cli/run/event-tool-output.d.ts

@@ -0,0 +1,2 @@
+export declare function writeToolHeader(toolName: string, input: Record<string, unknown>): void;
+export declare function writeToolOutput(output: string): void;

package/dist/cli/run/on-complete-hook.d.ts

@@ -1,7 +1,14 @@
+import { spawnWithWindowsHide } from "../../shared/spawn-with-windows-hide";
+import { log } from "../../shared/logger";
+type OnCompleteHookDeps = {
+    spawnWithWindowsHide: typeof spawnWithWindowsHide;
+    log: typeof log;
+};
 export declare function executeOnCompleteHook(options: {
     command: string;
     sessionId: string;
     exitCode: number;
     durationMs: number;
     messageCount: number;
-}): Promise<void>;
+}, deps?: OnCompleteHookDeps): Promise<void>;
+export {};

package/dist/cli/run/opencode-binary-resolver.d.ts

@@ -1,5 +1,6 @@
+import { spawnWithWindowsHide } from "../../shared/spawn-with-windows-hide";
 export declare function collectCandidateBinaryPaths(pathEnv: string | undefined, which?: (command: string) => string | null | undefined, platform?: NodeJS.Platform): string[];
-export declare function canExecuteBinary(binaryPath: string): Promise<boolean>;
+export declare function canExecuteBinary(binaryPath: string, spawn?: typeof spawnWithWindowsHide): Promise<boolean>;
 export declare function findWorkingOpencodeBinary(pathEnv?: string | undefined, probe?: (binaryPath: string) => Promise<boolean>, which?: (command: string) => string | null | undefined, platform?: NodeJS.Platform): Promise<string | null>;
 export declare function buildPathWithBinaryFirst(pathEnv: string | undefined, binaryPath: string): string;
 export declare function withWorkingOpencodePath<T>(startServer: () => Promise<T>, finder?: (pathEnv: string | undefined) => Promise<string | null>): Promise<T>;

package/dist/cli/runtime-commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function configureRuntimeCommands(program: Command): void;

package/dist/cli/sparkshell-appserver-websocket.d.ts

@@ -0,0 +1,4 @@
+import { type Socket } from "node:net";
+export declare function connectUnixWebSocket(socketPath: string): Promise<Socket>;
+export declare function writeWebSocketText(socket: Socket, payload: string): void;
+export declare function readWebSocketText(socket: Socket): Promise<string>;

package/dist/cli/sparkshell-appserver.d.ts

@@ -0,0 +1,16 @@
+export type RuntimeEnv = Readonly<Record<string, string | undefined>>;
+export type SparkShellAppServerCommand = {
+    readonly argv: readonly string[];
+    readonly cwd: string;
+    readonly env: RuntimeEnv;
+};
+export type SparkShellAppServerResult = {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+};
+export interface SparkShellAppServerClient {
+    getPlatform(): Promise<NodeJS.Platform>;
+    exec(command: SparkShellAppServerCommand): Promise<SparkShellAppServerResult>;
+}
+export declare function createDefaultSparkShellAppServerClient(env: RuntimeEnv): SparkShellAppServerClient | null;

package/dist/cli/sparkshell-parse.d.ts

@@ -0,0 +1,21 @@
+export declare const SPARKSHELL_USAGE: string;
+export type SparkShellFallbackInvocation = {
+    readonly kind: "command";
+    readonly argv: readonly string[];
+} | {
+    readonly kind: "tmux-pane";
+    readonly argv: readonly string[];
+};
+type RuntimeEnv = Readonly<Record<string, string | undefined>>;
+export declare function resolveFallbackShellArgv(script: string, options?: {
+    readonly platform?: NodeJS.Platform;
+    readonly env?: RuntimeEnv;
+    readonly commandExists?: (command: string) => boolean;
+}): readonly string[];
+export declare function parseSparkShellFallbackInvocation(rawArgs: readonly string[], options?: {
+    readonly platform?: NodeJS.Platform;
+    readonly env?: RuntimeEnv;
+    readonly commandExists?: (command: string) => boolean;
+}): SparkShellFallbackInvocation;
+export declare function hasTopLevelSparkShellHelpFlag(args: readonly string[]): boolean;
+export {};

package/dist/cli/sparkshell.d.ts

@@ -0,0 +1,26 @@
+import { type RuntimeEnv, type SparkShellAppServerClient, type SparkShellAppServerCommand, type SparkShellAppServerResult } from "./sparkshell-appserver";
+export declare const SPARKSHELL_BIN_ENV = "OMO_SPARKSHELL_BIN";
+export type { SparkShellAppServerClient, SparkShellAppServerCommand, SparkShellAppServerResult };
+export { parseSparkShellFallbackInvocation, resolveFallbackShellArgv, SPARKSHELL_USAGE, } from "./sparkshell-parse";
+export type SparkShellSpawnResult = {
+    readonly status?: number | null;
+    readonly signal?: string | null;
+    readonly stdout?: string;
+    readonly stderr?: string;
+    readonly error?: Error;
+};
+export type SparkShellSpawn = (command: string, args: readonly string[], options: {
+    readonly cwd: string;
+    readonly env: RuntimeEnv;
+}) => SparkShellSpawnResult;
+export type SparkShellRunOptions = {
+    readonly cwd?: string;
+    readonly env?: RuntimeEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly spawn?: SparkShellSpawn;
+    readonly writeStdout?: (value: string) => void;
+    readonly writeStderr?: (value: string) => void;
+    readonly commandExists?: (command: string) => boolean;
+    readonly appServerClient?: SparkShellAppServerClient | null;
+};
+export declare function runSparkShell(args: readonly string[], options?: SparkShellRunOptions): Promise<number>;

package/dist/cli/types.d.ts

@@ -12,6 +12,9 @@ export interface InstallArgs {
     zaiCodingPlan?: BooleanArg;
     kimiForCoding?: BooleanArg;
     opencodeGo?: BooleanArg;
+    bailianCodingPlan?: BooleanArg;
+    minimaxCnCodingPlan?: BooleanArg;
+    minimaxCodingPlan?: BooleanArg;
     vercelAiGateway?: BooleanArg;
     codexAutonomous?: boolean;
     skipAuth?: boolean;
@@ -29,6 +32,9 @@ export interface InstallConfig {
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;
     hasOpencodeGo: boolean;
+    hasBailianCodingPlan: boolean;
+    hasMinimaxCnCodingPlan: boolean;
+    hasMinimaxCodingPlan: boolean;
     hasVercelAiGateway: boolean;
     codexAutonomous: boolean;
 }
@@ -50,5 +56,8 @@ export interface DetectedConfig {
     hasZaiCodingPlan: boolean;
     hasKimiForCoding: boolean;
     hasOpencodeGo: boolean;
+    hasBailianCodingPlan: boolean;
+    hasMinimaxCnCodingPlan: boolean;
+    hasMinimaxCodingPlan: boolean;
     hasVercelAiGateway: boolean;
 }

package/dist/config/schema/claude-code.d.ts

@@ -7,5 +7,6 @@ export declare const ClaudeCodeConfigSchema: z.ZodObject<{
     hooks: z.ZodOptional<z.ZodBoolean>;
     plugins: z.ZodOptional<z.ZodBoolean>;
     plugins_override: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    anthropic_provider: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ClaudeCodeConfig = z.infer<typeof ClaudeCodeConfigSchema>;

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

@@ -39,6 +39,7 @@ export declare const HookNameSchema: z.ZodEnum<{
     "team-tool-gating": "team-tool-gating";
     "no-sisyphus-gpt": "no-sisyphus-gpt";
     "no-hephaestus-non-gpt": "no-hephaestus-non-gpt";
+    "hephaestus-agents-md-injector": "hephaestus-agents-md-injector";
     "unstable-agent-babysitter": "unstable-agent-babysitter";
     "task-resume-info": "task-resume-info";
     "stop-continuation-guard": "stop-continuation-guard";

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

@@ -2105,6 +2105,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         hooks: z.ZodOptional<z.ZodBoolean>;
         plugins: z.ZodOptional<z.ZodBoolean>;
         plugins_override: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        anthropic_provider: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     sisyphus_agent: z.ZodOptional<z.ZodObject<{
         disabled: z.ZodOptional<z.ZodBoolean>;

package/dist/create-hooks.d.ts

@@ -82,6 +82,7 @@ export declare function createHooks(args: {
     sisyphusJuniorNotepad: ReturnType<typeof import("./hooks").createSisyphusJuniorNotepadHook> | null;
     noSisyphusGpt: ReturnType<typeof import("./hooks").createNoSisyphusGptHook> | null;
     noHephaestusNonGpt: ReturnType<typeof import("./hooks").createNoHephaestusNonGptHook> | null;
+    hephaestusAgentsMdInjector: ReturnType<typeof import("./hooks").createHephaestusAgentsMdInjectorHook> | null;
     questionLabelTruncator: ReturnType<typeof import("./hooks").createQuestionLabelTruncatorHook> | null;
     taskResumeInfo: ReturnType<typeof import("./hooks").createTaskResumeInfoHook> | null;
     anthropicEffort: ReturnType<typeof import("./hooks/anthropic-effort").createAnthropicEffortHook> | null;

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

@@ -6,8 +6,13 @@ export declare class ConcurrencyManager {
     constructor(config?: BackgroundTaskConfig);
     getConcurrencyLimit(model: string): number;
     getConcurrencyKey(model: string): string;
-    acquire(model: string): Promise<void>;
+    acquire(model: string, taskId?: string): Promise<void>;
     release(model: string): void;
+    /**
+     * Cancel a specific task's waiter in the queue for a model.
+     * Returns true if a matching waiter was found and cancelled.
+     */
+    cancelWaiter(model: string, taskId: string): boolean;
     /**
      * Cancel all waiting acquires for a model. Used during cleanup.
      */

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

@@ -40,6 +40,7 @@ export interface Todo {
 }
 export interface QueueItem {
     attemptID: string;
+    rawConcurrencyKey?: string;
     task: BackgroundTask;
     input: LaunchInput;
 }

package/dist/features/background-agent/empty-assistant-turn.d.ts

@@ -0,0 +1,7 @@
+type AssistantTurnInfo = {
+    readonly role?: unknown;
+    readonly finish?: unknown;
+    readonly tokens?: unknown;
+};
+export declare function isEmptyNoProgressAssistantTurnInfo(info: unknown): info is AssistantTurnInfo;
+export {};

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

@@ -10,6 +10,9 @@ interface EventProperties {
     info?: {
         id?: string;
         sessionID?: string;
+        role?: unknown;
+        error?: unknown;
+        [key: string]: unknown;
     };
     [key: string]: unknown;
 }
@@ -57,6 +60,7 @@ export declare class BackgroundManager {
     private idleDeferralTimers;
     private notificationQueueByParent;
     private readonly parentWakeNotifier;
+    private parentWakeTextDeltaBuffers;
     private observedOutputSessions;
     private observedIncompleteTodosBySession;
     private rootDescendantCounts;
@@ -93,11 +97,15 @@ export declare class BackgroundManager {
     private startTask;
     getTask(id: string): BackgroundTask | undefined;
     getTasksByParentSession(sessionID: string): BackgroundTask[];
+    /** Return whether a session has direct child background tasks still in flight. */
+    hasActiveChildTasks(sessionID: string): boolean;
     private updateBackgroundTaskMarker;
     getAllDescendantTasks(sessionID: string): BackgroundTask[];
     findBySession(sessionID: string): BackgroundTask | undefined;
     private resolveTaskAttemptBySession;
     private getConcurrencyKeyFromInput;
+    private getRawConcurrencyKeyFromInput;
+    private getRawConcurrencyKeyFromTask;
     /**
      * Track a task created elsewhere (e.g., from task) for notification tracking.
      * This allows tasks created by other tools to receive the same toast/prompt notifications.
@@ -118,6 +126,10 @@ export declare class BackgroundManager {
     private requeueDispatchedParentWake;
     private clearSessionOutputObserved;
     private clearSessionTodoObservation;
+    private messageUpdatedInfoHasParentWakeOutput;
+    private shouldHoldDispatchedParentWakeForTextDelta;
+    private parentWakeTextDeltaBufferKey;
+    private clearParentWakeTextDeltaBuffers;
     handleEvent(event: Event): void;
     private interruptTaskFromAsyncPromptFailure;
     private handleSessionErrorEvent;

package/dist/features/background-agent/message-updated-parent-wake-output.d.ts

@@ -0,0 +1 @@
+export declare function messageUpdatedInfoHasParentWakeOutput(info: Record<string, unknown>, role: unknown): boolean;

package/dist/features/background-agent/parent-wake-dedupe.d.ts

@@ -13,7 +13,9 @@ export type PendingParentWake = {
     shouldReply: boolean;
     dispatchedAt?: number;
     toolCallDeferralStartedAt?: number;
+    allowEmptyAssistantTurnRetry?: boolean;
 };
 export declare function resolveParentWakePromptContext(promptContext: ParentWakePromptContext): ParentWakePromptContext;
 export declare function cloneParentWake(wake: PendingParentWake): PendingParentWake;
 export declare function isRedundantParentWake(latestWake: PendingParentWake, dispatchedWake: PendingParentWake): boolean;
+export declare function mergeParentWakeNotifications(existingNotifications: readonly string[], nextNotification: string): string[];

package/dist/features/background-agent/parent-wake-dispatched-tracker.d.ts

@@ -0,0 +1,21 @@
+import { type PendingParentWake } from "./parent-wake-dedupe";
+type ParentWakeDispatchedTrackerOptions = {
+    readonly failureRequeueWindowMs: number;
+    readonly onFailureRequeueWindowElapsed: (sessionID: string, wake: PendingParentWake) => void;
+};
+export declare class ParentWakeDispatchedTracker {
+    private readonly options;
+    private dispatchedParentWakes;
+    private dispatchedParentWakeTimers;
+    constructor(options: ParentWakeDispatchedTrackerOptions);
+    getWakes(): Map<string, PendingParentWake>;
+    getTimers(): Map<string, ReturnType<typeof setTimeout>>;
+    getWake(sessionID: string): PendingParentWake | undefined;
+    hasWake(sessionID: string): boolean;
+    clearWake(sessionID: string): void;
+    trackWake(sessionID: string, wake: PendingParentWake, dispatchedAt: number): void;
+    refreshWakeTimer(sessionID: string): void;
+    private scheduleFailureWindowTimer;
+    shutdown(): void;
+}
+export {};

package/dist/features/background-agent/parent-wake-flush-runner.d.ts

@@ -0,0 +1,24 @@
+import type { ParentWakeDispatchedTracker } from "./parent-wake-dispatched-tracker";
+import type { ParentWakePendingQueue } from "./parent-wake-pending-queue";
+import type { ParentWakeSessionInspector } from "./parent-wake-session-inspector";
+import type { ParentWakeNotifierDeps } from "./parent-wake-notifier-types";
+type ParentWakeFlushRunnerDeps = {
+    readonly notifierDeps: ParentWakeNotifierDeps;
+    readonly pendingQueue: ParentWakePendingQueue;
+    readonly dispatchedTracker: ParentWakeDispatchedTracker;
+    readonly sessionInspector: ParentWakeSessionInspector;
+};
+export declare class ParentWakeFlushRunner {
+    private readonly deps;
+    constructor(deps: ParentWakeFlushRunnerDeps);
+    flushPendingParentWake(sessionID: string): Promise<void>;
+    schedulePendingParentWakeFlush(sessionID: string, delayMs?: number): void;
+    clearPendingParentWakeTimer(sessionID: string): void;
+    private sendParentWakePrompt;
+    private isSessionActive;
+    private hasRecentParentSessionActivity;
+    private isUserMessageInProgress;
+    private shouldDeferParentWakeForSessionHistory;
+    private requeueWake;
+}
+export {};

package/dist/features/background-agent/parent-wake-history-state.d.ts

@@ -0,0 +1,5 @@
+import type { PendingParentWake } from "./parent-wake-dedupe";
+export declare function latestAssistantTurnIsCompletedEmptyNoProgress(messages: readonly unknown[]): boolean;
+export declare function latestAssistantTurnHasToolBlock(messages: readonly unknown[]): boolean;
+export declare function latestAssistantTurnHasFreshToolActivity(messages: readonly unknown[], now: number, maxAgeMs: number): boolean;
+export declare function createEmptyAssistantTurnRetryDedupeKey(wake: PendingParentWake): string;