@sayknow-cli/coding-agent 0.3.13 → 0.3.15

package/dist/types/tool-discovery/tool-index.d.ts

@@ -0,0 +1,112 @@
+import type { AgentTool } from "@sayknow-cli/agent-core";
+export type DiscoverableToolSource = "builtin" | "mcp" | "extension" | "custom";
+export interface DiscoverableTool {
+    name: string;
+    label: string;
+    /** Short BM25 corpus entry; falls back to description first 200 chars */
+    summary: string;
+    source: DiscoverableToolSource;
+    /** MCP only */
+    serverName?: string;
+    /** MCP only */
+    mcpToolName?: string;
+    schemaKeys: string[];
+}
+export interface DiscoverableToolServerSummary {
+    name: string;
+    toolCount: number;
+}
+export interface DiscoverableToolSummary {
+    servers: DiscoverableToolServerSummary[];
+    toolCount: number;
+}
+export interface DiscoverableToolSearchDocument {
+    tool: DiscoverableTool;
+    termFrequencies: Map<string, number>;
+    length: number;
+}
+export interface DiscoverableToolSearchIndex {
+    documents: DiscoverableToolSearchDocument[];
+    averageLength: number;
+    documentFrequencies: Map<string, number>;
+}
+export interface DiscoverableToolSearchResult {
+    tool: DiscoverableTool;
+    score: number;
+}
+/** @deprecated Use DiscoverableTool with source === "mcp" */
+export type DiscoverableMCPTool = Pick<DiscoverableTool, "name" | "label" | "schemaKeys" | "serverName" | "mcpToolName"> & {
+    description: string;
+};
+/** @deprecated Use DiscoverableToolServerSummary */
+export type DiscoverableMCPToolServerSummary = DiscoverableToolServerSummary;
+/** @deprecated Use DiscoverableToolSummary */
+export type DiscoverableMCPToolSummary = DiscoverableToolSummary;
+/** Tool object stored on legacy MCP index documents. Carries both legacy `description` and the
+ *  generic `summary`/`source` so the legacy index is structurally assignable to
+ *  DiscoverableToolSearchIndex (search functions read termFrequencies, not the tool fields). */
+export type DiscoverableMCPSearchTool = DiscoverableTool & {
+    description: string;
+};
+/** @deprecated Use DiscoverableToolSearchDocument */
+export interface DiscoverableMCPSearchDocument {
+    tool: DiscoverableMCPSearchTool;
+    termFrequencies: Map<string, number>;
+    length: number;
+}
+/** @deprecated Use DiscoverableToolSearchIndex.
+ *  Documents on this index expose `tool.description` (legacy MCP shape) while still being
+ *  searchable via `searchDiscoverableTools`. */
+export interface DiscoverableMCPSearchIndex {
+    documents: DiscoverableMCPSearchDocument[];
+    averageLength: number;
+    documentFrequencies: Map<string, number>;
+}
+/** @deprecated Use DiscoverableToolSearchResult */
+export interface DiscoverableMCPSearchResult {
+    tool: DiscoverableMCPSearchTool;
+    score: number;
+}
+export declare function isMCPToolName(name: string): boolean;
+export declare function isMCPBridgeTool(tool: {
+    name: string;
+    mcpServerName?: unknown;
+    mcpToolName?: unknown;
+}): boolean;
+/**
+ * Convert a raw AgentTool into a DiscoverableTool generic descriptor.
+ * source: "mcp" if name starts with "mcp__", else "builtin" (caller may override).
+ */
+export declare function getDiscoverableTool(tool: AgentTool, overrides?: {
+    source?: DiscoverableToolSource;
+    summary?: string;
+}): DiscoverableTool | null;
+/** Collect all DiscoverableTools from a tool iterable. Skips tools that return null. */
+export declare function collectDiscoverableTools(tools: Iterable<AgentTool>, options?: {
+    source?: DiscoverableToolSource;
+    summaryMap?: Map<string, string>;
+}): DiscoverableTool[];
+/** Filter discoverable tools by source */
+export declare function filterBySource(tools: DiscoverableTool[], source: DiscoverableToolSource): DiscoverableTool[];
+export declare function formatDiscoverableToolServerSummary(server: DiscoverableToolServerSummary): string;
+export declare function selectDiscoverableToolNamesByServer(tools: Iterable<DiscoverableTool>, serverNames: ReadonlySet<string>): string[];
+export declare function summarizeDiscoverableTools(tools: DiscoverableTool[]): DiscoverableToolSummary;
+export declare function buildDiscoverableToolSearchIndex(tools: Iterable<DiscoverableTool>): DiscoverableToolSearchIndex;
+export declare function searchDiscoverableTools(index: DiscoverableToolSearchIndex, query: string, limit: number): DiscoverableToolSearchResult[];
+/** @deprecated Use getDiscoverableTool */
+export declare function getDiscoverableMCPTool(tool: AgentTool): DiscoverableMCPTool | null;
+/** @deprecated Use collectDiscoverableTools with source filter */
+export declare function collectDiscoverableMCPTools(tools: Iterable<AgentTool>): DiscoverableMCPTool[];
+/** @deprecated Use selectDiscoverableToolNamesByServer */
+export declare function selectDiscoverableMCPToolNamesByServer(tools: Iterable<DiscoverableMCPTool>, serverNames: ReadonlySet<string>): string[];
+/** @deprecated Use summarizeDiscoverableTools */
+export declare function summarizeDiscoverableMCPTools(tools: DiscoverableMCPTool[]): DiscoverableMCPToolSummary;
+/** @deprecated Use buildDiscoverableToolSearchIndex.
+ *  Builds an index whose documents preserve the legacy `description` field on each tool while
+ *  also carrying the generic `summary` (set from `description`) so the index remains usable
+ *  with `searchDiscoverableTools`. */
+export declare function buildDiscoverableMCPSearchIndex(tools: Iterable<DiscoverableMCPTool>): DiscoverableMCPSearchIndex;
+/** @deprecated Use searchDiscoverableTools */
+export declare function searchDiscoverableMCPTools(index: DiscoverableMCPSearchIndex | DiscoverableToolSearchIndex, query: string, limit: number): DiscoverableMCPSearchResult[];
+/** @deprecated Use formatDiscoverableToolServerSummary */
+export declare const formatDiscoverableMCPToolServerSummary: typeof formatDiscoverableToolServerSummary;

