@sayknow-cli/coding-agent 0.4.2 → 0.4.3

package/dist/types/tools/recipe/runners/cargo.d.ts

@@ -0,0 +1,16 @@
+import type { RunnerTask, TaskRunner } from "../runner";
+export interface CargoMetadataTarget {
+    kind?: string[];
+    name?: string;
+}
+export interface CargoMetadataPackage {
+    id?: string;
+    name?: string;
+    targets?: CargoMetadataTarget[];
+}
+export interface CargoMetadata {
+    packages?: CargoMetadataPackage[];
+    workspace_members?: string[];
+}
+export declare function tasksFromCargoMetadata(metadata: CargoMetadata): RunnerTask[];
+export declare const cargoRunner: TaskRunner;

package/dist/types/tools/recipe/runners/index.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const RUNNERS: TaskRunner[];

package/dist/types/tools/recipe/runners/just.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const justRunner: TaskRunner;

package/dist/types/tools/recipe/runners/make.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const makeRunner: TaskRunner;

package/dist/types/tools/recipe/runners/pkg.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const pkgRunner: TaskRunner;

package/dist/types/tools/recipe/runners/task.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const taskRunner: TaskRunner;

package/dist/types/tools/render-mermaid.d.ts

@@ -0,0 +1,37 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from "./index";
+declare const renderMermaidSchema: z.ZodObject<{
+    mermaid: z.ZodString;
+    config: z.ZodOptional<z.ZodObject<{
+        useAscii: z.ZodOptional<z.ZodBoolean>;
+        paddingX: z.ZodOptional<z.ZodNumber>;
+        paddingY: z.ZodOptional<z.ZodNumber>;
+        boxBorderPadding: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type RenderMermaidParams = z.infer<typeof renderMermaidSchema>;
+export interface RenderMermaidToolDetails {
+    artifactId?: string;
+}
+export declare class RenderMermaidTool implements AgentTool<typeof renderMermaidSchema, RenderMermaidToolDetails> {
+    private readonly session;
+    readonly name = "render_mermaid";
+    readonly label = "RenderMermaid";
+    readonly summary = "Render a Mermaid diagram to an image";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        mermaid: z.ZodString;
+        config: z.ZodOptional<z.ZodObject<{
+            useAscii: z.ZodOptional<z.ZodBoolean>;
+            paddingX: z.ZodOptional<z.ZodNumber>;
+            paddingY: z.ZodOptional<z.ZodNumber>;
+            boxBorderPadding: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: RenderMermaidParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<RenderMermaidToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<RenderMermaidToolDetails>>;
+}
+export {};

package/dist/types/tools/render-utils.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Shared utilities and constants for tool renderers.
+ *
+ * Provides consistent formatting, truncation, and display patterns across all
+ * tool renderers to ensure a unified TUI experience.
+ */
+import type { ToolCallContext } from "@sayknow-cli/agent-core";
+import type { Ellipsis } from "@sayknow-cli/natives";
+import type { Component } from "@sayknow-cli/tui";
+import type { Theme } from "../modes/theme/theme";
+import { type ResizedImage } from "../utils/image-resize";
+export { Ellipsis } from "@sayknow-cli/natives";
+export { replaceTabs, truncateToWidth, wrapTextWithAnsi } from "@sayknow-cli/tui";
+/** Resolve inline image dimension caps from settings and viewport. */
+export declare function resolveImageOptions(): {
+    maxWidthCells: number;
+    maxHeightCells?: number;
+};
+/** Preview limits for collapsed/expanded views */
+export declare const PREVIEW_LIMITS: {
+    /** Lines shown in collapsed view */
+    readonly COLLAPSED_LINES: 3;
+    /** Lines shown in expanded view */
+    readonly EXPANDED_LINES: 12;
+    /** Items (files, results) shown in collapsed view */
+    readonly COLLAPSED_ITEMS: 8;
+    /** Output preview lines in collapsed view */
+    readonly OUTPUT_COLLAPSED: 3;
+    /** Output preview lines in expanded view */
+    readonly OUTPUT_EXPANDED: 10;
+    /** Max hunks shown when collapsed (edit tool) */
+    readonly DIFF_COLLAPSED_HUNKS: 8;
+    /** Max diff lines shown when collapsed (edit tool) */
+    readonly DIFF_COLLAPSED_LINES: 40;
+};
+/** Truncation lengths for different content types */
+export declare const TRUNCATE_LENGTHS: {
+    /** Short titles, labels */
+    readonly TITLE: 60;
+    /** Medium-length content (messages, previews) */
+    readonly CONTENT: 80;
+    /** Longer content (code, explanations) */
+    readonly LONG: 100;
+    /** Full line content */
+    readonly LINE: 110;
+    /** Very short (task previews, badges) */
+    readonly SHORT: 40;
+};
+/** Standard expand hint text */
+export declare const EXPAND_HINT = "(Ctrl+O for more)";
+/**
+ * Get first N lines of text as preview, with each line truncated.
+ */
+export declare function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[];
+/**
+ * Extract domain from URL, stripping www. prefix.
+ */
+export declare function getDomain(url: string): string;
+export { formatAge, formatBytes, formatCount, formatDuration, pluralize } from "@sayknow-cli/utils";
+/**
+ * Get the appropriate status icon with color for a given state.
+ * Standardizes status icon usage across all renderers.
+ */
+export declare function formatStatusIcon(status: ToolUIStatus, theme: Theme, spinnerFrame?: number): string;
+/**
+ * Format the expand hint with proper theming.
+ * Returns empty string if already expanded or there is nothing more to show.
+ */
+export declare function formatExpandHint(theme: Theme, expanded?: boolean, hasMore?: boolean): string;
+/**
+ * Format a badge like [done] or [failed] with brackets and color.
+ */
+export declare function formatBadge(label: string, color: ToolUIColor, theme: Theme): string;
+/**
+ * Build a "more items" suffix line for truncated lists.
+ * Uses consistent wording pattern.
+ */
+export declare function formatMoreItems(remaining: number, itemType: string): string;
+export declare function formatMeta(meta: string[], theme: Theme): string;
+export declare function formatErrorMessage(message: string | undefined, theme: Theme): string;
+export declare function formatEmptyMessage(message: string, theme: Theme): string;
+export type CodeFrameMarker = "" | " " | "*" | "+" | "-" | ">";
+export declare function formatCodeFrameLine(marker: CodeFrameMarker, lineNumber: string | number, content: string, lineNumberWidth: number): string;
+export type ToolUIStatus = "success" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
+export type ToolUIColor = "success" | "error" | "warning" | "accent" | "muted";
+export interface ToolUITitleOptions {
+    bold?: boolean;
+}
+export declare function formatTitle(label: string, theme: Theme, options?: ToolUITitleOptions): string;
+export declare function formatDiagnostics(diag: {
+    errored: boolean;
+    summary: string;
+    messages: string[];
+}, expanded: boolean, theme: Theme, getLangIcon: (filePath: string) => string): string;
+export interface DiffStats {
+    added: number;
+    removed: number;
+    hunks: number;
+    lines: number;
+}
+export declare function getDiffStats(diffText: string): DiffStats;
+export declare function formatDiffStats(added: number, removed: number, hunks: number, theme: Theme): string;
+export declare function truncateDiffByHunk(diffText: string, maxHunks: number, maxLines: number): {
+    text: string;
+    hiddenHunks: number;
+    hiddenLines: number;
+};
+export declare function shortenPath(filePath: string, homeDir?: string): string;
+export declare function formatToolWorkingDirectory(workdir: string | undefined, projectDir: string): string | undefined;
+export declare function formatScreenshot(opts: {
+    saveFullRes: boolean;
+    savedMimeType: string;
+    savedByteLength: number;
+    dest: string;
+    resized: ResizedImage;
+}): string[];
+export declare function wrapBrackets(text: string, theme: Theme): string;
+export declare const PARSE_ERRORS_LIMIT = 20;
+export declare function dedupeParseErrors(errors: string[] | undefined): string[];
+export declare function formatParseErrors(errors: string[], total?: number): string[];
+/**
+ * Cap an upstream parse-error list to {@link PARSE_ERRORS_LIMIT} unique entries,
+ * preserving the original deduplicated total. Use this at the source so tool
+ * details never carry thousands of per-file parse errors into traces or
+ * renderers.
+ */
+export declare function capParseErrors(errors: string[] | undefined, limit?: number): {
+    errors: string[];
+    total: number;
+};
+/**
+ * Group `rawLines` by blank-line separators, mirroring the historical search /
+ * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
+ * runs of blank lines; otherwise collapses non-empty lines into a single group.
+ */
+export declare function splitGroupsByBlankLine(rawLines: string[]): string[][];
+/**
+ * Standard width+expand keyed render cache used by every search-style tool
+ * renderer. `compute` re-runs only when the cache key changes; the returned
+ * Component is the canonical `{ render, invalidate }` pair.
+ */
+export declare function createCachedComponent(getExpanded: () => boolean, compute: (width: number, expanded: boolean) => string[]): Component;
+/**
+ * Append the indented bullet list of parse errors (capped at
+ * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the
+ * total exceeds the cap. No-op when `parseErrors` is empty.
+ */
+export declare function appendParseErrorsBulletList(lines: string[], parseErrors: readonly string[] | undefined, theme: Theme, total?: number): void;
+/**
+ * Human-readable summary string for the parse-issues count, capped by
+ * {@link PARSE_ERRORS_LIMIT}.
+ */
+export declare function formatParseErrorsCountLabel(parseErrors: readonly string[], total?: number): string;
+export interface LspBatchRequest {
+    id: string;
+    flush: boolean;
+}
+export declare function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined;

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

@@ -0,0 +1,26 @@
+/**
+ * TUI renderers for built-in tools.
+ *
+ * These provide rich visualization for tool calls and results in the TUI.
+ */
+import type { Component } from "@sayknow-cli/tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+type ToolRenderer = {
+    renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
+    renderResult: (result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: unknown;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: Record<string, unknown>;
+    }, theme: Theme, args?: unknown) => Component;
+    mergeCallAndResult?: boolean;
+    /** Render without background box, inline in the response flow */
+    inline?: boolean;
+};
+export declare const toolRenderers: Record<string, ToolRenderer>;
+export {};

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

@@ -0,0 +1,80 @@
+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 ".";
+declare const resolveSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        discard: "discard";
+        apply: "apply";
+    }>;
+    reason: z.ZodString;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ResolveParams = z.infer<typeof resolveSchema>;
+export interface ResolveToolDetails {
+    action: "apply" | "discard";
+    reason: string;
+    extra?: Record<string, unknown>;
+    sourceToolName?: string;
+    label?: string;
+    sourceResultDetails?: unknown;
+}
+export declare function queueResolveHandler(session: ToolSession, options: {
+    label: string;
+    sourceToolName: string;
+    apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+}): void;
+/**
+ * Shared invocation runner used by both queued (in-flight) handlers and
+ * standing handlers (e.g. plan-mode approval). Discriminates on action,
+ * routes through the caller's apply/reject, and wraps the resulting tool
+ * payload with `ResolveToolDetails` so the renderer and event-controller
+ * see a consistent shape.
+ */
+export declare function runResolveInvocation(params: ResolveParams, options: {
+    sourceToolName: string;
+    label: string;
+    apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+    /** Invoked synchronously when `apply()` throws, before the error is rethrown.
+     *  The queued caller uses this to re-push the resolve directive so the
+     *  pending preview survives a failed apply (e.g. overlapping ast_edit
+     *  replacements) and the model can `discard` or fix-and-retry. */
+    onApplyError?(error: unknown): void;
+}): Promise<AgentToolResult<ResolveToolDetails>>;
+export declare class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
+    private readonly session;
+    readonly name = "resolve";
+    readonly label = "Resolve";
+    readonly hidden = true;
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        action: z.ZodEnum<{
+            discard: "discard";
+            apply: "apply";
+        }>;
+        reason: z.ZodString;
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly intent: (args: Partial<ResolveParams>) => string;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: ResolveParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ResolveToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<ResolveToolDetails>>;
+}
+export declare const resolveToolRenderer: {
+    renderCall(args: ResolveParams, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: ResolveToolDetails;
+        isError?: boolean;
+    }, _options: RenderResultOptions, uiTheme: Theme): Component;
+    inline: boolean;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/resource-gc.d.ts

