jeopi-cli 16.2.14 → 16.2.17

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

@@ -0,0 +1,218 @@
+/**
+ * Shared utilities and constants for tool renderers.
+ *
+ * Provides consistent formatting, truncation, and display patterns across all
+ * tool renderers to ensure a unified TUI experience.
+ */
+import type { ToolCallContext } from "jeopi-agent-core";
+import type { Ellipsis } from "jeopi-natives";
+import type { Component } from "jeopi-tui";
+import type { Theme } from "../modes/theme/theme";
+import { type ResizedImage } from "../utils/image-resize";
+export { Ellipsis } from "jeopi-natives";
+export { replaceTabs, truncateToWidth, wrapTextWithAnsi } from "jeopi-tui";
+/** Resolve inline image dimension caps from settings and viewport. */
+export declare function resolveImageOptions(): {
+    maxWidthCells: number;
+    maxHeightCells?: number;
+};
+/** Preview limits for collapsed/expanded views */
+export declare const PREVIEW_LIMITS: {
+    /** Lines shown in collapsed view */
+    readonly COLLAPSED_LINES: 3;
+    /** Lines shown in expanded view */
+    readonly EXPANDED_LINES: 12;
+    /** Items (files, results) shown in collapsed view */
+    readonly COLLAPSED_ITEMS: 8;
+    /** Output preview lines in collapsed view */
+    readonly OUTPUT_COLLAPSED: 3;
+    /** Output preview lines in expanded view */
+    readonly OUTPUT_EXPANDED: 10;
+    /** Max hunks shown when collapsed (edit tool) */
+    readonly DIFF_COLLAPSED_HUNKS: 8;
+    /** Max diff lines shown when collapsed (edit tool) */
+    readonly DIFF_COLLAPSED_LINES: 40;
+};
+/** Truncation lengths for different content types */
+export declare const TRUNCATE_LENGTHS: {
+    /** Short titles, labels */
+    readonly TITLE: 60;
+    /** Medium-length content (messages, previews) */
+    readonly CONTENT: 80;
+    /** Longer content (code, explanations) */
+    readonly LONG: 100;
+    /** Full line content */
+    readonly LINE: 110;
+    /** Very short (task previews, badges) */
+    readonly SHORT: 40;
+    /** Idle recap status line (~40-word LLM reply) */
+    readonly RECAP: 280;
+};
+/** Human-readable key currently bound to tool-output expansion, e.g. `Ctrl+O`. */
+export declare function expandKeyHint(): string;
+/**
+ * Get first N lines of text as preview, with each line truncated.
+ */
+export declare function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[];
+/**
+ * Collapse a possibly multi-line string into a single line, then truncate it to
+ * `maxWidth` display cells. {@link truncateToWidth} alone caps width but
+ * newlines are zero-width, so multi-line content (markdown briefs, tool args,
+ * provider errors) would otherwise spill a single status row across several
+ * visual lines. Whitespace runs collapse to one space, so tabs are handled too.
+ */
+export declare function previewLine(text: string, maxWidth: number, ellipsis?: Ellipsis): string;
+/**
+ * Extract domain from URL, stripping www. prefix.
+ */
+export declare function getDomain(url: string): string;
+export { formatAge, formatBytes, formatCount, formatDuration, pluralize } from "jeopi-utils";
+/**
+ * Get the appropriate status icon with color for a given state.
+ * Standardizes status icon usage across all renderers.
+ */
+export declare function formatStatusIcon(status: ToolUIStatus, theme: Theme, spinnerFrame?: number): string;
+/**
+ * Format the expand hint with proper theming.
+ * Returns empty string if already expanded or there is nothing more to show.
+ */
+export declare function formatExpandHint(theme: Theme, expanded?: boolean, hasMore?: boolean): string;
+/**
+ * Format a badge like [done] or [failed] with brackets and color.
+ */
+export declare function formatBadge(label: string, color: ToolUIColor, theme: Theme): string;
+/**
+ * Build a "more items" suffix line for truncated lists.
+ * Uses consistent wording pattern.
+ */
+export declare function formatMoreItems(remaining: number, itemType: string): string;
+/** Tail-window height for collapsed command/code previews. */
+export declare function previewWindowRows(): number;
+/**
+ * Cap a pre-rendered command preview to a viewport-sized tail window: the end
+ * of the command stays visible (it is the live edge while args stream) behind
+ * an "… N earlier lines" marker on top. The same window applies while
+ * streaming and after completion so the block never jumps; only `expanded`
+ * (ctrl+o) uncaps it.
+ *
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the marker line so
+ * nested previews stay aligned. `expandHint: false` drops the "ctrl+o: Expand"
+ * suffix for callers that cap even inside the expanded view (task recent
+ * output), where the hint would point the wrong way.
+ */
+export declare function capPreviewLines(lines: string[], theme: Theme, options?: {
+    max?: number;
+    expanded?: boolean;
+    prefix?: string;
+    expandHint?: boolean;
+}): string[];
+export declare function formatMeta(meta: string[], theme: Theme): string;
+export declare function formatErrorMessage(message: string | undefined, theme: Theme): string;
+/**
+ * Error message rendered as a subordinate detail line beneath a status header
+ * that already carries the error icon (e.g. `✘ Write: <path>`). The header's
+ * icon already signals failure, so this omits the redundant error symbol and
+ * "Error:" prefix that `formatErrorMessage` adds for standalone single-line
+ * errors, indenting two columns to sit under the header title instead.
+ */
+export declare function formatErrorDetail(message: string | undefined, theme: Theme): string;
+export declare function formatEmptyMessage(message: string, theme: Theme): string;
+export type CodeFrameMarker = "" | " " | "*" | "+" | "-" | ">";
+export declare function formatCodeFrameLine(marker: CodeFrameMarker, lineNumber: string | number, content: string, lineNumberWidth: number): string;
+export type ToolUIStatus = "success" | "done" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
+export type ToolUIColor = "success" | "error" | "warning" | "accent" | "muted";
+export interface ToolUITitleOptions {
+    bold?: boolean;
+}
+export declare function formatTitle(label: string, theme: Theme, options?: ToolUITitleOptions): string;
+export declare function formatDiagnostics(diag: {
+    errored: boolean;
+    summary: string;
+    messages: string[];
+}, expanded: boolean, theme: Theme, getLangIcon: (filePath: string) => string, options?: {
+    title?: string;
+}): string;
+export interface DiffStats {
+    added: number;
+    removed: number;
+    hunks: number;
+    lines: number;
+}
+export declare function getDiffStats(diffText: string): DiffStats;
+export declare function formatDiffStats(added: number, removed: number, hunks: number, theme: Theme): string;
+export declare function truncateDiffByHunk(diffText: string, maxHunks: number, maxLines: number, options?: {
+    fromTail?: boolean;
+}): {
+    text: string;
+    hiddenHunks: number;
+    hiddenLines: number;
+};
+export declare function shortenPath(filePath: string, homeDir?: string): string;
+export declare function formatToolWorkingDirectory(workdir: string | undefined, projectDir: string): string | undefined;
+export declare function formatScreenshot(opts: {
+    saveFullRes: boolean;
+    savedMimeType: string;
+    savedByteLength: number;
+    dest: string;
+    resized: ResizedImage;
+}): string[];
+export declare function wrapBrackets(text: string, theme: Theme): string;
+export declare const PARSE_ERRORS_LIMIT = 20;
+export declare function dedupeParseErrors(errors: string[] | undefined): string[];
+export declare function formatParseErrors(errors: string[], total?: number): string[];
+/**
+ * Cap an upstream parse-error list to {@link PARSE_ERRORS_LIMIT} unique entries,
+ * preserving the original deduplicated total. Use this at the source so tool
+ * details never carry thousands of per-file parse errors into traces or
+ * renderers.
+ */
+export declare function capParseErrors(errors: string[] | undefined, limit?: number): {
+    errors: string[];
+    total: number;
+};
+/**
+ * Standard width+expand keyed render cache used by every search-style tool
+ * renderer. `compute` re-runs only when the cache key changes; the returned
+ * Component is the canonical `{ render, invalidate }` pair.
+ */
+export declare function createCachedComponent(getExpanded: () => boolean, compute: (width: number, expanded: boolean) => string[], options?: {
+    paddingX?: number;
+}): Component;
+/**
+ * Single-slot memo for an expensive rendered string (syntax highlighting, diff
+ * coloring) keyed by the exact inputs that shape the bytes: theme instance,
+ * expanded state, a caller-chosen salt (path/language), and the source content.
+ * Field-wise comparison instead of a concatenated key string: a cache hit costs
+ * one string value-compare (engines short-circuit on length) and a miss never
+ * allocates a key. Comparing the {@link Theme} by reference is sound because
+ * theme switches replace the instance wholesale (`setTheme`/`previewTheme`/
+ * `setSymbolPreset` in modes/theme/theme.ts) — themes are never mutated in
+ * place.
+ */
+export interface RenderedStringCache {
+    theme: Theme | null;
+    expanded: boolean;
+    salt: string;
+    content: string;
+    value: string;
+}
+export declare function createRenderedStringCache(): RenderedStringCache;
+/** Drop the memo so the next lookup re-renders (e.g. the render function identity changed). */
+export declare function invalidateRenderedStringCache(cache: RenderedStringCache): void;
+export declare function cachedRenderedString(cache: RenderedStringCache | undefined, theme: Theme, expanded: boolean, salt: string, content: string, render: () => string): string;
+/**
+ * Append the indented bullet list of parse errors (capped at
+ * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the
+ * total exceeds the cap. No-op when `parseErrors` is empty.
+ */
+export declare function appendParseErrorsBulletList(lines: string[], parseErrors: readonly string[] | undefined, theme: Theme, total?: number): void;
+/**
+ * Human-readable summary string for the parse-issues count, capped by
+ * {@link PARSE_ERRORS_LIMIT}.
+ */
+export declare function formatParseErrorsCountLabel(parseErrors: readonly string[], total?: number): string;
+export interface LspBatchRequest {
+    id: string;
+    flush: boolean;
+}
+export declare function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined;

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

