jeopi-cli 16.2.14 → 16.2.17

package/dist/types/tiny/title-client.d.ts

@@ -0,0 +1,68 @@
+import { type RefCountedWorkerHandle, type SpawnedSubprocess } from "../subprocess/worker-client";
+import type { TinyTitleProgressEvent, TinyTitleWorkerInbound, TinyTitleWorkerOutbound } from "./title-protocol";
+export interface TinyTitleDownloadResult {
+    ok: boolean;
+    error?: string;
+}
+export interface TinyTitleDownloadOptions {
+    signal?: AbortSignal;
+    onProgress?: (event: TinyTitleProgressEvent) => void;
+}
+/**
+ * Per-request controls for {@link TinyTitleClient.generate}.
+ *
+ * Carries the optional abort signal and title-system-prompt override used by
+ * callers that customize automatic session-title generation.
+ */
+export interface TinyTitleGenerateOptions {
+    signal?: AbortSignal;
+    systemPrompt?: string;
+}
+/**
+ * Hidden subcommand on the main CLI that boots the tiny-model worker in the
+ * spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
+ */
+export declare const TINY_WORKER_ARG = "__omp_worker_tiny_inference";
+/**
+ * Decide which `PI_TINY_DEVICE` / `PI_TINY_DTYPE` vars to overlay onto the worker
+ * env. A present env var wins (left untouched); otherwise the mapped persisted
+ * setting is used. Returns only the keys to add — never the default sentinel.
+ * Pure for testability; see {@link tinyWorkerEnv} for the spawn-time glue.
+ * @internal
+ */
+export declare function tinyWorkerEnvOverlay(env: Record<string, string | undefined>, deviceSetting: string | undefined, dtypeSetting: string | undefined): Record<string, string>;
+/**
+ * Env handed to the tiny-model subprocess — and reused verbatim by the STT and
+ * TTS workers, which share the same device/dtype resolution. The
+ * `PI_TINY_DEVICE` / `PI_TINY_DTYPE` env vars win; otherwise the persisted
+ * `providers.tinyModelDevice` / `providers.tinyModelDtype` settings are mapped
+ * onto those vars so the subprocess's env-based resolution picks them up.
+ * Resolved once at spawn (pipelines are cached for the lifetime of the
+ * subprocess).
+ */
+export declare function tinyWorkerEnv(): Record<string, string>;
+/**
+ * Spawn the tiny-model worker as a subprocess. Exported for tests and the
+ * smoke probe; production callers go through {@link spawnTinyTitleWorker}.
+ */
+export declare function createTinyTitleSubprocess(): SpawnedSubprocess<TinyTitleWorkerOutbound>;
+export declare class TinyTitleClient {
+    #private;
+    constructor(spawnWorker?: () => RefCountedWorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>);
+    onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
+    generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
+    generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;
+    complete(modelKey: string, prompt: string, options?: {
+        maxTokens?: number;
+        signal?: AbortSignal;
+    }): Promise<string | null>;
+    downloadModel(modelKey: string, options?: TinyTitleDownloadOptions): Promise<TinyTitleDownloadResult>;
+    terminate(): Promise<void>;
+}
+export declare const tinyTitleClient: TinyTitleClient;
+/** Alias for the shared tiny-model worker client (titles + memory completions). */
+export declare const tinyModelClient: TinyTitleClient;
+export declare function shutdownTinyTitleClient(): Promise<void>;
+export declare function smokeTestTinyTitleWorker({ timeoutMs, }?: {
+    timeoutMs?: number;
+}): Promise<void>;

package/dist/types/tiny/title-protocol.d.ts

@@ -0,0 +1,78 @@
+import type { TinyLocalModelKey, TinyTitleLocalModelKey } from "./models";
+export type TinyTitleProgressStatus = "initiate" | "download" | "progress" | "progress_total" | "done" | "ready" | "error";
+export interface TinyTitleProgressFileState {
+    loaded: number;
+    total: number;
+}
+export interface TinyTitleProgressEvent {
+    modelKey: TinyLocalModelKey;
+    status: TinyTitleProgressStatus;
+    name?: string;
+    file?: string;
+    progress?: number;
+    loaded?: number;
+    total?: number;
+    files?: Record<string, TinyTitleProgressFileState>;
+    task?: string;
+    model?: string;
+}
+export type TinyTitleWorkerInbound = {
+    type: "ping";
+    id: string;
+} | {
+    type: "generate";
+    id: string;
+    modelKey: TinyTitleLocalModelKey;
+    message: string;
+    systemPrompt?: string;
+} | {
+    type: "complete";
+    id: string;
+    modelKey: TinyLocalModelKey;
+    prompt: string;
+    maxTokens?: number;
+} | {
+    type: "download";
+    id: string;
+    modelKey: TinyLocalModelKey;
+};
+export type TinyTitleWorkerOutbound = {
+    type: "pong";
+    id: string;
+} | {
+    type: "title";
+    id: string;
+    title: string | null;
+} | {
+    type: "completion";
+    id: string;
+    text: string | null;
+} | {
+    type: "downloaded";
+    id: string;
+} | {
+    type: "error";
+    id: string;
+    error: string;
+} | {
+    type: "progress";
+    id: string;
+    event: TinyTitleProgressEvent;
+} | {
+    type: "log";
+    level: "debug" | "warn" | "error";
+    msg: string;
+    meta?: Record<string, unknown>;
+};
+/**
+ * Wire transport between the parent (`TinyTitleClient`) and the tiny-model
+ * subprocess. The parent owns the subprocess lifecycle (graceful work, hard
+ * kill on shutdown); the protocol therefore carries no explicit close
+ * handshake — once the parent decides to terminate, it signals the OS to
+ * reap the child so `onnxruntime-node`'s NAPI finalizer never runs in any
+ * shared address space. See `title-client.ts` for the spawn/kill glue.
+ */
+export interface TinyTitleTransport {
+    send(message: TinyTitleWorkerOutbound): void;
+    onMessage(handler: (message: TinyTitleWorkerInbound) => void): () => void;
+}