@@ -0,0 +1,68 @@
+import type { Settings } from "../config/settings";
+import { type TabGcSnapshot } from "./browser/tab-supervisor";
+export interface BrowserGcPolicy {
+    enabled: boolean;
+    idleMs: number;
+    rssLimitBytes: number;
+}
+export interface ComputerGcPolicy {
+    enabled: boolean;
+    staleMs: number;
+    scanIntervalMs: number;
+}
+export declare function resolveBrowserGcPolicy(settings: Settings): BrowserGcPolicy;
+export declare function resolveComputerGcPolicy(settings: Settings): ComputerGcPolicy;
+export declare function resolveSweepIntervalMs(settings: Settings): number;
+/** Injectable seams so the controller is fully testable without real browsers/filesystem/RSS. */
+export interface ResourceGcDeps {
+    now: () => number;
+    rssBytes: () => number;
+    logWarn: (msg: string, meta?: Record<string, unknown>) => void;
+    listTabs: () => TabGcSnapshot[];
+    releaseTab: (name: string, policy: {
+        now: () => number;
+        idleMs: number;
+    }) => Promise<boolean>;
+    cleanupScreenshots: (opts: {
+        now: () => number;
+        staleMs: number;
+    }) => Promise<{
+        scanned: number;
+        removed: number;
+    }>;
+    screenshotArmed: () => boolean;
+}
+export interface ResourceGcRegistration {
+    sessionId: string;
+    settings: Settings;
+}
+/**
+ * Register a session with the resource GC. Starts the single shared timer on the first
+ * registration. Returns an idempotent unregister function; the timer stops only when the last
+ * session unregisters.
+ */
+export declare function registerResourceGcSession(reg: ResourceGcRegistration): () => void;
+export declare function sweepOnce(d?: ResourceGcDeps): Promise<void>;
+export declare function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>): void;
+export declare function __setResourceGcSchedulerNowForTest(now: () => number): void;
+export declare function __runResourceGcTickForTest(): Promise<void>;
+export declare function __runResourceGcTimerCallbackForTest(owner: {
+    generation: number;
+    token: number;
+}, deadline: number): Promise<void>;
+export declare function __getResourceGcStateForTest(): {
+    timerActive: boolean;
+    sessionCount: number;
+    rssWarningActive: boolean;
+    inProgress: boolean;
+    generation: number;
+    pendingDeadline: number | null;
+    pendingOwner: {
+        generation: number;
+        token: number;
+    } | null;
+    deferredDeadline: number | null;
+    deferredGeneration: number | null;
+    activeGeneration: number | null;
+};
+export declare function __resetResourceGcForTest(): void;

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