@@ -0,0 +1,45 @@
+/**
+ * TUI renderers for built-in tools.
+ *
+ * These provide rich visualization for tool calls and results in the TUI.
+ */
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+export type ToolRenderer = {
+    renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
+    renderResult: (result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: unknown;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: Record<string, unknown>;
+    }, theme: Theme, args?: unknown) => Component;
+    mergeCallAndResult?: boolean;
+    /** Render without background box, inline in the response flow */
+    inline?: boolean;
+    /**
+     * Whether pending-call rows are provisional: useful on screen while a tool is
+     * streaming, but not durable transcript history. `true` means every pending
+     * shape is provisional. `"collapsed"` means only the collapsed pending shape
+     * is provisional; expanded rendering is top-anchored/append-shaped enough to
+     * let the transcript commit its settled prefix. Absent = the pending preview
+     * streams rows the result render preserves.
+     */
+    provisionalPendingPreview?: boolean | "collapsed";
+    /**
+     * Whether the partial-result render is provisional: chrome rows (header
+     * glyph, frame state) that change between `options.isPartial === true` and
+     * the final result render. When `true`, the block is treated as
+     * commit-unstable while a partial result is in flight, so the
+     * stable-prefix ratchet in `deriveLiveCommitState` cannot promote the
+     * partial chrome to native scrollback only to have the final render strand
+     * it above the settled frame. Absent = the partial render is byte-stable
+     * with the final render and may commit like any settled stream.
+     */
+    provisionalPartialResult?: boolean;
+};
+export declare const toolRenderers: Record<string, ToolRenderer>;

