jeopi-cli 16.2.13 → 16.2.14

package/dist/types/task/executor.d.ts

@@ -1,214 +0,0 @@
-/**
- * In-process execution for subagents.
- *
- * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
- */
-import type { AgentTelemetryConfig, ThinkingLevel } from "jeopi-agent-core";
-import type { ServiceTierByFamily } from "jeopi-ai";
-import type { Rule } from "../capability/rule";
-import { ModelRegistry } from "../config/model-registry";
-import type { PromptTemplate } from "../config/prompt-templates";
-import { Settings } from "../config/settings";
-import { type SettingPath } from "../config/settings-schema";
-import type { ToolPathWithSource } from "../extensibility/custom-tools";
-import type { CustomTool } from "../extensibility/custom-tools/types";
-import { type Skill } from "../extensibility/skills";
-import type { HindsightSessionState } from "../hindsight/state";
-import type { LocalProtocolOptions } from "../internal-urls";
-import type { MCPManager } from "../mcp/manager";
-import type { MnemopiSessionState } from "../mnemopi/state";
-import type { AgentSession } from "../session/agent-session";
-import type { ArtifactManager } from "../session/artifacts";
-import type { AuthStorage } from "../session/auth-storage";
-import type { ContextFileEntry } from "../tools";
-import type { EventBus } from "../utils/event-bus";
-import type { WorkspaceTree } from "../workspace-tree";
-import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult, type YieldItem } from "./types";
-export type { YieldItem } from "./types";
-/**
- * Soft per-agent request budgets (assistant requests per run). When a subagent
- * crosses its budget it can receive an optional steering notice asking it to
- * wrap up; at 1.5x the budget the run is aborted gracefully so partial output is
- * salvaged. The `default` key applies to agents without an explicit entry and
- * can be overridden via the `task.softRequestBudget` setting (0 disables the
- * guard). The notice is off by default and controlled separately by
- * `task.softRequestBudgetNotice`.
- */
-export declare const SOFT_REQUEST_BUDGET: Record<string, number>;
-/** Optional steering notice injected when a subagent crosses its soft request budget. */
-export declare function buildBudgetNotice(requests: number): string;
-/** Options for subagent execution */
-export interface ExecutorOptions {
-    cwd: string;
-    worktree?: string;
-    agent: AgentDefinition;
-    task: string;
-    assignment?: string;
-    /** Shared background from the task call (`task.batch`), rendered into the subagent's system prompt. */
-    context?: string;
-    /**
-     * The session's active overall plan, handed off so subagents spawned during
-     * plan execution share the same plan context as the main agent. Omitted when
-     * the session did not start with a plan (or while plan mode is still active).
-     */
-    planReference?: {
-        path: string;
-        content: string;
-    };
-    description?: string;
-    /** Specialist role/expertise for this spawn; drives the system-prompt preamble, display name, and telemetry identity. */
-    role?: string;
-    index: number;
-    id: string;
-    parentToolCallId?: string;
-    /**
-     * Spawn runs as a detached background job (parent turn not blocked on it).
-     * Rides the subagent lifecycle/progress payloads so HUD-style surfaces can
-     * skip spawns the transcript already renders inline. See
-     * {@link SubagentLifecyclePayload.detached}.
-     */
-    detached?: boolean;
-    modelOverride?: string | string[];
-    /**
-     * Active model selector of the parent session, used as an auth-aware fallback
-     * if the resolved subagent model has no working credentials. See #985.
-     */
-    parentActiveModelPattern?: string;
-    thinkingLevel?: ThinkingLevel;
-    outputSchema?: unknown;
-    /**
-     * Caller supplied a schema that supersedes the agent's native output prompt.
-     * Eval `agent(..., schema=...)` sets this so built-in agents ignore stale yield labels.
-     */
-    outputSchemaOverridesAgent?: boolean;
-    /** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */
-    taskDepth?: number;
-    /**
-     * Override the `task.maxRuntimeMs` wall-clock cap for this run. When provided
-     * it wins over the settings value; `0` disables the per-subagent wall-clock
-     * limit entirely. Used by the eval `agent()` bridge, whose parent cell
-     * watchdog is already suspended for the call's duration.
-     */
-    maxRuntimeMs?: number;
-    enableLsp?: boolean;
-    signal?: AbortSignal;
-    onProgress?: (progress: AgentProgress) => void;
-    /**
-     * Epochs (ms, `Date.now()`) bracketing the concurrency-semaphore wait:
-     * `invokedAt` is stamped at the spawn boundary before `acquire()`,
-     * `acquiredAt` immediately after. {@link runSubprocess} reports true queue
-     * wait (`acquiredAt - invokedAt`) and pre-run setup (`startTime - acquiredAt`)
-     * separately in the launch-timing debug log. Undefined for callers that
-     * bypass the semaphore path.
-     */
-    invokedAt?: number;
-    acquiredAt?: number;
-    sessionFile?: string | null;
-    persistArtifacts?: boolean;
-    artifactsDir?: string;
-    eventBus?: EventBus;
-    contextFiles?: ContextFileEntry[];
-    skills?: Skill[];
-    promptTemplates?: PromptTemplate[];
-    workspaceTree?: WorkspaceTree;
-    /** Parent-discovered rules, forwarded to skip rule discovery in the subagent. */
-    rules?: Rule[];
-    /**
-     * Parent's discovered extension source paths. Forwarded to skip the
-     * extension FS scan in the subagent; the subagent then re-binds each
-     * extension against its own `ExtensionAPI` (cwd, eventBus, runtime).
-     */
-    preloadedExtensionPaths?: string[];
-    /**
-     * Parent's discovered custom-tool source paths. Forwarded to skip the
-     * `.omp/tools/` FS scan in the subagent; the subagent then re-binds each
-     * tool against its own `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
-     */
-    preloadedCustomToolPaths?: ToolPathWithSource[];
-    mcpManager?: MCPManager;
-    authStorage?: AuthStorage;
-    modelRegistry?: ModelRegistry;
-    settings?: Settings;
-    /**
-     * Parent session's live per-family service tiers, the source of truth for a
-     * subagent whose `tier.subagent` is `"inherit"`. `null` = the parent
-     * explicitly has no tier (e.g. `/fast off`); omitted = no live session, so
-     * inherit falls back to the subagent's configured `tier.*` settings.
-     */
-    parentServiceTier?: ServiceTierByFamily | null;
-    /** Override local:// protocol options so subagent shares parent's local:// root */
-    localProtocolOptions?: LocalProtocolOptions;
-    /**
-     * Parent session's ArtifactManager. Subagent adopts it so artifact IDs are
-     * unique across the whole agent tree and all artifacts land in the parent's
-     * artifacts directory (no per-subagent subdir).
-     */
-    parentArtifactManager?: ArtifactManager;
-    parentHindsightSessionState?: HindsightSessionState;
-    parentMnemopiSessionState?: MnemopiSessionState;
-    /** Parent agent's eval executor session id. Subagents reuse it so eval state is shared. */
-    parentEvalSessionId?: string;
-    /**
-     * Parent agent's OpenTelemetry configuration. When defined, the subagent's
-     * loop is started with the same tracer/hooks but its own agent identity
-     * stamped, so its `invoke_agent` / `chat` / `execute_tool` spans appear as
-     * a sub-tree under the parent's active `execute_tool task` span. A
-     * `handoff` span is emitted on dispatch to mark the parent → subagent
-     * transition explicitly.
-     */
-    parentTelemetry?: AgentTelemetryConfig;
-    /** Skills to autoload via sendCustomMessage before the first prompt */
-    autoloadSkills?: Skill[];
-    /**
-     * Registry id of the spawning agent, recorded as this subagent's parent.
-     * Forwarded verbatim to the SDK; the executor never derives it (the spawner
-     * passes its own `getAgentId()`).
-     */
-    parentAgentId?: string;
-    /**
-     * Keep the finished subagent addressable in the registry for IRC/revival.
-     * Defaults to true. Eval bridge agents are programmatic one-shot helpers and
-     * set this false so disposal unregisters them instead of leaving idle peers.
-     */
-    keepAlive?: boolean;
-}
-interface FinalizeSubprocessOutputArgs {
-    rawOutput: string;
-    exitCode: number;
-    stderr: string;
-    doneAborted: boolean;
-    signalAborted: boolean;
-    yieldItems?: YieldItem[];
-    reportFindings?: ReviewFinding[];
-    outputSchema: unknown;
-    lastAssistantText?: string;
-}
-interface FinalizeSubprocessOutputResult {
-    rawOutput: string;
-    exitCode: number;
-    stderr: string;
-    abortedViaYield: boolean;
-    hasYield: boolean;
-}
-export declare const SUBAGENT_WARNING_SCHEMA_OVERRIDDEN = "SYSTEM WARNING: Subagent exhausted schema-retry budget; result was accepted despite failing the output schema.";
-export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
-export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
-export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
-/**
- * Create proxy tools that reuse the parent's MCP connections.
- */
-export declare function createMCPProxyTools(mcpManager: MCPManager): CustomTool[];
-export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTierByFamily | null): Settings;
-export declare function finalizeSubagentLifecycle(args: {
-    id: string;
-    session: AgentSession;
-    aborted: boolean;
-    keepAlive: boolean;
-    isolated: boolean;
-    agentIdleTtlMs: number;
-    reviveSession: (() => Promise<AgentSession>) | null;
-}): Promise<void>;
-/**
- * Run a single agent in-process.
- */
-export declare function runSubprocess(options: ExecutorOptions): Promise<SingleResult>;