@@ -0,0 +1,63 @@
+/**
+ * Review tools - report_finding for structured code review.
+ *
+ * Used by the reviewer agent to report findings in a structured way.
+ * Hidden by default - only enabled when explicitly listed in agent's tools.
+ * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
+ */
+import type { AgentTool } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
+import type { ReviewFinding } from "../task/types";
+export type FindingPriority = "P0" | "P1" | "P2" | "P3";
+export interface FindingPriorityInfo {
+    ord: 0 | 1 | 2 | 3;
+    symbol: "status.error" | "status.warning" | "status.info";
+    color: ThemeColor;
+}
+export declare const PRIORITY_LABELS: FindingPriority[];
+export declare function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo;
+declare const ReportFindingParams: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    priority: z.ZodEnum<{
+        P0: "P0";
+        P1: "P1";
+        P2: "P2";
+        P3: "P3";
+    }>;
+    confidence: z.ZodNumber;
+    file_path: z.ZodString;
+    line_start: z.ZodNumber;
+    line_end: z.ZodNumber;
+}, z.core.$strict>;
+interface ReportFindingDetails {
+    title: string;
+    body: string;
+    priority: FindingPriority;
+    confidence: number;
+    file_path: string;
+    line_start: number;
+    line_end: number;
+}
+export declare function parseReportFindingDetails(value: unknown): ReportFindingDetails | undefined;
+export declare const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme>;
+/** SubmitReviewDetails - used for rendering review results from yield tool */
+export interface SubmitReviewDetails {
+    overall_correctness: "correct" | "incorrect";
+    explanation: string;
+    confidence: number;
+}
+export type { ReportFindingDetails };
+/**
+ * Coerce a tool-side `ReportFindingDetails` into the cross-boundary
+ * `ReviewFinding` shape consumed by the reviewer agent's JTD output schema.
+ *
+ * The `report_finding` tool exposes `priority` as a string enum (`"P0".."P3"`)
+ * for ergonomics, but the bundled reviewer schema (and every custom review
+ * agent that mirrors it) declares `priority: number`. Without this coercion
+ * the auto-populated `findings[]` fails JTD validation and every review run
+ * that surfaces a finding is rejected with `findings.0.priority: expected
+ * number, received string`.
+ */
+export declare function toReviewFinding(details: ReportFindingDetails): ReviewFinding;