package/dist/types/tools/report-tool-issue.d.ts

@@ -0,0 +1,127 @@
+/**
+ * report_tool_issue — automated QA tool for tracking unexpected tool behavior.
+ *
+ * Enabled by default; gated behind PI_AUTO_QA=1 / `dev.autoqa` so a user
+ * who flips the setting off short-circuits injection entirely.
+ * Always injected into every agent (including subagents) regardless of tool selection.
+ * Records grievances to a local SQLite database; never throws.
+ *
+ * Before the first record lands, the user's consent is checked. If they've
+ * never been asked (`dev.autoqa.consent === "unset"`) the process-global
+ * consent handler — wired by `InteractiveMode` to a Yes/No popup — is
+ * invoked exactly once and the decision is persisted. Subsequent calls
+ * (including from subagents) read the cached decision without prompting.
+ *
+ * When the user grants consent, push is automatically active against the
+ * bundled endpoint (`dev.autoqaPush.endpoint`, default `qa.omp.sh`). Each
+ * insert schedules a background flush that POSTs pending rows and deletes
+ * them on HTTP 2xx. `PI_AUTO_QA_PUSH=1` forces push in non-interactive
+ * environments where the consent dialog never fires. Tool execution is
+ * never blocked on the network and never throws.
+ */
+import { Database } from "bun:sqlite";
+import type { AgentTool } from "jeopi-agent-core";
+import type { FetchImpl } from "jeopi-ai";
+import type { Settings } from "..";
+import type { ToolSession } from "./index";
+export declare function isAutoQaEnabled(settings?: Settings): boolean;
+/**
+ * Resolver for the user's "share grievances?" consent.
+ *
+ * Return values:
+ *   - `true`  — user agreed; record + ship for this run and persist.
+ *   - `false` — user declined; suppress for this run and persist.
+ *   - `null`  — user dismissed the dialog (ESC, click-away, …) without
+ *               picking an option. The decision is NOT cached or persisted,
+ *               so the next `report_tool_issue` invocation re-prompts.
+ *
+ * Persistence is the tool's job (so subagent invocations can persist into
+ * the disk-backed `Settings` instance the host registered alongside the
+ * handler), not the handler's. Implementations live in hosts that have UI
+ * affordances — today only `InteractiveMode`. When no handler is
+ * registered (CLI subcommands, tests, non-interactive runs) consent
+ * defaults to `false` — the explicit "don't collect by default" stance.
+ */
+export type AutoQaConsentHandler = () => Promise<boolean | null>;
+/**
+ * Register the consent handler and the persistent {@link Settings} instance
+ * the decision should be written to. Passing `null` clears the handler
+ * (e.g. on `InteractiveMode` teardown). Re-registration is authoritative.
+ */
+export declare function setAutoQaConsentHandler(handler: AutoQaConsentHandler | null, persistentSettings?: Settings | null): void;
+/** Test-only: clear consent cache + handler. Never call from production code. */
+export declare function __resetAutoQaConsentForTests(): void;
+/**
+ * Resolve the user's consent for `report_tool_issue` grievances.
+ *
+ * Precedence (highest first):
+ *   1. Process-global cache (set on first successful resolution).
+ *   2. Persistent setting (`dev.autoqa.consent` on the supplied `Settings`).
+ *   3. Persistent setting on the registered host `Settings`.
+ *   4. Consent handler popup (single-flight; persists the answer).
+ *   5. Default-deny when no handler is registered.
+ *
+ * Never throws — handler errors degrade to "denied for this call" without
+ * caching, so a subsequent invocation can re-prompt instead of being
+ * permanently locked into the false branch.
+ */
+export declare function resolveAutoQaConsent(settings: Settings | undefined): Promise<boolean>;
+/**
+ * Open (or return the cached handle for) the auto-QA SQLite database at
+ * `~/.jeopi/agent/autoqa.db`. Idempotently runs schema creation, the
+ * `pushed`-column migration, and index setup so every consumer — tool
+ * execute path, manual `jeopi grievances push`, future debug scripts —
+ * sees the same prepared schema. Returns `null` only on a hard open
+ * failure (filesystem permissions, etc.); a missing file is created.
+ *
+ * Exported because the `jeopi grievances` CLI handlers need the migrated
+ * handle too — having a second `openDb` in the CLI led to the column
+ * never being added on the manual-push path.
+ */
+export declare function openAutoQaDb(): Database | null;
+export interface FlushResult {
+    pushed: number;
+    ok: boolean;
+    skipped?: boolean;
+}
+/**
+ * Optional per-flush controls. Used by `jeopi grievances push` to surface
+ * progress to a TTY and to skip the user-facing consent gate (manual
+ * pushes are the user's explicit intent, not a side effect of a tool call).
+ */
+export interface FlushOptions {
+    /**
+     * Skip the `dev.autoqa.consent === "granted"` gate in
+     * {@link resolvePushConfig}. Endpoint configuration is still required.
+     * Reserved for explicit user-driven pushes (CLI `grievances push`,
+     * future debug recipes); never set from the tool's auto-flush path.
+     */
+    bypassConsent?: boolean;
+    /**
+     * Fetch implementation for the push POST. Defaults to global fetch.
+     */
+    fetch?: FetchImpl;
+    /**
+     * Fires once at the start of the loop with the snapshot count of
+     * unpushed rows. Subsequent inserts won't be reflected (the count is
+     * a planning hint for progress reporters, not a live total).
+     */
+    onStart?: (totalUnpushed: number) => void;
+    /**
+     * Fires after every successfully shipped batch with the running pushed
+     * count. Reporters compare against the `totalUnpushed` they saw in
+     * `onStart` to advance their bar.
+     */
+    onProgress?: (pushedSoFar: number) => void;
+}
+/** Test-only: clear single-flight + cooldown state. Never call from production code. */
+export declare function __resetAutoQaFlushStateForTests(): void;
+/**
+ * Flush queued grievances to the configured backend.
+ *
+ * Single-flight: concurrent callers share the in-flight promise. After a
+ * failed push, retries are skipped for {@link FAILURE_COOLDOWN_MS} ms.
+ * Never throws — all errors are caught and routed to the logger.
+ */
+export declare function flushGrievances(db?: Database, settings?: Settings, options?: FlushOptions): Promise<FlushResult>;
+export declare function createReportToolIssueTool(session: ToolSession, activeBuiltinNames?: readonly string[]): AgentTool;

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