package/dist/types/task/index.d.ts

@@ -1,79 +0,0 @@
-import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
-import type { ToolSession } from "..";
-import type { Theme } from "../modes/theme/theme";
-import { type AgentDefinition, type SingleResult, type TaskItem, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
-import "../tools/review";
-import { renderResult, renderCall as renderTaskCall } from "./render";
-export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
-export { discoverCommands, expandCommand, getCommand } from "./commands";
-export { discoverAgents, getAgent } from "./discovery";
-export { AgentOutputManager } from "./output-manager";
-export type { AgentDefinition, AgentProgress, SingleResult, SubagentEventPayload, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
-export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
-export declare const READ_ONLY_TOOL_NAMES: ReadonlySet<string>;
-export declare function isReadOnlyAgent(agent: AgentDefinition): boolean;
-/**
- * Preview text for a child result. Falls back to "(no output)" — annotated
- * with the request count when the child actually did work, so the parent can
- * tell a no-op child from one that burned requests before being cancelled.
- */
-export declare function formatResultOutputFallback(result: Pick<SingleResult, "output" | "stderr" | "requests">): string;
-/**
- * Advisory — never a rejection — nudging the spawner toward tailored
- * specialists when it spawns generic role-less workers and still holds spawn
- * capacity (DepthCapacity: it currently has the `task` tool). Fires when a
- * generic `task`/`sonic` spawn carries no `role`, or when one call clones
- * the same agent ≥2× all without roles. Returns undefined when no nudge applies.
- */
-export declare function buildSpecializationAdvisory(agentName: string | undefined, items: TaskItem[], depthCapacity: boolean): string | undefined;
-/**
- * Suggestion — never a rejection — nudging the spawner to coordinate via `irc`
- * when one call creates ≥2 live siblings and it still holds spawn capacity.
- * Returns undefined when there is nothing to coordinate or IRC is unavailable.
- */
-export declare function buildCoordinationAdvisory(items: TaskItem[], depthCapacity: boolean, ircEnabled: boolean): string | undefined;
-/**
- * Compose the non-blocking advisory appended to a `task` result: the
- * specialization nudge, plus — only when the siblings keep running after this
- * call (`willRunAsync`) — the coordination suggestion. Coordination is gated on
- * async because a sync fanout's siblings have already finished, so a
- * "coordinate while they run" hint would misfire. Returns undefined when
- * neither applies.
- */
-export declare function composeSpawnAdvisory(args: {
-    agentName: string | undefined;
-    items: TaskItem[];
-    depthCapacity: boolean;
-    ircEnabled: boolean;
-    willRunAsync: boolean;
-}): string | undefined;
-/**
- * Task tool - Delegate tasks to specialized agents.
- *
- * Each call spawns one subagent — or, with `task.batch`, one per `tasks[]`
- * item. When `async.enabled` is on, spawns run as AsyncJobManager jobs; when
- * disabled, the tool blocks until every spawn finishes.
- */
-export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetails, Theme> {
-    #private;
-    private readonly session;
-    readonly name = "task";
-    readonly approval: "exec";
-    readonly formatApprovalDetails: (args: unknown) => string[];
-    readonly label = "Task";
-    readonly summary = "Spawn subagents to complete delegated tasks";
-    readonly strict = true;
-    readonly loadMode = "discoverable";
-    readonly renderResult: typeof renderResult;
-    readonly mergeCallAndResult = true;
-    get parameters(): TaskToolSchemaInstance;
-    renderCall(args: unknown, options: Parameters<typeof renderTaskCall>[1], theme: Theme): import("jeopi-tui").Component;
-    /** Dynamic description that reflects current disabled-agent settings */
-    get description(): string;
-    private constructor();
-    /**
-     * Create a TaskTool instance with async agent discovery.
-     */
-    static create(session: ToolSession): Promise<TaskTool>;
-    execute(toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
-}

package/dist/types/task/isolation-runner.d.ts

@@ -1,128 +0,0 @@
-import type * as natives from "jeopi-natives";
-import type { ToolSession } from "../tools";
-import type { ExecutorOptions } from "./executor";
-import type { SingleResult } from "./types";
-import { type WorktreeBaseline } from "./worktree";
-type IsoBackendKind = natives.IsoBackendKind;
-/** Resolved repo + baseline used by every isolated spawn in a single call. */
-export interface IsolationContext {
-    repoRoot: string;
-    baseline: WorktreeBaseline;
-}
-/**
- * Resolve the git repo root and capture the worktree baseline used to diff
- * each isolated spawn against. Throws when the cwd is not inside a git
- * repository; callers surface the error as a task-tool failure.
- */
-export declare function prepareIsolationContext(cwd: string): Promise<IsolationContext>;
-/** Build a commit-message callback for branch/nested commits; `undefined` ⇒ fall back to generic message. */
-export type BuildCommitMessage = () => undefined | ((diff: string) => Promise<string | null>);
-/**
- * Construct the commit-message factory used by isolation branch commits and
- * nested-repo patch commits. Returns a closure that, each time it's called,
- * either yields an AI-backed `(diff) => Promise<string|null>` callback (when
- * `task.isolation.commits === "ai"` and a model registry is available) or
- * `undefined` so the caller falls back to a generic commit message.
- *
- * Centralized so `TaskTool` and the eval `agent()` bridge share one wiring;
- * a drift here previously meant the two callers built subtly different
- * generators for the same setting.
- */
-export declare function makeIsolationCommitMessage(session: ToolSession): BuildCommitMessage;
-export interface IsolatedRunOptions {
-    /**
-     * Base run options handed to the subagent subprocess. This helper sets
-     * `worktree`, clears `preloadedExtensionPaths` / `preloadedCustomToolPaths`
-     * (isolated runs re-discover inside the worktree), and forwards everything
-     * else unchanged.
-     */
-    baseOptions: ExecutorOptions;
-    /** Context returned by {@link prepareIsolationContext}. Baseline is cloned per spawn. */
-    context: IsolationContext;
-    /** PAL backend hint from `parseIsolationMode(...)` (undefined ⇒ resolver picks). */
-    preferredBackend: IsoBackendKind | undefined;
-    /** Stable id used as the isolation worktree namespace and as the branch suffix. */
-    agentId: string;
-    /** Merge mode driving how changes are captured ("branch" commits, "patch" diffs). */
-    mergeMode: "patch" | "branch";
-    /** Output dir for `${agentId}.patch` artifacts (patch mode). */
-    artifactsDir: string;
-    /** Human description carried onto the branch commit (branch mode). */
-    description?: string;
-    /** Build a commit-message callback (`task.isolation.commits === "ai"`). */
-    buildCommitMessage?: BuildCommitMessage;
-    /**
-     * Construct a `SingleResult` when isolation setup throws — the caller has
-     * the full metadata (index, agent, assignment, modelOverride) needed to
-     * build a result shape consistent with their non-isolated path.
-     */
-    buildFailureResult: (err: unknown) => SingleResult;
-}
-/**
- * Run a subagent inside an isolation worktree and capture its changes.
- *
- * Branch mode: on success, commits the diff onto `omp/task/${agentId}` and
- * returns `branchName` + `nestedPatches`. On commit failure the branch is
- * deleted and `result.error` carries the merge-failure message.
- *
- * Patch mode: on success, writes `${artifactsDir}/${agentId}.patch` and
- * returns `patchPath` + `nestedPatches`.
- *
- * Failure paths preserve the underlying `SingleResult` whenever possible so
- * the caller can still surface the subagent's output; only isolation setup
- * itself routes through {@link IsolatedRunOptions.buildFailureResult}.
- *
- * The isolation handle is always torn down in `finally`.
- */
-export declare function runIsolatedSubprocess(opts: IsolatedRunOptions): Promise<SingleResult>;
-export interface IsolationMergeOptions {
-    result: SingleResult;
-    repoRoot: string;
-    mergeMode: "patch" | "branch";
-}
-export interface IsolationMergeOutcome {
-    /** Trailing summary appended to the subagent's result text. May be empty. */
-    summary: string;
-    /**
-     * Tri-state apply outcome:
-     * - `true`  — merge ran (or had nothing to apply) and left the repo clean.
-     * - `false` — merge attempted and failed; artifacts are preserved.
-     * - `null`  — caller skipped the merge phase entirely (e.g. `apply=false`).
-     */
-    changesApplied: boolean | null;
-    hadAnyChanges: boolean;
-    /** True iff the root branch actually merged — gates nested-repo patch application. */
-    mergedBranchForNestedPatches: boolean;
-}
-/**
- * Apply changes captured by {@link runIsolatedSubprocess} back to the parent
- * repo: patch apply (patch mode) or cherry-pick + cleanup (branch mode).
- *
- * The caller decides whether to run this at all — eval `agent()` with
- * `apply=False` skips this step and surfaces the patch artifact / branch name
- * instead.
- */
-export declare function mergeIsolatedChanges(opts: IsolationMergeOptions): Promise<IsolationMergeOutcome>;
-export interface NestedPatchApplyOptions {
-    /** Subagent result carrying `nestedPatches`/`exitCode`/`aborted`. */
-    result: SingleResult;
-    repoRoot: string;
-    mergeMode: "patch" | "branch";
-    /** Parent merge outcome — patch mode skips nested apply when this is `false`. */
-    changesApplied: boolean | null;
-    /** Branch mode gates nested apply on whether the root branch merged. */
-    mergedBranchForNestedPatches: boolean;
-    /** Optional AI commit-message callback for nested commits; falls back to a generic message. */
-    commitMessage?: (diff: string) => Promise<string | null>;
-}
-/**
- * Apply nested-repo patches after the parent merge phase. Centralizes the
- * three-way gate (exitCode/aborted, patch-mode failed parent, branch-mode
- * branch-merged) and the non-fatal failure handling so `TaskTool` and the
- * eval `agent()` bridge use one implementation.
- *
- * Returns a system-notification suffix to append to the parent merge summary,
- * or an empty string when nothing was applied or the nested apply succeeded.
- */
-export declare function applyEligibleNestedPatches(opts: NestedPatchApplyOptions): Promise<string>;
-export {};

package/dist/types/task/name-generator.d.ts

@@ -1,16 +0,0 @@
-/**
- * Generate memorable two-word task identifiers.
- * Format: AdjectiveNoun (e.g., "SwiftFalcon", "CalmPanda")
- *
- * Dictionaries sourced from unique-names-generator (MIT license).
- * 1202 adjectives × 355 animals = 426,710 combinations.
- */
-/**
- * Generate a unique two-word identifier (e.g., "SwiftFalcon").
- * Falls back to numeric suffix if all combinations exhausted.
- */
-export declare function generateTaskName(): string;
-/**
- * Reset name generator state (for testing).
- */
-export declare function resetTaskNames(): void;

package/dist/types/task/omp-command.d.ts

@@ -1,7 +0,0 @@
-interface OmpCommand {
-    cmd: string;
-    args: string[];
-    shell: boolean;
-}
-export declare function resolveOmpCommand(): OmpCommand;
-export {};

package/dist/types/task/output-manager.d.ts

@@ -1,20 +0,0 @@
-/**
- * Manages agent output ID allocation to ensure uniqueness.
- *
- * The first allocation of a given name keeps the name as-is; subsequent
- * allocations of the same name get a `-2`, `-3`, … suffix. On resume, scans
- * existing output files so previously written outputs are never overwritten.
- */
-export declare class AgentOutputManager {
-    #private;
-    constructor(getArtifactsDir: () => string | null, options?: {
-        parentPrefix?: string;
-    });
-    /**
-     * Allocate a unique ID.
-     *
-     * @param id Requested ID (e.g., "Anna")
-     * @returns Unique ID ("Anna" first, then "Anna-2", "Anna-3", …)
-     */
-    allocate(id: string): Promise<string>;
-}

package/dist/types/task/parallel.d.ts

@@ -1,55 +0,0 @@
-/**
- * Parallel execution with concurrency control.
- */
-/** Result of parallel execution */
-export interface ParallelResult<R> {
-    /** Results array - undefined entries indicate tasks that were skipped due to abort */
-    results: (R | undefined)[];
-    /** Whether execution was aborted before all tasks completed */
-    aborted: boolean;
-}
-/**
- * Execute items with a concurrency limit using a worker pool pattern.
- * Results are returned in the same order as input items.
- *
- * On abort: returns partial results with `aborted: true`. Completed tasks are preserved,
- * in-progress tasks will complete with their abort handling, skipped tasks are `undefined`.
- *
- * On error: fails fast - does not wait for other workers to complete.
- *
- * @param items - Items to process
- * @param concurrency - Maximum concurrent operations
- * @param fn - Async function to execute for each item; receives a worker signal that fires on abort or fail-fast so in-flight siblings can cancel
- * @param signal - Optional abort signal to stop scheduling new work
- */
-export declare function mapWithConcurrencyLimit<T, R>(items: T[], concurrency: number, fn: (item: T, index: number, signal: AbortSignal) => Promise<R>, signal?: AbortSignal): Promise<ParallelResult<R>>;
-/**
- * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
- *
- * `max <= 0` (or any non-finite input) means unbounded — every `acquire()` resolves
- * immediately — matching `task.maxConcurrency = 0`'s "Unlimited" semantics in the
- * settings UI ([#3305](https://github.com/can1357/oh-my-pi/issues/3305)).
- */
-export declare function normalizeConcurrencyLimit(max: number): number;
-export declare class Semaphore {
-    #private;
-    constructor(max: number);
-    /**
-     * Resolves when a slot is available. Pass an `AbortSignal` so callers that
-     * stop waiting (parent task cancelled, wall-clock budget elapsed) also stop
-     * occupying a queue slot — otherwise a later `release()` would resolve the
-     * abandoned waiter, permanently shrinking effective concurrency for the
-     * remaining lifetime of the process (issue #3464 review feedback).
-     */
-    acquire(signal?: AbortSignal): Promise<void>;
-    release(): void;
-    /**
-     * Adjust the maximum concurrency in place. Raising the ceiling immediately
-     * admits queued waiters that now fit; lowering it lets in-flight holders
-     * drain naturally (new acquires keep blocking until `#current` falls below
-     * the new max). Resizing the single shared instance — instead of replacing
-     * it — keeps in-flight slots counted, so a runtime or mixed limit change can
-     * never push concurrency past the cap (issue #3464 review feedback).
-     */
-    resize(max: number): void;
-}

package/dist/types/task/persisted-revive.d.ts

@@ -1,36 +0,0 @@
-import type { ModelRegistry } from "../config/model-registry";
-import type { Settings } from "../config/settings";
-import type { PersistedSubagentReviverFactory } from "../registry/agent-lifecycle";
-import type { AgentSession } from "../session/agent-session";
-import type { AuthStorage } from "../session/auth-storage";
-/**
- * Ambient context the reviver needs at revive time. The top-level session is
- * kept LIVE (cwd / artifact manager read on demand) so a later `/new` or cwd
- * move is followed rather than snapshotted; auth/models/settings are
- * process-stable and captured by reference.
- */
-export interface PersistedSubagentReviveContext {
-    session: AgentSession;
-    authStorage: AuthStorage;
-    modelRegistry: ModelRegistry;
-    settings: Settings;
-    /** LSP policy of the top-level session; revived subagents inherit it rather than defaulting on. */
-    enableLsp: boolean;
-}
-/**
- * Build the factory the {@link AgentLifecycleManager} uses to cold-revive a
- * `parked` subagent ref restored from disk (Agent Hub scan, collab mirror, or a
- * resumed process). Such a ref carries a sessionFile but no in-memory adoption —
- * the executor's live reviver closure died with the process/turn that spawned
- * it — so `ensureLive` (IRC sends, hub focus) would otherwise refuse it.
- *
- * This rebuilds the subagent the same way `--resume` rebuilds a session: reopen
- * the JSONL and replay it through {@link createAgentSession}. The catch is that
- * resume restores only conversation/model from the file — the runtime contract
- * (tools / system prompt / output schema / kind) is built from options, so a
- * bare reopen would resurrect a wrong (top-level) session. We source that
- * contract from the persisted `session_init` entry instead, and mirror the
- * executor's subagent wiring (MCP proxy tools, depth-derived gating,
- * yield-required, active-tool clamp, registry status sync).
- */
-export declare function createPersistedSubagentReviverFactory(ctx: PersistedSubagentReviveContext): PersistedSubagentReviverFactory;

package/dist/types/task/provider-concurrency.d.ts

@@ -1,40 +0,0 @@
-/**
- * Per-provider LLM concurrency cap, applied around each provider HTTP request.
- *
- * The semaphore brackets only the streaming request itself, not the whole
- * agent lifetime: a parent subagent releases its slot the moment its LLM
- * stream finishes producing, so children spawned during tool execution can
- * acquire slots for their own turns. Holding the slot across the parent's
- * full conversation deadlocks any spawn tree whose width exceeds
- * `maxConcurrency` because the parents wait for children that wait for
- * slots the parents are holding (issue
- * [#3749](https://github.com/can1357/oh-my-pi/issues/3749)).
- */
-import type { StreamFn } from "jeopi-agent-core";
-import type { Settings } from "../config/settings";
-import { Semaphore } from "./parallel";
-/**
- * Resolve the configured concurrency ceiling for a provider, or `undefined`
- * when the provider has no cap concept at all. A configured value `<= 0` means
- * "unlimited" and maps to `Infinity` — still a tracked ceiling, so every run
- * holds a slot and a later finite resize counts work started while unlimited.
- */
-export declare function getProviderConcurrencyLimit(settings: Settings, provider: string): number | undefined;
-/**
- * Hand out the single shared limiter for `provider` (creating one lazily) and
- * resize it in place when the configured limit changes. Replacing the
- * semaphore would orphan in-flight slots on the old instance and let a
- * runtime or mixed limit value exceed the cap (issue #3464 review feedback).
- */
-export declare function getProviderSemaphore(settings: Settings, provider: string): Semaphore | undefined;
-/**
- * Wrap a {@link StreamFn} so every LLM HTTP request acquires the provider's
- * concurrency slot before the request goes out and releases it when the
- * stream finishes producing (success, error, or abort). Providers without a
- * configured cap pass straight through.
- *
- * The acquire bracket is intentionally narrow (one slot per LLM call), so
- * spawn trees deeper than `maxConcurrency` no longer deadlock on themselves —
- * see the module-level comment for the failure mode this fixes.
- */
-export declare function wrapStreamFnWithProviderConcurrency(settings: Settings, base: StreamFn): StreamFn;

package/dist/types/task/render.d.ts

@@ -1,34 +0,0 @@
-import type { Component } from "jeopi-tui";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { type Theme } from "../modes/theme/theme";
-import type { TaskParams, TaskToolDetails } from "./types";
-/** Render context threaded in from `ToolExecutionComponent.#buildRenderContext`. */
-interface TaskRenderContext {
-    hasResult?: boolean;
-    /**
-     * The block left the transcript live region (detached spawn the transcript
-     * has moved past, or a sealed block): progress rows render static gray, so
-     * commit-eligible rows do not repaint after entering native scrollback.
-     */
-    frozen?: boolean;
-}
-type TaskRenderOptions = RenderResultOptions & {
-    renderContext?: TaskRenderContext;
-};
-export declare function formatTaskId(id: string): string;
-/**
- * Render the tool call arguments.
- */
-export declare function renderCall(args: TaskParams, options: TaskRenderOptions, theme: Theme): Component;
-/**
- * Render the tool result.
- */
-export declare function renderResult(result: {
-    content: Array<{
-        type: string;
-        text?: string;
-    }>;
-    details?: TaskToolDetails;
-    isError?: boolean;
-}, options: TaskRenderOptions, theme: Theme, args?: TaskParams): Component;
-export {};

package/dist/types/task/render.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/task/renderer.d.ts

@@ -1,13 +0,0 @@
-/**
- * Task tool renderer export.
- *
- * Separated from render.ts to avoid circular dependency issues with
- * tools/renderers.ts. This module has no side effects and can be safely
- * imported without triggering the subprocessToolRegistry registration.
- */
-import { renderCall, renderResult } from "./render";
-export declare const taskToolRenderer: {
-    readonly renderCall: typeof renderCall;
-    readonly renderResult: typeof renderResult;
-    readonly mergeCallAndResult: true;
-};