package/dist/types/tools/search-tool-bm25.d.ts

@@ -0,0 +1,64 @@
+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 ".";
+declare const searchToolBm25Schema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SearchToolBm25Params = z.infer<typeof searchToolBm25Schema>;
+interface SearchToolBm25Match {
+    name: string;
+    label: string;
+    description: string;
+    server_name?: string;
+    mcp_tool_name?: string;
+    schema_keys: string[];
+    score: number;
+}
+export interface SearchToolBm25Details {
+    query: string;
+    limit: number;
+    total_tools: number;
+    activated_tools: string[];
+    active_selected_tools: string[];
+    tools: SearchToolBm25Match[];
+}
+export declare function renderSearchToolBm25Description(): string;
+/**
+ * SearchToolsTool — wire name `search_tool_bm25` (preserved for persisted session back-compat).
+ *
+ * When tools.discoveryMode === "all", this covers both MCP tools and built-in discoverable tools.
+ * When tools.discoveryMode === "mcp-only" or mcp.discoveryMode === true, only MCP tools are searched.
+ */
+export declare class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema, SearchToolBm25Details> {
+    private readonly session;
+    readonly name = "search_tool_bm25";
+    readonly label = "SearchTools";
+    readonly loadMode = "essential";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        query: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): SearchToolBm25Tool | null;
+    execute(_toolCallId: string, params: SearchToolBm25Params, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<SearchToolBm25Details>, _context?: AgentToolContext): Promise<AgentToolResult<SearchToolBm25Details>>;
+}
+export declare const searchToolBm25Renderer: {
+    renderCall(args: SearchToolBm25Params, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SearchToolBm25Details;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme): Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};
+export {};

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