package/dist/types/tools/archive-reader.d.ts

@@ -0,0 +1,40 @@
+export type ArchiveFormat = "zip" | "tar" | "tar.gz";
+export interface ArchivePathCandidate {
+    archivePath: string;
+    subPath: string;
+}
+export interface ArchiveNode {
+    path: string;
+    isDirectory: boolean;
+    size: number;
+    mtimeMs?: number;
+}
+export interface ArchiveDirectoryEntry extends ArchiveNode {
+    name: string;
+}
+export interface ExtractedArchiveFile extends ArchiveNode {
+    bytes: Uint8Array;
+}
+interface TarStorage {
+    type: "tar";
+    file: File;
+}
+interface ZipStorage {
+    type: "zip";
+    bytes: Uint8Array;
+}
+type EntryStorage = TarStorage | ZipStorage;
+interface ArchiveIndexEntry extends ArchiveNode {
+    storage?: EntryStorage;
+}
+export declare function parseArchivePathCandidates(filePath: string): ArchivePathCandidate[];
+export declare class ArchiveReader {
+    #private;
+    readonly format: ArchiveFormat;
+    constructor(format: ArchiveFormat, entries: ArchiveIndexEntry[]);
+    getNode(subPath?: string): ArchiveNode | undefined;
+    listDirectory(subPath?: string): ArchiveDirectoryEntry[];
+    readFile(subPath: string): Promise<ExtractedArchiveFile>;
+}
+export declare function openArchive(filePath: string): Promise<ArchiveReader>;
+export {};

package/dist/types/tools/ask-answer-registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Process-wide registry mapping a session id to its active {@link AskAnswerSource}.
+ *
+ * Decouples the `ask` tool (which reads the source via `AgentSession`) from the
+ * notifications extension (which registers one), without threading a new method
+ * through the extension/runner/controller wiring. A session has at most one
+ * source; registering returns a disposer.
+ */
+import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
+import type { AskAnswerSource } from "./index";
+/** Register `source` for `sessionId`. Returns a disposer that clears it. */
+export declare function registerAskAnswerSource(sessionId: string, source: AskAnswerSource): () => void;
+/** The answer source for `sessionId`, if one is registered. */
+export declare function getAskAnswerSource(sessionId: string): AskAnswerSource | undefined;
+/** Publish a session's current workflow-gate emitter after mode initialization. */
+export declare function notifyWorkflowGateEmitterChanged(sessionId: string, emitter: WorkflowGateEmitter | undefined): void;
+/** Observe workflow-gate emitter installation even when it occurs after session_start. */
+export declare function registerWorkflowGateEmitterListener(sessionId: string, listener: (emitter: WorkflowGateEmitter | undefined) => void): () => void;