@@ -0,0 +1,94 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, CustomMessage } from "jeopi-agent-core";
+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 resolveSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "apply" | "discard";
+    reason: string;
+    extra?: Record<string, unknown> | undefined;
+}, {}>;
+type ResolveParams = typeof resolveSchema.infer;
+export interface ResolveToolDetails {
+    action: "apply" | "discard";
+    reason: string;
+    extra?: Record<string, unknown>;
+    sourceToolName?: string;
+    label?: string;
+    sourceResultDetails?: unknown;
+}
+/**
+ * Register a non-forcing resolve-protocol handler for a staged preview. Wraps the
+ * caller's apply/reject into an onInvoked closure (matching the resolve schema) and
+ * stores it on the tool-choice queue's pending-invoker registry under a UNIQUE id.
+ * The `resolve` tool dispatches to it; the agent-loop's SoftToolRequirement
+ * lifecycle injects the preview reminder and escalates to a forced `resolve` only
+ * if the model declines — so a compliant turn pays ZERO tool_choice change (no
+ * prompt-cache messages-cache invalidation).
+ *
+ * This is the canonical entry point for any tool that wants preview/apply
+ * semantics. No session-level abstraction is needed: callers pass their
+ * apply/reject functions directly.
+ */
+export declare function queueResolveHandler(session: ToolSession, options: {
+    label: string;
+    sourceToolName: string;
+    apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+}): void;
+/**
+ * The canonical preview reminder. The resolve mechanism owns the wording; the
+ * agent-loop delivers it via the session's `SoftToolRequirement.reminder` (injected
+ * once per pending-preview head) instead of a host-side steer, so it lands as a
+ * stable mid-history append and never churns the cached prefix.
+ */
+export declare function buildResolveReminderMessage(sourceToolName: string): CustomMessage;
+/**
+ * Shared invocation runner used by both queued (in-flight) handlers and
+ * standing handlers (e.g. plan-mode approval). Discriminates on action,
+ * routes through the caller's apply/reject, and wraps the resulting tool
+ * payload with `ResolveToolDetails` so the renderer and event-controller
+ * see a consistent shape.
+ */
+export declare function runResolveInvocation(params: ResolveParams, options: {
+    sourceToolName: string;
+    label: string;
+    apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+    /** Invoked synchronously when `apply()` throws, before the error is rethrown.
+     *  The queued caller uses this to re-push the resolve directive so the
+     *  pending preview survives a failed apply (e.g. overlapping ast_edit
+     *  replacements) and the model can `discard` or fix-and-retry. */
+    onApplyError?(error: unknown): void;
+}): Promise<AgentToolResult<ResolveToolDetails>>;
+export declare class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
+    private readonly session;
+    readonly name = "resolve";
+    readonly approval: "read";
+    readonly label = "Resolve";
+    readonly hidden = true;
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "apply" | "discard";
+        reason: string;
+        extra?: Record<string, unknown> | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly intent: (args: Partial<ResolveParams>) => string;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: ResolveParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ResolveToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<ResolveToolDetails>>;
+}
+export declare const resolveToolRenderer: {
+    renderCall(args: ResolveParams, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: ResolveToolDetails;
+        isError?: boolean;
+    }, _options: RenderResultOptions, uiTheme: Theme): Component;
+    inline: boolean;
+    mergeCallAndResult: boolean;
+};
+export {};

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