@@ -0,0 +1,93 @@
+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 TruncationResult } from "../session/streaming-output";
+import type { ToolSession } from ".";
+import { type OutputMeta } from "./output-meta";
+declare const searchSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    i: z.ZodOptional<z.ZodBoolean>;
+    gitignore: z.ZodOptional<z.ZodBoolean>;
+    skip: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type SearchToolInput = z.infer<typeof searchSchema>;
+/** Maximum number of distinct files surfaced in a single response. The
+ * agent paginates further pages via `skip`. */
+export declare const DEFAULT_FILE_LIMIT = 20;
+/** Per-file match cap for multi-file searches — keeps a single hot file
+ * from crowding out diverse hits. Applied in JS after grep returns. */
+export declare const MULTI_FILE_PER_FILE_MATCHES = 20;
+/** Per-file match cap for single-file searches — there's no diversity
+ * concern when the scope is one file. */
+export declare const SINGLE_FILE_MATCHES = 200;
+export interface SearchToolDetails {
+    truncation?: TruncationResult;
+    fileLimitReached?: number;
+    perFileLimitReached?: number;
+    linesTruncated?: boolean;
+    meta?: OutputMeta;
+    scopePath?: string;
+    matchCount?: number;
+    fileCount?: number;
+    files?: string[];
+    fileMatches?: Array<{
+        path: string;
+        count: number;
+    }>;
+    truncated?: boolean;
+    error?: string;
+    /** Pre-formatted text for the user-visible TUI render. Mirrors the model-facing
+     * `result.text` lines but uses a `│` gutter and `*` to mark match lines (vs space for
+     * context). The TUI uses this directly so it never parses model-facing hashline anchors. */
+    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;
+    /** User-supplied paths whose base directory was missing on disk. The tool
+     * skipped these and continued with the surviving entries; surfaced as a
+     * non-fatal warning in the renderer and in the model-facing text. */
+    missingPaths?: string[];
+}
+type SearchParams = z.infer<typeof searchSchema>;
+export declare class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
+    private readonly session;
+    readonly name = "search";
+    readonly label = "Search";
+    readonly loadMode = "discoverable";
+    readonly summary = "Search file contents using ripgrep (fast text search)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        pattern: z.ZodString;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        i: z.ZodOptional<z.ZodBoolean>;
+        gitignore: z.ZodOptional<z.ZodBoolean>;
+        skip: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: SearchParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<SearchToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<SearchToolDetails>>;
+}
+interface SearchRenderArgs {
+    pattern: string;
+    paths?: string[];
+    i?: boolean;
+    gitignore?: boolean;
+    skip?: number;
+}
+export declare const searchToolRenderer: {
+    inline: boolean;
+    renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SearchToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: SearchRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/skill-discovery.d.ts

@@ -0,0 +1,40 @@
+import type { AgentTool, AgentToolResult } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import { type RuntimeSkillDiscoveryCandidate } from "../extensibility/runtime-skill-discovery";
+import type { ToolSession } from ".";
+declare const skillDiscoverySchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        user: "user";
+        project: "project";
+        all: "all";
+    }>>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, z.core.$strict>;
+export type SkillDiscoveryToolInput = z.infer<typeof skillDiscoverySchema>;
+export interface SkillDiscoveryToolDetails {
+    candidates: RuntimeSkillDiscoveryCandidate[];
+    count: number;
+}
+export declare class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema, SkillDiscoveryToolDetails> {
+    #private;
+    readonly name = "skill_discovery";
+    readonly label = "SkillDiscovery";
+    readonly summary = "Discover project and user runtime skills by thin metadata";
+    readonly loadMode = "essential";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        query: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            user: "user";
+            project: "project";
+            all: "all";
+        }>>>;
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strict>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): SkillDiscoveryTool | null;
+    execute(_toolCallId: string, input: SkillDiscoveryToolInput, signal?: AbortSignal): Promise<AgentToolResult<SkillDiscoveryToolDetails>>;
+}
+export {};