import type { Tool } from '@wrongstack/core/types';
/**
 * Provider-facing descriptions for every built-in tool.
 *
 * Keep these decision-oriented: state the primary job, the appropriate time
 * to use the tool, and any important boundary. This is deliberately kept next
 * to the canonical catalog so tools discovered lazily receive the same useful
 * guidance as directly exposed tools.
 */
export declare const BUILTIN_TOOL_DESCRIPTIONS: Readonly<Record<string, string>>;
/**
 * Non-essential tools that can be omitted in token-saving mode to reduce
 * per-request token consumption. Each tool definition adds ~50-200 tokens
 * to the system prompt; skipping these saves ~2000-3000 tokens per iteration.
 *
 * These tools are useful but not critical for core development flow:
 * package management (install/audit/outdated run once per session at most),
 * browser automation, the E2E planner, and log tailing. The `tool_search` /
 * `tool_use` gateway is deliberately NOT here — it is what makes everything
 * omitted below tier `off` reachable, so withholding it would strand the
 * tools this list exists to withhold.
 */
export declare const OPTIONAL_TOOLS: Tool[];
/**
 * Specialized built-ins intentionally exposed directly only when token saving
 * is off. Keeping this set explicit prevents newly registered built-ins from
 * becoming off-only merely because somebody forgot to classify them.
 */
export declare const OFF_ONLY_TOOLS: Tool[];
/**
 * Tier 1 (Token Saving) tool set — the absolute minimum for useful work.
 * 26 tools covering core file ops, indexed project discovery, structured
 * edits, shell, search, utilities, and the lazy-catalog gateway. Codebase
 * index lifecycle tools stay available at every tier so token saving does not
 * force broad filesystem scans. Saves ~3500-5500 tokens vs full mode by
 * omitting specialized schemas from direct provider exposure; the withheld
 * tools stay executable and are reachable through the gateway pair.
 *
 * Tier 1 tools:
 *   read, write, edit, clarify                 — file operations
 *   codebase-stats/search/index/skeleton/repo-map/impact/targeted-test/
 *   incoming-calls/outgoing-calls/ast-replace/invariant-check,
 *   security-ast-scan                          — indexed project discovery
 *   bash, grep, glob                           — shell + exact/path fallback
 *   diff, patch, json                          — utility
 *   search                                     — web research
 *   tool_search, tool_use                      — reach the withheld catalog
 */
export declare const TIER1_TOOLS: Tool[];
/**
 * Tier 2 tool set — standard development tools useful for non-trivial work.
 * Adds 20 tools: replace, exec, pwsh, fetch, git, tree, lint, format,
 * typecheck, test, languageInfo, language, languagePackage, todo, plan,
 * kanban, task, install, audit, design.
 *
 * These tools are used regularly during development but are not essential for
 * every turn. Omitting them in minimal/light tier saves ~900 tokens per prompt.
 */
export declare const TIER2_TOOLS: Tool[];
/**
 * Tier 3 tool set — specialized, administrative, and exploratory tools.
 * Adds 3 tools: outdated, logs, dead-code-scan.
 *
 * These tools are situational (log tailing, dependency maintenance, dead-code
 * sweeps). Omitting their schemas below tier `off` saves tokens; they stay
 * registered and executable, and the model reaches them through `tool_search`
 * / `tool_use` — which is why that pair lives in TIER1 rather than here.
 */
export declare const TIER3_TOOLS: Tool[];
/** The executable catalog always exposes the reviewed description above. */
export declare const builtinTools: Tool[];
//# sourceMappingURL=builtin.d.ts.map