package/dist/types/tiny/worker.d.ts

@@ -0,0 +1,2 @@
+import type { TinyTitleTransport } from "./title-protocol";
+export declare function startTinyTitleWorker(transport: TinyTitleTransport): void;

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

@@ -0,0 +1,8 @@
+import type { Settings } from "../config/settings";
+import type { SettingValue } from "../config/settings-schema";
+export declare const TOOL_DISCOVERY_AUTO_THRESHOLD = 40;
+export declare const TOOL_DISCOVERY_SEARCH_TOOL_NAME = "search_tool_bm25";
+export type ToolDiscoveryModeSetting = SettingValue<"tools.discoveryMode">;
+export type EffectiveToolDiscoveryMode = Exclude<ToolDiscoveryModeSetting, "auto">;
+export declare function countToolsForAutoDiscovery(toolNames: Iterable<string>): number;
+export declare function resolveEffectiveToolDiscoveryMode(settings: Settings, toolCount: number): EffectiveToolDiscoveryMode;

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

@@ -0,0 +1,57 @@
+import type { AgentTool } from "jeopi-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;
+}
+export declare function isMCPToolName(name: string): 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[];

package/dist/types/tools/__tests__/eval-description.test.d.ts

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

package/dist/types/tools/__tests__/json-tree.test.d.ts

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

package/dist/types/tools/acp-bridge.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared ACP client bridge routing for file-write sites.
+ *
+ * When an ACP client (e.g. Zed) advertises the `fs.writeTextFile` capability,
+ * all write-mode tools must route through it so the editor's open buffer is
+ * updated immediately. Internal artifacts ('/Users/theo/.jeopi/agent/sessions/-Projects-oh-my-pi/2026-06-10T09-11-41-506Z_019eb0cd-3ec2-7000-92aa-1b82aa4d78f0/local' plan files, other scheme
+ * URLs) are always written directly to disk — those are OMP-owned and should
+ * never be pushed into the editor.
+ */
+import type { ToolSession } from ".";
+/**
+ * Return `true` when an ACP client bridge write is appropriate for this path.
+ *
+ * Returns `false` for internal-URL paths (e.g. `'/Users/theo/.jeopi/agent/sessions/-Projects-oh-my-pi/2026-06-10T09-11-41-506Z_019eb0cd-3ec2-7000-92aa-1b82aa4d78f0/local/PLAN.md'`) and for the
+ * active plan file while plan mode is enabled — both are OMP-internal artifacts
+ * that must stay off the editor's buffer.
+ */
+export declare function shouldRouteWriteThroughBridge(session: ToolSession, requestedPath: string, absolutePath: string): boolean;
+/**
+ * Try to route a file write through the ACP client bridge.
+ *
+ * Performs the full guard check, bridge call (wrapped in {@link ToolError}),
+ * FS-scan cache invalidation, and session mutation-version bump.
+ *
+ * Returns `true` when the bridge was used and the caller must skip the
+ * writethrough path. Returns `false` when the bridge is unavailable or the
+ * path should not be routed through it.
+ */
+export declare function routeWriteThroughBridge(session: ToolSession, requestedPath: string, absolutePath: string, content: string): Promise<boolean>;

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

