@sayknow-cli/coding-agent 0.3.12 → 0.3.13

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

@@ -1,48 +0,0 @@
-/**
- * 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

@@ -1,94 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,117 +0,0 @@
-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<{
-        await: "await";
-        cancel: "cancel";
-        inspect: "inspect";
-        list: "list";
-        pause: "pause";
-        resume: "resume";
-        steer: "steer";
-    }>;
-    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<{
-        full: "full";
-        preview: "preview";
-        receipt: "receipt";
-    }>>;
-}, 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<{
-            await: "await";
-            cancel: "cancel";
-            inspect: "inspect";
-            list: "list";
-            pause: "pause";
-            resume: "resume";
-            steer: "steer";
-        }>;
-        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<{
-            full: "full";
-            preview: "preview";
-            receipt: "receipt";
-        }>>;
-    }, 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

@@ -1,32 +0,0 @@
-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;
-    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

@@ -1,120 +0,0 @@
-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<{
-            append: "append";
-            done: "done";
-            drop: "drop";
-            init: "init";
-            note: "note";
-            rm: "rm";
-            start: "start";
-        }>;
-        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<{
-                append: "append";
-                done: "done";
-                drop: "drop";
-                init: "init";
-                note: "note";
-                rm: "rm";
-                start: "start";
-            }>;
-            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

@@ -1,33 +0,0 @@
-/**
- * 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

@@ -1,30 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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;