@sayknow-cli/coding-agent 0.3.13 → 0.3.15

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

@@ -0,0 +1,48 @@
+/**
+ * Skill Tool — agent-initiated skill chaining.
+ *
+ * Lets the agent hand off to another available skill in the current turn. The
+ * callee's SKILL.md is dispatched through the same custom-message path used by
+ * `/skill:<name>` typing, as a user-attribution message delivered same-turn
+ * (without `deliverAs: "nextTurn"`). When the caller is one of the canonical
+ * workflow skills, the tool first runs the native state handoff so workflow
+ * mode-state and `skill-active-state.json` transition atomically. Runtime
+ * project/user skills have no native workflow mode-state, so they are dispatched
+ * directly and tracked by the prompt observer instead.
+ *
+ * Canonical workflow chaining is refused unless the caller's `current_phase` is
+ * in `{complete, completed, handoff, failed, cancelled, canceled, inactive}`.
+ * The agent declares readiness either by writing `current_phase: "handoff"` to
+ * its mode-state or by running the handoff verb directly.
+ */
+import type { AgentTool, AgentToolResult } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+declare const skillSchema: z.ZodObject<{
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SkillToolInput = z.infer<typeof skillSchema>;
+export interface SkillToolDetails {
+    name: string;
+    path: string;
+    args?: string;
+    lineCount: number;
+}
+export declare class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails> {
+    #private;
+    readonly name = "skill";
+    readonly label = "Skill";
+    readonly summary = "Chain into another available skill in the current turn";
+    readonly loadMode = "essential";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): SkillTool | null;
+    execute(_toolCallId: string, input: SkillToolInput, signal?: AbortSignal): Promise<AgentToolResult<SkillToolDetails>>;
+}
+export {};

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

@@ -0,0 +1,94 @@
+import type { Database } from "bun:sqlite";
+export interface SqlitePathCandidate {
+    sqlitePath: string;
+    subPath: string;
+    queryString: string;
+}
+export type SqliteSelector = {
+    kind: "list";
+} | {
+    kind: "schema";
+    table: string;
+    sampleLimit: number;
+} | {
+    kind: "row";
+    table: string;
+    key: string;
+} | {
+    kind: "query";
+    table: string;
+    limit: number;
+    offset: number;
+    order?: string;
+    where?: string;
+} | {
+    kind: "raw";
+    sql: string;
+};
+export type SqliteRowLookup = {
+    kind: "pk";
+    column: string;
+    type: string;
+} | {
+    kind: "rowid";
+};
+export declare function parseSqlitePathCandidates(filePath: string): SqlitePathCandidate[];
+export declare function isSqliteFile(absolutePath: string): Promise<boolean>;
+export declare function parseSqliteSelector(subPath: string, queryString: string): SqliteSelector;
+export declare function listTables(db: Database): {
+    name: string;
+    rowCount: number;
+}[];
+export declare function getTableSchema(db: Database, table: string): string;
+export declare function getTablePrimaryKey(db: Database, table: string): {
+    column: string;
+    type: string;
+} | null;
+export declare function resolveTableRowLookup(db: Database, table: string): SqliteRowLookup;
+export declare function queryRows(db: Database, table: string, opts: {
+    limit: number;
+    offset: number;
+    order?: string;
+    where?: string;
+}): {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    totalCount: number;
+};
+export declare function getRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string): Record<string, unknown> | null;
+export declare function getRowByRowId(db: Database, table: string, key: string): Record<string, unknown> | null;
+export declare function executeReadQuery(db: Database, sql: string, maxRows?: number): {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    truncated: boolean;
+};
+export declare function insertRow(db: Database, table: string, data: Record<string, unknown>): void;
+export declare function updateRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string, data: Record<string, unknown>): number;
+export declare function updateRowByRowId(db: Database, table: string, key: string, data: Record<string, unknown>): number;
+export declare function deleteRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string): number;
+export declare function deleteRowByRowId(db: Database, table: string, key: string): number;
+export declare function renderTableList(tables: {
+    name: string;
+    rowCount: number;
+}[]): string;
+export declare function renderSchema(createSql: string, sampleRows: {
+    columns: string[];
+    rows: Record<string, unknown>[];
+}): string;
+export declare function renderRow(row: Record<string, unknown>): string;
+export declare function renderTable(columns: string[], rows: Record<string, unknown>[], meta: {
+    totalCount: number;
+    offset: number;
+    limit: number;
+    table: string;
+    dbPath: string;
+}): string;

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