package/dist/types/tools/ask.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Ask Tool - Interactive user prompting during execution
+ *
+ * Use this tool when you need to ask the user questions during execution.
+ * This allows you to:
+ *   1. Gather user preferences or requirements
+ *   2. Clarify ambiguous instructions
+ *   3. Get decisions on implementation choices as you work
+ *   4. Offer choices to the user about what direction to take
+ *
+ * Usage notes:
+ *   - Users will always be able to select "Other" to provide custom text input
+ *   - Use multi: true to allow multiple answers to be selected for a question
+ *   - Use recommended: <index> to mark the default option; "(Recommended)" suffix is added automatically
+ *   - Questions may time out and auto-select the recommended option (configurable, disabled in plan mode)
+ */
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import { type Component } from "@sayknow-cli/tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+export declare const askSchema: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$strip>>;
+        multi: z.ZodOptional<z.ZodBoolean>;
+        recommended: z.ZodOptional<z.ZodNumber>;
+        deepInterview: z.ZodOptional<z.ZodObject<{
+            round_id: z.ZodOptional<z.ZodString>;
+            round: z.ZodNumber;
+            component: z.ZodString;
+            dimension: z.ZodString;
+            ambiguity: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AskToolInput = z.infer<typeof askSchema>;
+/** Result for a single question */
+export interface QuestionResult {
+    id: string;
+    question: string;
+    options: string[];
+    multi: boolean;
+    selectedOptions: string[];
+    customInput?: string;
+}
+export interface AskToolDetails {
+    question?: string;
+    options?: string[];
+    multi?: boolean;
+    selectedOptions?: string[];
+    customInput?: string;
+    /** Multi-part question mode */
+    results?: QuestionResult[];
+}
+type AskParams = AskToolInput;
+/**
+ * Ask tool for interactive user prompting during execution.
+ *
+ * Allows gathering user preferences, clarifying instructions, and getting decisions
+ * on implementation choices as the agent works.
+ */
+export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "ask";
+    readonly label = "Ask";
+    readonly summary = "Ask the user a clarifying question";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            question: z.ZodString;
+            options: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+            }, z.core.$strip>>;
+            multi: z.ZodOptional<z.ZodBoolean>;
+            recommended: z.ZodOptional<z.ZodNumber>;
+            deepInterview: z.ZodOptional<z.ZodObject<{
+                round_id: z.ZodOptional<z.ZodString>;
+                round: z.ZodNumber;
+                component: z.ZodString;
+                dimension: z.ZodString;
+                ambiguity: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): AskTool | null;
+    execute(_toolCallId: string, params: AskParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AskToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<AskToolDetails>>;
+}
+interface AskRenderArgs {
+    question?: string;
+    options?: Array<{
+        label: string;
+    }>;
+    multi?: boolean;
+    questions?: Array<{
+        id: string;
+        question: string;
+        options: Array<{
+            label: string;
+        }>;
+        multi?: boolean;
+    }>;
+}
+export declare const askToolRenderer: {
+    renderCall(args: AskRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: AskToolDetails;
+    }, _options: RenderResultOptions, uiTheme: Theme): Component;
+};
+export {};

package/dist/types/tools/ast-edit.d.ts