@@ -0,0 +1,46 @@
+/**
+ * Tool approval resolution.
+ *
+ * Approval policy is declared by each tool. This module only knows how to:
+ * - normalize user `tools.approval.<tool>: allow | deny | prompt` overrides,
+ * - compare a tool capability tier against the active approval mode,
+ * - format the generic approval prompt body.
+ */
+import type { AgentTool, ToolTier } from "jeopi-agent-core";
+export type { ToolApproval, ToolApprovalDecision, ToolTier } from "jeopi-agent-core";
+export type ApprovalPolicy = "allow" | "deny" | "prompt";
+export type ApprovalMode = "always-ask" | "write" | "yolo";
+type ApprovalSubject = Pick<AgentTool, "name" | "approval" | "formatApprovalDetails">;
+export interface ResolvedApproval {
+    policy: ApprovalPolicy;
+    tier: ToolTier;
+    reason?: string;
+    override: boolean;
+}
+/**
+ * Resolve approval policy for a tool call.
+ *
+ * Resolution order:
+ *  1. Tool `approval(args)` decision, defaulting to tier "exec" when omitted.
+ *  2. User per-tool override, if set and valid.
+ *  3. Active mode tier comparison.
+ *
+ * In yolo mode, override-based tool prompts are ignored; user `tools.approval`
+ * settings remain authoritative.
+ */
+export declare function resolveApproval(tool: ApprovalSubject, args: unknown, mode: ApprovalMode, userConfig?: Record<string, unknown>): ResolvedApproval;
+/**
+ * Check if a tool call requires user approval.
+ *
+ * @throws Error if policy is 'deny'
+ * @returns Object with required flag and optional reason for the prompt
+ */
+export declare function requiresApproval(tool: ApprovalSubject, args: unknown, mode: ApprovalMode, userConfig?: Record<string, unknown>): {
+    required: boolean;
+    reason?: string;
+};
+export declare function truncateForPrompt(value: string, maxChars?: number): string;
+/**
+ * Format the approval prompt body shown to the user.
+ */
+export declare function formatApprovalPrompt(tool: ApprovalSubject, args: unknown, reason?: string): string;

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

@@ -0,0 +1,119 @@
+/**
+ * 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 "jeopi-agent-core";
+import type { ToolExample } from "jeopi-ai";
+import { type Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+declare const askSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    questions: {
+        id: string;
+        question: string;
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        multi?: boolean | undefined;
+        recommended?: number | undefined;
+    }[];
+}, {}>;
+export type AskToolInput = typeof askSchema.infer;
+/** Result for a single question */
+export interface QuestionResult {
+    id: string;
+    question: string;
+    options: string[];
+    multi: boolean;
+    selectedOptions: string[];
+    customInput?: string;
+    /** True when the answer was auto-selected because the dialog timed out. */
+    timedOut?: boolean;
+}
+export interface AskToolDetails {
+    question?: string;
+    options?: string[];
+    multi?: boolean;
+    selectedOptions?: string[];
+    customInput?: string;
+    /** True when the answer was auto-selected because the dialog timed out. */
+    timedOut?: boolean;
+    /** 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 approval: "read";
+    readonly label = "Ask";
+    readonly summary = "Ask the user a clarifying question";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        questions: {
+            id: string;
+            question: string;
+            options: {
+                label: string;
+                description?: string | undefined;
+            }[];
+            multi?: boolean | undefined;
+            recommended?: number | undefined;
+        }[];
+    }, {}>;
+    readonly strict = true;
+    readonly examples: readonly ToolExample<typeof askSchema.infer>[];
+    readonly concurrency = "exclusive";
+    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 AskRenderOption {
+    label: string;
+    description?: string;
+}
+interface AskRenderArgs {
+    question?: string;
+    options?: AskRenderOption[];
+    multi?: boolean;
+    questions?: Array<{
+        id: string;
+        question: string;
+        options: AskRenderOption[];
+        multi?: boolean;
+    }>;
+}
+export declare const askToolRenderer: {
+    mergeCallAndResult: boolean;
+    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,84 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import type { ToolExample } from "jeopi-ai";
+import type { Component } from "jeopi-tui";
+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: import("arktype/internal/variants/object.ts").ObjectType<{
+    ops: {
+        pat: string;
+        out: string;
+    }[];
+    paths: string[];
+}, {}>;
+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;
+    /** Session cwd at edit time. Display header paths are cwd-relative, so the
+     * renderer resolves them against this; `searchPath` is the scope target. */
+    cwd?: string;
+}
+type AstEditSchemaInfer = typeof astEditSchema.infer;
+export declare class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolDetails> {
+    private readonly session;
+    readonly name = "ast_edit";
+    readonly approval: (args: unknown) => "read" | "write";
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    readonly label = "AST Edit";
+    readonly summary = "Perform AST-aware code edits (structural refactoring)";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        ops: {
+            pat: string;
+            out: string;
+        }[];
+        paths: string[];
+    }, {}>;
+    readonly strict = true;
+    readonly examples: readonly ToolExample<AstEditSchemaInfer>[];
+    readonly deferrable = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: AstEditSchemaInfer, 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,74 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import type { ToolExample } from "jeopi-ai";
+import type { Component } from "jeopi-tui";
+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: import("arktype/internal/variants/object.ts").ObjectType<{
+    pat: string;
+    paths: string[];
+    skip?: number | undefined;
+}, {}>;
+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;
+    /** Session cwd at search time. Display header/match paths are cwd-relative, so
+     * the renderer resolves them against this; `searchPath` is the scope target. */
+    cwd?: string;
+}
+export declare class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolDetails> {
+    private readonly session;
+    readonly name = "ast_grep";
+    readonly approval: "read";
+    readonly label = "AST Grep";
+    readonly summary = "Search code with AST patterns (structural grep)";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        pat: string;
+        paths: string[];
+        skip?: number | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly examples: readonly ToolExample<typeof astGrepSchema.inferIn>[];
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: typeof astGrepSchema.infer, 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-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 "jeopi-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;