@@ -0,0 +1,67 @@
+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 { SSHHost } from "../capability/ssh";
+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 sshSchema: z.ZodObject<{
+    host: z.ZodString;
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export interface SSHToolDetails {
+    meta?: OutputMeta;
+}
+type SshToolParams = z.infer<typeof sshSchema>;
+export declare class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
+    #private;
+    private readonly session;
+    private readonly hostNames;
+    private readonly hostsByName;
+    readonly description: string;
+    readonly name = "ssh";
+    readonly summary = "Execute a command on a remote host over SSH";
+    readonly loadMode = "discoverable";
+    readonly label = "SSH";
+    readonly parameters: z.ZodObject<{
+        host: z.ZodString;
+        command: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    constructor(session: ToolSession, hostNames: string[], hostsByName: Map<string, SSHHost>, description: string);
+    execute(_toolCallId: string, { host, command, cwd, timeout: rawTimeout }: SshToolParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<SSHToolDetails>, _ctx?: AgentToolContext): Promise<AgentToolResult<SSHToolDetails>>;
+}
+export declare function loadSshTool(session: ToolSession): Promise<SshTool | null>;
+interface SshRenderArgs {
+    host?: string;
+    command?: string;
+    timeout?: number;
+}
+interface SshRenderContext {
+    /** Visual lines for truncated output (pre-computed by tool-execution) */
+    visualLines?: string[];
+    /** Number of lines skipped */
+    skippedCount?: number;
+    /** Total visual lines */
+    totalVisualLines?: number;
+}
+export declare const sshToolRenderer: {
+    renderCall(args: SshRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SSHToolDetails;
+    }, options: RenderResultOptions & {
+        renderContext?: SshRenderContext;
+    }, uiTheme: Theme, args?: SshRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

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

@@ -0,0 +1,31 @@
+/**
+ * TUI renderer for the `subagent` tool.
+ *
+ * The await panel surfaces each awaited subagent's live streaming status at
+ * parity with the inline `task` panel by reusing `renderSubagentLiveProgress`.
+ * Falls back to a `running, no activity yet` placeholder when a live producer
+ * exists but has not emitted yet, and to a static status line when no live
+ * producer is available (resumed-from-disk or backward-compat records).
+ */
+import type { Component } from "@sayknow-cli/tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { type SubagentToolDetails } from "./subagent";
+/** Test-only seam (PR3 deterministic cache-hit assertions). */
+export declare const subagentBodyCacheTestHooks: {
+    readonly bodyRenders: number;
+    readonly size: number;
+    reset(): void;
+};
+export declare const subagentToolRenderer: {
+    inline: boolean;
+    renderCall(_args: unknown, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SubagentToolDetails;
+    }, options: RenderResultOptions, theme: Theme): Component;
+    mergeCallAndResult: boolean;
+};

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

@@ -0,0 +1,117 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import type { AgentProgress, AgentSource } from "../task/types";
+import type { ToolSession } from "./index";
+declare const subagentSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        resume: "resume";
+        pause: "pause";
+        steer: "steer";
+        list: "list";
+        cancel: "cancel";
+        inspect: "inspect";
+        await: "await";
+    }>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    pause: z.ZodOptional<z.ZodBoolean>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        receipt: "receipt";
+        full: "full";
+        preview: "preview";
+    }>>;
+}, z.core.$strip>;
+type SubagentParams = z.infer<typeof subagentSchema>;
+type SubagentStatus = "running" | "paused" | "queued" | "completed" | "failed" | "cancelled" | "not_found" | "already_completed";
+export interface SubagentSnapshot {
+    id: string;
+    jobId: string;
+    status: SubagentStatus;
+    label: string;
+    agent: string;
+    agentSource: AgentSource;
+    description?: string;
+    assignment?: string;
+    durationMs: number;
+    resultText?: string;
+    errorText?: string;
+    resultPreview?: string;
+    outputRef?: string;
+    truncated?: boolean;
+    guidance?: string;
+    steerMessage?: string;
+    steerState?: "queued" | "resume_queued" | "resume_started";
+    steerPauseRequested?: boolean;
+    /** Live streaming progress for the awaited subagent (await panel only; UI detail). */
+    progress?: AgentProgress;
+    /** True when a live in-session progress producer exists for this subagent. */
+    liveProgressAvailable?: boolean;
+    /** Model the subagent actually runs on (after any auth fallback). */
+    effectiveModel?: string;
+    /** Model originally requested via role/preset mapping; differs from effective on fallback. */
+    requestedModel?: string;
+    /** True when the requested model lacked credentials and fell back to the parent model. */
+    modelFellBack?: boolean;
+}
+export interface SubagentToolDetails {
+    subagents: SubagentSnapshot[];
+}
+export declare class SubagentTool implements AgentTool<typeof subagentSchema, SubagentToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "subagent";
+    readonly label = "Subagent";
+    readonly summary = "Manage detached task subagents";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        action: z.ZodEnum<{
+            resume: "resume";
+            pause: "pause";
+            steer: "steer";
+            list: "list";
+            cancel: "cancel";
+            inspect: "inspect";
+            await: "await";
+        }>;
+        ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        pause: z.ZodOptional<z.ZodBoolean>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        verbosity: z.ZodOptional<z.ZodEnum<{
+            receipt: "receipt";
+            full: "full";
+            preview: "preview";
+        }>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<SubagentToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<SubagentToolDetails>>;
+}
+/**
+ * Canonical, value-based rendered-state signature for the `subagent` await panel.
+ *
+ * Producer-side await gating compares this signature against the last emitted one
+ * and only fires `onUpdate` when the *rendered* state actually changed. Unchanged
+ * idle ticks therefore stop rebuilding the renderer component and stop mutating
+ * transcript lines above the viewport, which is what triggers TUI full-redraw
+ * storms (`tui.ts` `firstChanged < viewportTop`).
+ *
+ * It is deliberately value-based, never object identity: `AsyncJobManager.record-
+ * SubagentProgress` stores a `structuredClone` but `getSubagentProgress` returns
+ * the retained object by reference, so identity comparison would be both noisy and
+ * unsafe.
+ *
+ * Time-derived fields are intentionally excluded so the panel does not churn while
+ * idle: raw durations (`durationMs`), current-tool elapsed (`currentToolStartMs`),
+ * and retry countdowns (`retryState.startedAtMs`) are omitted. Idle duration and
+ * countdown ticking is sacrificed by design; every real transition still changes
+ * the signature.
+ */
+export declare function subagentAwaitRenderedStateSignature(subagents: readonly SubagentSnapshot[]): string;
+export {};