@@ -0,0 +1,77 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import type { Component } from "@sayknow-cli/tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+import type { OutputMeta } from "./output-meta";
+declare const astEditSchema: z.ZodObject<{
+    ops: z.ZodArray<z.ZodObject<{
+        pat: z.ZodString;
+        out: z.ZodString;
+    }, z.core.$strip>>;
+    paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export interface AstEditToolDetails {
+    totalReplacements: number;
+    filesTouched: number;
+    filesSearched: number;
+    applied: boolean;
+    limitReached: boolean;
+    parseErrors?: string[];
+    /** Total parse error count before {@link PARSE_ERRORS_LIMIT} capping. Omitted when no errors. */
+    parseErrorsTotal?: number;
+    scopePath?: string;
+    files?: string[];
+    fileReplacements?: Array<{
+        path: string;
+        count: number;
+    }>;
+    meta?: OutputMeta;
+    /** Pre-formatted text for the user-visible TUI render. Mirrors `result.text` lines but uses
+     * a `│` gutter (no model-only hashline anchors). The TUI uses this directly so it never parses model-facing text. */
+    displayContent?: string;
+    /** Absolute base directory used during the edit. Used by the renderer to resolve
+     * display-relative paths to absolute paths for OSC 8 hyperlinks. */
+    searchPath?: string;
+}
+export declare class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolDetails> {
+    private readonly session;
+    readonly name = "ast_edit";
+    readonly label = "AST Edit";
+    readonly summary = "Perform AST-aware code edits (structural refactoring)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        ops: z.ZodArray<z.ZodObject<{
+            pat: z.ZodString;
+            out: z.ZodString;
+        }, z.core.$strip>>;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly deferrable = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: z.infer<typeof astEditSchema>, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstEditToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstEditToolDetails>>;
+}
+interface AstEditRenderArgs {
+    ops?: Array<{
+        pat?: string;
+        out?: string;
+    }>;
+    paths?: string[];
+}
+export declare const astEditToolRenderer: {
+    inline: boolean;
+    renderCall(args: AstEditRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: AstEditToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: AstEditRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/ast-grep.d.ts

@@ -0,0 +1,69 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import type { Component } from "@sayknow-cli/tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+import type { OutputMeta } from "./output-meta";
+declare const astGrepSchema: z.ZodObject<{
+    pat: z.ZodString;
+    paths: z.ZodArray<z.ZodString>;
+    skip: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, z.core.$strip>;
+export interface AstGrepToolDetails {
+    matchCount: number;
+    fileCount: number;
+    filesSearched: number;
+    limitReached: boolean;
+    parseErrors?: string[];
+    /** Total parse error count before {@link PARSE_ERRORS_LIMIT} capping. Omitted when no errors. */
+    parseErrorsTotal?: number;
+    scopePath?: string;
+    files?: string[];
+    fileMatches?: Array<{
+        path: string;
+        count: number;
+    }>;
+    meta?: OutputMeta;
+    /** Pre-formatted text for the user-visible TUI render. Mirrors `result.text` lines but uses
+     * a `│` gutter and `*` to mark match lines. The TUI uses this directly so it never parses model-facing text. */
+    displayContent?: string;
+    /** Absolute base directory used during search. Used by the renderer to resolve
+     * display-relative paths to absolute paths for OSC 8 hyperlinks. */
+    searchPath?: string;
+}
+export declare class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolDetails> {
+    private readonly session;
+    readonly name = "ast_grep";
+    readonly label = "AST Grep";
+    readonly summary = "Search code with AST patterns (structural grep)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        pat: z.ZodString;
+        paths: z.ZodArray<z.ZodString>;
+        skip: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: z.infer<typeof astGrepSchema>, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstGrepToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstGrepToolDetails>>;
+}
+interface AstGrepRenderArgs {
+    pat?: string;
+    paths?: string[];
+    skip?: number;
+}
+export declare const astGrepToolRenderer: {
+    inline: boolean;
+    renderCall(args: AstGrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: AstGrepToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: AstGrepRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/auto-generated-guard.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Check if a file is auto-generated by examining its content.
+ * Throws ToolError if the file appears to be auto-generated.
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param displayPath - Path to show in error messages (relative or as provided)
+ */
+export declare function assertEditableFile(absolutePath: string, displayPath?: string): Promise<void>;
+/**
+ * Check if file content is auto-generated.
+ * Uses only the first CHECK_BYTE_COUNT characters of the content.
+ * Throws ToolError if the content appears to be auto-generated.
+ *
+ * @param content - File content to check (can be full content or prefix)
+ * @param displayPath - Path to show in error messages
+ */
+export declare function assertEditableFileContent(content: string, displayPath: string): void;

package/dist/types/tools/bash-allowed-prefixes.d.ts

@@ -0,0 +1,10 @@
+export interface BashAllowedPrefixesCheck {
+    allowed: boolean;
+    reason?: string;
+}
+export type BashRestrictionProfile = "workflow" | "read-only";
+export interface BashRestrictionOptions {
+    profile?: BashRestrictionProfile;
+}
+export declare function normalizeReadOnlyBashCommand(command: string): string | undefined;
+export declare function checkBashAllowedPrefixes(command: string, allowedPrefixes: readonly string[] | undefined, options?: BashRestrictionOptions): BashAllowedPrefixesCheck;

package/dist/types/tools/bash-command-fixup.d.ts

@@ -0,0 +1,11 @@
+export interface BashFixupResult {
+    /** Possibly-rewritten command. */
+    command: string;
+    /** Substrings that were stripped, in the order they were removed. */
+    stripped: string[];
+}
+/**
+ * Apply both fixups to a bash command. On any parse failure, multi-line input,
+ * or no-op transform, returns the input verbatim with `stripped: []`.
+ */
+export declare function applyBashFixups(command: string): BashFixupResult;

package/dist/types/tools/bash-interactive.d.ts

@@ -0,0 +1,16 @@
+import type { AgentToolContext } from "@sayknow-cli/agent-core";
+import { type OutputSummary } from "../session/streaming-output";
+export interface BashInteractiveResult extends OutputSummary {
+    exitCode: number | undefined;
+    cancelled: boolean;
+    timedOut: boolean;
+}
+export declare function runInteractiveBashPty(ui: NonNullable<AgentToolContext["ui"]>, options: {
+    command: string;
+    cwd: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    env?: Record<string, string>;
+    artifactPath?: string;
+    artifactId?: string;
+}): Promise<BashInteractiveResult>;

package/dist/types/tools/bash-interceptor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Bash intent interceptor - redirects common shell patterns to proper tools.
+ *
+ * When an LLM calls bash with patterns like `grep`, `cat`, `find`, etc.,
+ * this interceptor provides helpful error messages directing them to use
+ * the specialized tools instead.
+ */
+import { type BashInterceptorRule } from "../config/settings-schema";
+export interface InterceptionResult {
+    /** If true, the bash command should be blocked */
+    block: boolean;
+    /** Error message to return instead of executing */
+    message?: string;
+    /** Suggested tool to use instead */
+    suggestedTool?: string;
+}
+/**
+ * Check if a bash command should be intercepted.
+ *
+ * @param command The bash command to check
+ * @param availableTools Set of tool names that are available
+ * @returns InterceptionResult indicating if the command should be blocked
+ */
+export declare function checkBashInterception(command: string, availableTools: string[], rules?: BashInterceptorRule[]): InterceptionResult;

package/dist/types/tools/bash-pty-selection.d.ts

@@ -0,0 +1,7 @@
+/** Minimal UI-capability fields needed to decide whether bash can use the local PTY overlay. */
+export interface BashPtyContext {
+    hasUI?: boolean;
+    ui?: unknown;
+}
+/** Return whether a bash tool call should use the local interactive PTY overlay. */
+export declare function canUseInteractiveBashPty(pty: boolean, ctx: BashPtyContext | undefined): boolean;

package/dist/types/tools/bash-skill-urls.d.ts

@@ -0,0 +1,31 @@
+import type { Skill } from "../extensibility/skills";
+import { type LocalProtocolOptions } from "../internal-urls";
+import type { InternalResource } from "../internal-urls/types";
+interface InternalUrlResolver {
+    canHandle(input: string): boolean;
+    resolve(input: string): Promise<InternalResource>;
+}
+export interface InternalUrlExpansionOptions {
+    skills: readonly Skill[];
+    noEscape?: boolean;
+    internalRouter?: InternalUrlResolver;
+    localOptions?: LocalProtocolOptions;
+    ensureLocalParentDirs?: boolean;
+}
+/**
+ * Resolve a single skill:// URL to its absolute filesystem path.
+ * Does NOT read file content or verify existence.
+ */
+export declare function resolveSkillUrlToPath(url: string, skills: readonly Skill[]): string;
+/**
+ * Expand all skill:// URIs in a bash command string.
+ * Returns the command with URIs replaced by shell-escaped absolute paths.
+ * Throws ToolError if any URI cannot be resolved.
+ */
+export declare function expandSkillUrls(command: string, skills: readonly Skill[]): string;
+/**
+ * Expand supported internal URLs in a bash command string to shell-escaped absolute paths.
+ * Supported schemes: skill://, agent://, artifact://, memory://, rule://, local://
+ */
+export declare function expandInternalUrls(command: string, options: InternalUrlExpansionOptions): Promise<string>;
+export {};