@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/ssh/sshfs-mount.d.ts

@@ -0,0 +1,6 @@
+import { type SSHConnectionTarget } from "./connection-manager";
+export declare function hasSshfs(): boolean;
+export declare function isMounted(path: string): Promise<boolean>;
+export declare function mountRemote(host: SSHConnectionTarget, remotePath?: string): Promise<string | undefined>;
+export declare function unmountRemote(host: SSHConnectionTarget): Promise<boolean>;
+export declare function unmountAll(): Promise<void>;

package/dist/types/ssh/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeHostName(name: string): string;
+export declare function buildSshTarget(username: string | undefined, host: string): string;

package/dist/types/stt/downloader.d.ts

@@ -0,0 +1,9 @@
+export interface DownloadProgress {
+    stage: string;
+    percent?: number;
+}
+export interface EnsureOptions {
+    modelName?: string;
+    onProgress?: (progress: DownloadProgress) => void;
+}
+export declare function ensureSTTDependencies(options?: EnsureOptions): Promise<void>;

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

@@ -0,0 +1,3 @@
+export * from "./downloader";
+export * from "./setup";
+export * from "./stt-controller";

package/dist/types/stt/recorder.d.ts

@@ -0,0 +1,13 @@
+export interface RecordingHandle {
+    stop(): Promise<void>;
+}
+/**
+ * Returns available recording tools in priority order.
+ */
+export declare function detectRecordingTools(): string[];
+export declare function startRecording(outputPath: string): Promise<RecordingHandle>;
+/**
+ * Verify a recorded audio file is usable.
+ * Returns the file size in bytes, or throws.
+ */
+export declare function verifyRecordingFile(filePath: string): Promise<number>;

package/dist/types/stt/setup.d.ts

@@ -0,0 +1,18 @@
+export interface STTDependencyStatus {
+    recorder: {
+        available: boolean;
+        tool: string | null;
+        installHint: string;
+    };
+    python: {
+        available: boolean;
+        path: string | null;
+        installHint: string;
+    };
+    whisper: {
+        available: boolean;
+        installHint: string;
+    };
+}
+export declare function checkDependencies(): Promise<STTDependencyStatus>;
+export declare function formatDependencyStatus(status: STTDependencyStatus): string;

package/dist/types/stt/stt-controller.d.ts

@@ -0,0 +1,16 @@
+export type SttState = "idle" | "recording" | "transcribing";
+interface ToggleOptions {
+    showWarning(msg: string): void;
+    showStatus(msg: string): void;
+    onStateChange(state: SttState): void;
+}
+interface Editor {
+    insertText(text: string): void;
+}
+export declare class STTController {
+    #private;
+    get state(): SttState;
+    toggle(editor: Editor, options: ToggleOptions): Promise<void>;
+    dispose(): void;
+}
+export {};

package/dist/types/stt/transcriber.d.ts