package/dist/types/tools/telegram-send.d.ts

@@ -0,0 +1,39 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import { z } from "zod/v4";
+import type { ToolSession } from "./index";
+declare const telegramSendSchema: z.ZodObject<{
+    path: z.ZodString;
+    caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type TelegramSendParams = z.infer<typeof telegramSendSchema>;
+interface TelegramSendDetails {
+    path: string;
+    caption?: string;
+    ok: boolean;
+    error?: string;
+}
+export declare class TelegramSendTool implements AgentTool<typeof telegramSendSchema, TelegramSendDetails> {
+    private readonly session;
+    readonly name = "telegram_send";
+    readonly label = "TelegramSend";
+    readonly summary = "Send a workspace file to Telegram";
+    readonly loadMode = "discoverable";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        path: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): TelegramSendTool | null;
+    /**
+     * Resolve `requested` against the workspace root and confine it via realpath:
+     * blocks absolute paths outside the project, `..` traversal, and symlinks that
+     * escape the root. Returns the resolved real path of a regular file, or an
+     * error message. This is the egress safety boundary — the model can only send
+     * files that genuinely live inside the session workspace.
+     */
+    private resolveContainedFile;
+    execute(_toolCallId: string, params: TelegramSendParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TelegramSendDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TelegramSendDetails>>;
+}
+export {};

package/dist/types/tools/todo-write.d.ts

@@ -0,0 +1,120 @@
+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 "../sdk";
+import type { SessionEntry } from "../session/session-manager";
+export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
+export interface TodoItem {
+    content: string;
+    status: TodoStatus;
+    /**
+     * Append-only list of freeform notes attached by `op: "note"`.
+     * Each element is one note and may itself be multi-line.
+     * Rendered as text only when the task is in_progress; otherwise shown as a
+     * dim marker indicating the task has notes.
+     */
+    notes?: string[];
+}
+export interface TodoPhase {
+    name: string;
+    tasks: TodoItem[];
+}
+export interface TodoWriteToolDetails {
+    phases: TodoPhase[];
+    storage: "session" | "memory";
+}
+declare const todoWriteSchema: z.ZodObject<{
+    ops: z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            drop: "drop";
+            init: "init";
+            start: "start";
+            done: "done";
+            rm: "rm";
+            append: "append";
+            note: "note";
+        }>;
+        list: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            phase: z.ZodString;
+            items: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+        task: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodString>;
+        items: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        text: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type TodoWriteParams = z.infer<typeof todoWriteSchema>;
+export declare const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
+export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[];
+/** Apply an array of `todo_write`-style ops to existing phases. Used by /todo slash command. */
+export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoWriteParams["ops"]): {
+    phases: TodoPhase[];
+    errors: string[];
+};
+/** Render todo phases as a Markdown checklist suitable for editing/copying. */
+export declare function phasesToMarkdown(phases: TodoPhase[]): string;
+/** Parse a Markdown checklist back into todo phases. */
+export declare function markdownToPhases(md: string): {
+    phases: TodoPhase[];
+    errors: string[];
+};
+export declare class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWriteToolDetails> {
+    private readonly session;
+    readonly name = "todo_write";
+    readonly label = "Todo Write";
+    readonly summary = "Write a structured todo list to track progress within a session";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        ops: z.ZodArray<z.ZodObject<{
+            op: z.ZodEnum<{
+                drop: "drop";
+                init: "init";
+                start: "start";
+                done: "done";
+                rm: "rm";
+                append: "append";
+                note: "note";
+            }>;
+            list: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                phase: z.ZodString;
+                items: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>>;
+            task: z.ZodOptional<z.ZodString>;
+            phase: z.ZodOptional<z.ZodString>;
+            items: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: TodoWriteParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TodoWriteToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TodoWriteToolDetails>>;
+}
+type TodoWriteRenderArgs = {
+    ops?: Array<{
+        op?: string;
+        task?: string;
+        phase?: string;
+        items?: string[];
+    }>;
+};
+/** One-based ASCII roman numeral for display (I, II, III, IV, …). */
+export declare function phaseRomanNumeral(oneBasedIndex: number): string;
+/** Display-only phase header: `I. Foundation`. State and prompts never see this. */
+export declare function formatPhaseDisplayName(name: string, oneBasedIndex: number): string;
+export declare const todoWriteToolRenderer: {
+    renderCall(args: TodoWriteRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: TodoWriteToolDetails;
+    }, options: RenderResultOptions, uiTheme: Theme, _args?: TodoWriteRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/tool-errors.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Standardized error types for tool execution.
+ *
+ * Tools should throw these instead of returning error text.
+ * The agent loop catches and renders them appropriately.
+ */
+/**
+ * Base error for tool execution failures.
+ * Override render() for custom LLM-facing formatting.
+ */
+export declare class ToolError extends Error {
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, context?: Record<string, unknown> | undefined);
+    /** Render error for LLM consumption. Override for custom formatting. */
+    render(): string;
+}
+/**
+ * Error thrown when a tool operation is aborted (e.g., via AbortSignal).
+ */
+export declare class ToolAbortError extends Error {
+    static readonly MESSAGE = "Operation aborted";
+    constructor(message?: string);
+}
+/**
+ * Throw ToolAbortError if the signal is aborted.
+ * Use this instead of signal?.throwIfAborted() to get consistent error types.
+ */
+export declare function throwIfAborted(signal?: AbortSignal): void;
+/**
+ * Render an error for LLM consumption.
+ * Handles ToolError.render() and falls back to message/string.
+ */
+export declare function renderError(e: unknown): string;

package/dist/types/tools/tool-result.d.ts

@@ -0,0 +1,30 @@
+import type { AgentToolResult } from "@sayknow-cli/agent-core";
+import type { ImageContent, TextContent } from "@sayknow-cli/ai";
+import type { OutputSummary, TruncationResult } from "../session/streaming-output";
+import type { OutputMeta, TruncationOptions, TruncationSummaryOptions, TruncationTextOptions } from "./output-meta";
+type ToolContent = Array<TextContent | ImageContent>;
+type DetailsWithMeta = {
+    meta?: OutputMeta;
+};
+export declare class ToolResultBuilder<TDetails extends DetailsWithMeta> {
+    #private;
+    constructor(details?: TDetails);
+    text(text: string): this;
+    content(content: ToolContent): this;
+    truncation(result: TruncationResult, options: TruncationOptions): this;
+    truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this;
+    truncationFromText(text: string, options: TruncationTextOptions): this;
+    limits(limits: {
+        matchLimit?: number;
+        resultLimit?: number;
+        headLimit?: number;
+        columnMax?: number;
+    }): this;
+    sourceUrl(value: string): this;
+    sourcePath(value: string): this;
+    sourceInternal(value: string): this;
+    diagnostics(summary: string, messages: string[]): this;
+    done(): AgentToolResult<TDetails>;
+}
+export declare function toolResult<TDetails extends DetailsWithMeta>(details?: TDetails): ToolResultBuilder<TDetails>;
+export {};

package/dist/types/tools/tool-timeouts.d.ts

@@ -0,0 +1,56 @@
+export interface ToolTimeoutConfig {
+    /** Default timeout in seconds when agent omits the field */
+    default: number;
+    /** Minimum allowed timeout in seconds */
+    min: number;
+    /** Maximum allowed timeout in seconds (per-tool ceiling) */
+    max: number;
+}
+export declare const TOOL_TIMEOUTS: {
+    readonly bash: {
+        readonly default: 300;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly eval: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 600;
+    };
+    readonly browser: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 300;
+    };
+    readonly computer: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 300;
+    };
+    readonly ssh: {
+        readonly default: 60;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly fetch: {
+        readonly default: 20;
+        readonly min: 1;
+        readonly max: 45;
+    };
+    readonly lsp: {
+        readonly default: 20;
+        readonly min: 5;
+        readonly max: 60;
+    };
+    readonly debug: {
+        readonly default: 30;
+        readonly min: 5;
+        readonly max: 300;
+    };
+};
+export type ToolWithTimeout = keyof typeof TOOL_TIMEOUTS;
+/**
+ * Clamp a raw timeout to the allowed range for a tool.
+ * If rawTimeout is undefined, returns the tool's default.
+ */
+export declare function clampTimeout(tool: ToolWithTimeout, rawTimeout?: number): number;

package/dist/types/tools/ultragoal-ask-guard.d.ts

@@ -0,0 +1,12 @@
+import type { AgentTool } from "@sayknow-cli/agent-core";
+import { type UltragoalAskBlockDiagnostic } from "../skc-runtime/ultragoal-guard";
+export interface UltragoalAskGuardContext {
+    activeSkillState?: {
+        skill?: string;
+        session_id?: string;
+    } | null;
+    sessionId?: string | null;
+}
+export declare function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiagnostic): string;
+export declare function assertUltragoalAskAllowed(cwd: string, context?: UltragoalAskGuardContext): Promise<void>;
+export declare function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string, getContext?: () => UltragoalAskGuardContext): T;