@sayknow-cli/coding-agent 0.3.6 → 0.3.8

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

@@ -0,0 +1,94 @@
+import * as natives from "@sayknow-cli/natives";
+declare const IsoBackendKind: typeof natives.IsoBackendKind;
+type IsoBackendKind = natives.IsoBackendKind;
+/** Baseline state for a single git repository. */
+export interface RepoBaseline {
+    repoRoot: string;
+    headCommit: string;
+    staged: string;
+    unstaged: string;
+    untracked: string[];
+    untrackedPatch: string;
+}
+/** Baseline state for the project, including any nested git repos. */
+export interface WorktreeBaseline {
+    root: RepoBaseline;
+    /** Nested git repos (path relative to root.repoRoot). */
+    nested: Array<{
+        relativePath: string;
+        baseline: RepoBaseline;
+    }>;
+}
+export declare function getRepoRoot(cwd: string): Promise<string>;
+export declare function getGitNoIndexNullPath(): string;
+export declare function captureBaseline(repoRoot: string): Promise<WorktreeBaseline>;
+export interface NestedRepoPatch {
+    relativePath: string;
+    patch: string;
+}
+export interface DeltaPatchResult {
+    rootPatch: string;
+    nestedPatches: NestedRepoPatch[];
+}
+export declare function captureDeltaPatch(isolationDir: string, baseline: WorktreeBaseline): Promise<DeltaPatchResult>;
+/**
+ * Apply nested repo patches directly to their working directories after parent merge.
+ * @param commitMessage Optional async function to generate a commit message from the combined diff.
+ *                      If omitted or returns null, falls back to a generic message.
+ */
+export declare function applyNestedPatches(repoRoot: string, patches: NestedRepoPatch[], commitMessage?: (diff: string) => Promise<string | null>): Promise<void>;
+/**
+ * User-facing isolation mode names exposed by the `task.isolation.mode`
+ * setting. Mapped to a backend-kind hint via {@link parseIsolationMode};
+ * the PAL's `iso_resolve` then falls back through the kind order
+ * whenever the hint isn't available on the current host.
+ */
+export type TaskIsolationMode = "none" | "auto" | "apfs" | "btrfs" | "zfs" | "reflink" | "overlayfs" | "projfs" | "block-clone" | "rcopy" | "worktree" | "fuse-overlay" | "fuse-projfs";
+/**
+ * Translate a {@link TaskIsolationMode} string to an [`IsoBackendKind`]
+ * the PAL can act on. `"none"` returns `null` (caller skips isolation
+ * entirely); `"auto"` returns `undefined` (no hint — let the resolver
+ * pick). Anything else returns the matching kind.
+ */
+export declare function parseIsolationMode(mode: TaskIsolationMode): IsoBackendKind | undefined;
+export interface IsolationHandle {
+    /** Merged view materialised by the backend; pass this to the task. */
+    mergedDir: string;
+    /** Backend the PAL actually used. */
+    backend: IsoBackendKind;
+    /** True when the resolver downgraded from `preferred` to `backend`. */
+    fellBack: boolean;
+    /** Optional reason associated with `fellBack`. */
+    fallbackReason: string | null;
+}
+export declare function ensureIsolation(baseCwd: string, id: string, preferred?: IsoBackendKind): Promise<IsolationHandle>;
+/** Tear down a handle returned by {@link ensureIsolation}. */
+export declare function cleanupIsolation(handle: IsolationHandle): Promise<void>;
+export interface CommitToBranchResult {
+    branchName?: string;
+    nestedPatches: NestedRepoPatch[];
+}
+/**
+ * Commit task-only changes to a new branch.
+ * Only root repo changes go on the branch. Nested repo patches are returned
+ * separately since the parent git can't track files inside gitlinks.
+ */
+export declare function commitToBranch(isolationDir: string, baseline: WorktreeBaseline, taskId: string, description: string | undefined, commitMessage?: (diff: string) => Promise<string | null>): Promise<CommitToBranchResult | null>;
+export interface MergeBranchResult {
+    merged: string[];
+    failed: string[];
+    conflict?: string;
+}
+/**
+ * Cherry-pick task branch commits sequentially onto HEAD.
+ * Each branch has a single commit that gets replayed cleanly.
+ * Stops on first conflict and reports which branches succeeded.
+ */
+export declare function mergeTaskBranches(repoRoot: string, branches: Array<{
+    branchName: string;
+    taskId: string;
+    description?: string;
+}>): Promise<MergeBranchResult>;
+/** Clean up temporary task branches. */
+export declare function cleanupTaskBranches(repoRoot: string, branches: string[]): Promise<void>;
+export {};

package/dist/types/thinking-metadata.d.ts

@@ -0,0 +1,16 @@
+export type ThinkingLevelValue = "inherit" | "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/**
+ * Metadata used to render thinking selector values in the coding-agent UI.
+ *
+ * This module is intentionally provider/native-free so schema generation can
+ * import settings metadata before native addons have been built in CI.
+ */
+export interface ThinkingLevelMetadata {
+    value: ThinkingLevelValue;
+    label: string;
+    description: string;
+}
+/**
+ * Returns display metadata for a thinking selector.
+ */
+export declare function getThinkingLevelMetadata(level: ThinkingLevelValue): ThinkingLevelMetadata;

package/dist/types/thinking.d.ts

@@ -0,0 +1,22 @@
+import { type ResolvedThinkingLevel, ThinkingLevel } from "@sayknow-cli/agent-core/thinking";
+import { type Effort } from "@sayknow-cli/ai/model-thinking";
+import type { Model } from "@sayknow-cli/ai/types";
+export { getThinkingLevelMetadata, type ThinkingLevelMetadata } from "./thinking-metadata";
+/**
+ * Parses a provider-facing effort value.
+ */
+export declare function parseEffort(value: string | null | undefined): Effort | undefined;
+/**
+ * Parses an agent-local thinking selector.
+ */
+export declare function parseThinkingLevel(value: string | null | undefined): ThinkingLevel | undefined;
+/**
+ * Converts an agent-local selector into the effort sent to providers.
+ */
+export declare function toReasoningEffort(level: ThinkingLevel | undefined): Effort | undefined;
+/**
+ * Resolves a selector against the current model while preserving explicit "off".
+ */
+export declare function resolveThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ResolvedThinkingLevel | undefined;
+export declare function clampExplicitThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ThinkingLevel | undefined;
+export declare function formatClampedModelSelector(selector: string, model: Model | undefined): string;

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,13 @@
+/**
+ * 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 { 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;

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;