@@ -0,0 +1,59 @@
+/**
+ * Legacy hidden review-finding tool for agents that have not migrated to
+ * incremental `yield` sections.
+ *
+ * Hidden by default - only enabled when explicitly listed in an agent's tools.
+ * Reviewers now finish via incremental `yield`; this tool remains for
+ * compatibility with older or custom review agents.
+ */
+import type { AgentTool } from "jeopi-agent-core";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
+import type { ReviewFinding } from "../task/types";
+export type FindingPriority = "P0" | "P1" | "P2" | "P3";
+export interface FindingPriorityInfo {
+    ord: 0 | 1 | 2 | 3;
+    symbol: "status.error" | "status.warning" | "status.info";
+    color: ThemeColor;
+}
+export declare const PRIORITY_LABELS: FindingPriority[];
+export declare function isFindingPriority(value: unknown): value is FindingPriority;
+export declare function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo;
+declare const ReportFindingParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    title: string;
+    body: string;
+    priority: "P0" | "P1" | "P2" | "P3";
+    confidence: number;
+    file_path: string;
+    line_start: number;
+    line_end: number;
+}, {}>;
+interface ReportFindingDetails {
+    title: string;
+    body: string;
+    priority: FindingPriority;
+    confidence: number;
+    file_path: string;
+    line_start: number;
+    line_end: number;
+}
+export declare function parseReportFindingDetails(value: unknown): ReportFindingDetails | undefined;
+export declare const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme>;
+/** SubmitReviewDetails - used for rendering review results from yield tool */
+export interface SubmitReviewDetails {
+    overall_correctness: "correct" | "incorrect";
+    explanation: string;
+    confidence: number;
+}
+export type { ReportFindingDetails };
+/**
+ * Coerce a tool-side `ReportFindingDetails` into the cross-boundary
+ * `ReviewFinding` shape consumed by the reviewer agent's JTD output schema.
+ *
+ * The `report_finding` tool exposes `priority` as a string enum (`"P0".."P3"`)
+ * for ergonomics, but the bundled reviewer schema (and every custom review
+ * agent that mirrors it) declares `priority: number`. Without this coercion
+ * the auto-populated `findings[]` fails JTD validation and every review run
+ * that surfaces a finding is rejected with `findings.0.priority: expected
+ * number, received string`.
+ */
+export declare function toReviewFinding(details: ReportFindingDetails): ReviewFinding;