@@ -0,0 +1,16 @@
+export interface TranscribeOptions {
+    modelName?: string;
+    language?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Find a usable Python command.
+ */
+export declare function resolvePython(): string | null;
+/**
+ * Transcribe a WAV file using Python openai-whisper.
+ *
+ * Reads the WAV via Python's built-in `wave` module (no ffmpeg needed),
+ * resamples to 16 kHz mono, and passes the numpy array directly to whisper.
+ */
+export declare function transcribe(audioPath: string, options?: TranscribeOptions): Promise<string>;

package/dist/types/system-prompt.d.ts

@@ -0,0 +1,93 @@
+/**
+ * System prompt construction and project context loading
+ */
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { SkillsSettings } from "./config/settings";
+import { type Skill } from "./extensibility/skills";
+import { type WorkspaceTree } from "./workspace-tree";
+interface AlwaysApplyRule {
+    name: string;
+    content: string;
+    path: string;
+}
+/** Resolve input as file path or literal string */
+export declare function resolvePromptInput(input: string | undefined, description: string): Promise<string | undefined>;
+export interface LoadContextFilesOptions {
+    /** Working directory to start walking up from. Default: getProjectDir() */
+    cwd?: string;
+}
+/**
+ * Load all project context files using the capability API.
+ * Returns {path, content, depth} entries for all discovered context files.
+ * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
+ */
+export declare function loadProjectContextFiles(options?: LoadContextFilesOptions): Promise<Array<{
+    path: string;
+    content: string;
+    depth?: number;
+}>>;
+/**
+ * Load the effective system prompt customization from SYSTEM.md.
+ * Project-level SYSTEM.md overrides user-level SYSTEM.md.
+ */
+export declare function loadSystemPromptFiles(options?: LoadContextFilesOptions): Promise<string | null>;
+export interface SystemPromptToolMetadata {
+    label: string;
+    description: string;
+    /** Tool name the model sees on the provider wire. Defaults to the internal tool name. */
+    wireName?: string;
+}
+export declare function buildSystemPromptToolMetadata(tools: Map<string, AgentTool>, overrides?: Partial<Record<string, Partial<SystemPromptToolMetadata>>>): Map<string, SystemPromptToolMetadata>;
+export interface BuildSystemPromptOptions {
+    /** Custom system prompt (replaces default). */
+    customPrompt?: string;
+    /** Tools to include in prompt. */
+    tools?: Map<string, SystemPromptToolMetadata>;
+    /** Tool names to include in prompt. */
+    toolNames?: string[];
+    /** Text to append to system prompt. */
+    appendSystemPrompt?: string;
+    /** Repeat full tool descriptions in system prompt. Default: false */
+    repeatToolDescriptions?: boolean;
+    /** Skills settings for discovery. */
+    skillsSettings?: SkillsSettings;
+    /** Working directory. Default: getProjectDir() */
+    cwd?: string;
+    /** Pre-loaded context files (skips discovery if provided). */
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+        depth?: number;
+    }>;
+    /** Skills provided directly to system prompt construction. */
+    skills?: Skill[];
+    /** Pre-loaded rulebook rules (descriptions, excluding TTSR and always-apply). */
+    rules?: Array<{
+        name: string;
+        description?: string;
+        path: string;
+        globs?: string[];
+    }>;
+    /** Intent field name injected into every tool schema. If set, explains the field in the prompt. */
+    intentField?: string;
+    /** Whether MCP tool discovery is active for this prompt build. */
+    mcpDiscoveryMode?: boolean;
+    /** Discoverable MCP server summaries to advertise when discovery mode is active. */
+    mcpDiscoveryServerSummaries?: string[];
+    /** Encourage the agent to delegate via tasks unless changes are trivial. */
+    eagerTasks?: boolean;
+    /** Rules with alwaysApply=true — their full content is injected into the prompt. */
+    alwaysApplyRules?: AlwaysApplyRule[];
+    /** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
+    secretsEnabled?: boolean;
+    /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
+    workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
+}
+/** Result of building provider-facing system prompt messages. */
+export interface BuildSystemPromptResult {
+    /** Ordered system prompt blocks. Providers should preserve entries as distinct messages/blocks. */
+    systemPrompt: string[];
+}
+/** Build the system prompt with tools, guidelines, and context */
+export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export {};

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

@@ -0,0 +1,28 @@
+import type { AgentDefinition, AgentSource } from "./types";
+export declare class AgentParsingError extends Error {
+    readonly source?: unknown;
+    constructor(error: Error, source?: unknown);
+    toString(): string;
+}
+/**
+ * Parse an agent from embedded content.
+ */
+export declare function parseAgent(filePath: string, content: string, source: AgentSource, level?: "fatal" | "warn" | "off"): AgentDefinition;
+/**
+ * Load all bundled agents from embedded content.
+ * Results are cached after first load.
+ */
+export declare function loadBundledAgents(): AgentDefinition[];
+/**
+ * Get a bundled agent by name.
+ */
+export declare function getBundledAgent(name: string): AgentDefinition | undefined;
+/**
+ * Get all bundled agents as a map keyed by name.
+ */
+export declare function getBundledAgentsMap(): Map<string, AgentDefinition>;
+/**
+ * Clear the bundled agents cache (for testing).
+ */
+export declare function clearBundledAgentsCache(): void;
+export declare const BUNDLED_AGENTS: typeof loadBundledAgents;

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

@@ -0,0 +1,35 @@
+export declare const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{
+    name: string;
+    content: string;
+}>;
+/** Workflow command definition */
+export interface WorkflowCommand {
+    name: string;
+    description: string;
+    instructions: string;
+    source: "bundled" | "user" | "project";
+    filePath: string;
+}
+/**
+ * Load all bundled commands from embedded content.
+ */
+export declare function loadBundledCommands(): WorkflowCommand[];
+/**
+ * Discover all available commands.
+ *
+ * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
+ */
+export declare function discoverCommands(cwd: string): Promise<WorkflowCommand[]>;
+/**
+ * Get a command by name.
+ */
+export declare function getCommand(commands: WorkflowCommand[], name: string): WorkflowCommand | undefined;
+/**
+ * Expand command instructions with task input.
+ * Replaces $@ with the provided input.
+ */
+export declare function expandCommand(command: WorkflowCommand, input: string): string;
+/**
+ * Clear the bundled commands cache (for testing).
+ */
+export declare function clearBundledCommandsCache(): void;

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

@@ -0,0 +1,18 @@
+import type { AgentDefinition } from "./types";
+/** Result of agent discovery */
+export interface DiscoveryResult {
+    agents: AgentDefinition[];
+    projectAgentsDir: string | null;
+}
+/**
+ * Discover agents from filesystem and merge with bundled agents.
+ *
+ * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
+ *
+ * @param cwd - Current working directory for project agent discovery
+ */
+export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;
+/**
+ * Get an agent by name from discovered agents.
+ */
+export declare function getAgent(agents: AgentDefinition[], name: string): AgentDefinition | undefined;

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

@@ -0,0 +1,106 @@
+/**
+ * In-process execution for subagents.
+ *
+ * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
+ */
+import type { AgentTelemetryConfig, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { ModelRegistry } from "../config/model-registry";
+import type { PromptTemplate } from "../config/prompt-templates";
+import { Settings } from "../config/settings";
+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 { 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 } from "./types";
+/** Options for subagent execution */
+export interface ExecutorOptions {
+    cwd: string;
+    worktree?: string;
+    agent: AgentDefinition;
+    task: string;
+    assignment?: string;
+    context?: string;
+    description?: string;
+    index: number;
+    id: string;
+    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;
+    /** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */
+    taskDepth?: number;
+    enableLsp?: boolean;
+    signal?: AbortSignal;
+    onProgress?: (progress: AgentProgress) => void;
+    sessionFile?: string | null;
+    persistArtifacts?: boolean;
+    artifactsDir?: string;
+    /** Path to parent conversation context file */
+    contextFile?: string;
+    eventBus?: EventBus;
+    contextFiles?: ContextFileEntry[];
+    skills?: Skill[];
+    promptTemplates?: PromptTemplate[];
+    workspaceTree?: WorkspaceTree;
+    mcpManager?: MCPManager;
+    authStorage?: AuthStorage;
+    modelRegistry?: ModelRegistry;
+    settings?: Settings;
+    /** 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;
+    /**
+     * 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;
+}
+export interface YieldItem {
+    data?: unknown;
+    status?: "success" | "aborted";
+    error?: string;
+}
+interface FinalizeSubprocessOutputArgs {
+    rawOutput: string;
+    exitCode: number;
+    stderr: string;
+    doneAborted: boolean;
+    signalAborted: boolean;
+    yieldItems?: YieldItem[];
+    reportFindings?: ReviewFinding[];
+    outputSchema: unknown;
+}
+interface FinalizeSubprocessOutputResult {
+    rawOutput: string;
+    exitCode: number;
+    stderr: string;
+    abortedViaYield: boolean;
+    hasYield: boolean;
+}
+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;
+/**
+ * Run a single agent in-process.
+ */
+export declare function runSubprocess(options: ExecutorOptions): Promise<SingleResult>;
+export {};

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

@@ -0,0 +1,38 @@
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "..";
+import type { Theme } from "../modes/theme/theme";
+import { 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, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
+export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
+/**
+ * Task tool - Delegate tasks to specialized agents.
+ *
+ * Requires async initialization to discover available agents.
+ * Use `TaskTool.create(session)` to instantiate.
+ */
+export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetails, Theme> {
+    #private;
+    private readonly session;
+    readonly name = "task";
+    readonly label = "Task";
+    readonly summary = "Spawn a subagent to complete a parallel task";
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly renderResult: typeof renderResult;
+    get parameters(): TaskToolSchemaInstance;
+    renderCall(args: unknown, options: Parameters<typeof renderTaskCall>[1], theme: Theme): import("@oh-my-pi/pi-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/name-generator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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

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

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

@@ -0,0 +1,36 @@
+/**
+ * Manages agent output ID allocation to ensure uniqueness.
+ *
+ * Each allocated ID gets a numeric prefix based on allocation order.
+ * If configured with a parent prefix, the numeric prefix is appended after
+ * the parent (e.g., "0-Parent.0-Child").
+ * On resume, scans existing files to find the next available index.
+ */
+export declare class AgentOutputManager {
+    #private;
+    constructor(getArtifactsDir: () => string | null, options?: {
+        parentPrefix?: string;
+    });
+    /**
+     * Allocate a unique ID with numeric prefix.
+     *
+     * @param id Requested ID (e.g., "AuthProvider")
+     * @returns Unique ID with prefix (e.g., "0-AuthProvider")
+     */
+    allocate(id: string): Promise<string>;
+    /**
+     * Allocate unique IDs for a batch of tasks.
+     *
+     * @param ids Array of requested IDs
+     * @returns Array of unique IDs in same order
+     */
+    allocateBatch(ids: string[]): Promise<string[]>;
+    /**
+     * Get the next ID that would be allocated (without allocating).
+     */
+    peekNextIndex(): Promise<number>;
+    /**
+     * Reset state (primarily for testing).
+     */
+    reset(): void;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * 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
+ * @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) => Promise<R>, signal?: AbortSignal): Promise<ParallelResult<R>>;
+/**
+ * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
+ */
+export declare class Semaphore {
+    #private;
+    constructor(max: number);
+    acquire(): Promise<void>;
+    release(): void;
+}

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

@@ -0,0 +1,22 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { TaskParams, TaskToolDetails } from "./types";
+/**
+ * Render the tool call arguments.
+ */
+export declare function renderCall(args: TaskParams, _options: RenderResultOptions, theme: Theme): Component;
+/**
+ * Render the tool result.
+ */
+export declare function renderResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: TaskToolDetails;
+}, options: RenderResultOptions, theme: Theme): Component;
+export declare const taskToolRenderer: {
+    renderCall: typeof renderCall;
+    renderResult: typeof renderResult;
+};

package/dist/types/task/simple-mode.d.ts

@@ -0,0 +1,8 @@
+export declare const TASK_SIMPLE_MODES: readonly ["default", "schema-free", "independent"];
+export type TaskSimpleMode = (typeof TASK_SIMPLE_MODES)[number];
+interface TaskSimpleModeCapabilities {
+    contextEnabled: boolean;
+    customSchemaEnabled: boolean;
+}
+export declare function getTaskSimpleModeCapabilities(mode: TaskSimpleMode): TaskSimpleModeCapabilities;
+export {};

package/dist/types/task/subprocess-tool-registry.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Registry for handling tool events from subprocess agents.
+ *
+ * Tools can register handlers to:
+ * - Extract structured data from their execution results
+ * - Trigger subprocess termination on completion
+ * - Provide custom rendering for realtime/final display
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { Theme } from "../modes/theme/theme";
+/** Event from subprocess tool execution (parsed from JSONL) */
+export interface SubprocessToolEvent {
+    toolName: string;
+    toolCallId: string;
+    args?: Record<string, unknown>;
+    result?: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: unknown;
+    };
+    isError?: boolean;
+}
+/** Handler for subprocess tool events */
+export interface SubprocessToolHandler<TData = unknown> {
+    /**
+     * Extract structured data from tool result.
+     * Extracted data is accumulated in progress.extractedToolData[toolName][].
+     */
+    extractData?: (event: SubprocessToolEvent) => TData | undefined;
+    /**
+     * Whether this tool's completion should terminate the subprocess.
+     * Return true to send SIGTERM after the tool completes.
+     */
+    shouldTerminate?: (event: SubprocessToolEvent) => boolean;
+    /**
+     * Render a single data item inline during streaming progress.
+     * Called for each tool execution end event.
+     */
+    renderInline?: (data: TData, theme: Theme) => Component;
+    /**
+     * Render accumulated data in the final result view.
+     * Called once with all accumulated data for this tool.
+     */
+    renderFinal?: (allData: TData[], theme: Theme, expanded: boolean) => Component;
+}
+/** Registry for subprocess tool handlers */
+declare class SubprocessToolRegistryImpl {
+    #private;
+    /**
+     * Register a handler for a tool's subprocess events.
+     */
+    register<T>(toolName: string, handler: SubprocessToolHandler<T>): void;
+    /**
+     * Get the handler for a tool, if registered.
+     */
+    getHandler(toolName: string): SubprocessToolHandler | undefined;
+    /**
+     * Check if a tool has a registered handler.
+     */
+    hasHandler(toolName: string): boolean;
+    /**
+     * Get all registered tool names.
+     */
+    getRegisteredTools(): string[];
+}
+/** Singleton registry instance */
+export declare const subprocessToolRegistry: SubprocessToolRegistryImpl;
+/** Type helper for extracted tool data in progress/result */
+export type ExtractedToolData = Record<string, unknown[]>;
+export {};