package/dist/types/tools/search-tool-bm25.d.ts

@@ -0,0 +1,65 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { type DiscoverableTool } from "../tool-discovery/tool-index";
+import type { ToolSession } from ".";
+declare const searchToolBm25Schema: import("arktype/internal/variants/object.ts").ObjectType<{
+    query: string;
+    limit?: number | undefined;
+}, {}>;
+type SearchToolBm25Params = typeof searchToolBm25Schema.infer;
+interface SearchToolBm25Match {
+    name: string;
+    label: string;
+    description: string;
+    server_name?: string;
+    mcp_tool_name?: string;
+    schema_keys: string[];
+    score: number;
+}
+export interface SearchToolBm25Details {
+    query: string;
+    limit: number;
+    total_tools: number;
+    activated_tools: string[];
+    active_selected_tools: string[];
+    tools: SearchToolBm25Match[];
+}
+export declare function renderSearchToolBm25Description(discoverableTools?: DiscoverableTool[]): string;
+/**
+ * SearchToolsTool — wire name `search_tool_bm25` (preserved for persisted session back-compat).
+ *
+ * When tools.discoveryMode === "all", this covers both MCP tools and built-in discoverable tools.
+ * When tools.discoveryMode === "mcp-only" or mcp.discoveryMode === true, only MCP tools are searched.
+ */
+export declare class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema, SearchToolBm25Details> {
+    private readonly session;
+    readonly name = "search_tool_bm25";
+    readonly approval: "read";
+    readonly label = "SearchTools";
+    readonly loadMode = "essential";
+    get description(): string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        query: string;
+        limit?: number | undefined;
+    }, {}>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): SearchToolBm25Tool | null;
+    execute(_toolCallId: string, params: SearchToolBm25Params, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<SearchToolBm25Details>, _context?: AgentToolContext): Promise<AgentToolResult<SearchToolBm25Details>>;
+}
+export declare const searchToolBm25Renderer: {
+    renderCall(args: SearchToolBm25Params, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SearchToolBm25Details;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme): Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};
+export {};