@prometheus-ai/agent 0.5.4 → 0.5.8

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

@@ -0,0 +1,51 @@
+import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
+import { z } from "zod/v4";
+import type { ToolSession } from ".";
+declare const learnSchema: z.ZodObject<{
+    memory: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    skill: z.ZodOptional<z.ZodObject<{
+        action: z.ZodEnum<{
+            create: "create";
+            update: "update";
+        }>;
+        name: z.ZodString;
+        description: z.ZodString;
+        body: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LearnParams = z.infer<typeof learnSchema>;
+/**
+ * Orchestrating "learn" tool: persists a lesson to long-term memory and,
+ * given a `skill` payload, mints/enhances a managed skill via the shared
+ * `writeManagedSkill` primitive. Gated behind `autolearn.enabled` plus a live
+ * memory backend — `hindsight`/`mnemopi` (remote/SQLite) or `local` (the
+ * file-based rollout backend, where lessons append to `learned.md`).
+ */
+export declare class LearnTool implements AgentTool<typeof learnSchema> {
+    private readonly session;
+    readonly name = "learn";
+    readonly approval: (args: unknown) => "read" | "write";
+    readonly label = "Learn";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        memory: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+        skill: z.ZodOptional<z.ZodObject<{
+            action: z.ZodEnum<{
+                create: "create";
+                update: "update";
+            }>;
+            name: z.ZodString;
+            description: z.ZodString;
+            body: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode: "essential";
+    readonly summary = "Capture a reusable lesson to memory (and optionally a managed skill)";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): LearnTool | null;
+    execute(_id: string, params: LearnParams): Promise<AgentToolResult>;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
+import { z } from "zod/v4";
+import type { ToolSession } from ".";
+declare const manageSkillSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        update: "update";
+    }>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ManageSkillParams = z.infer<typeof manageSkillSchema>;
+/**
+ * Direct create/update/delete of isolated managed skills. Gated behind
+ * `autolearn.enabled`; backend-independent (the skill side is standalone).
+ */
+export declare class ManageSkillTool implements AgentTool<typeof manageSkillSchema> {
+    readonly name = "manage_skill";
+    readonly approval: "write";
+    readonly label = "Manage Skill";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        action: z.ZodEnum<{
+            create: "create";
+            delete: "delete";
+            update: "update";
+        }>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode: "essential";
+    readonly summary = "Create, update, or delete an isolated managed skill";
+    static createIf(session: ToolSession): ManageSkillTool | null;
+    execute(_id: string, params: ManageSkillParams): Promise<AgentToolResult>;
+}
+export {};

package/dist/types/tools/memory-edit.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolSession } from ".";
 declare const memoryEditSchema: z.ZodObject<{
     op: z.ZodEnum<{
@@ -32,7 +32,7 @@ export declare class MemoryEditTool implements AgentTool<typeof memoryEditSchema
     }, z.core.$strip>;
     readonly strict = true;
     readonly loadMode = "discoverable";
-    readonly summary = "Update, forget, or invalidate Prometheus Memory memories";
+    readonly summary = "Update, forget, or invalidate Mnemopi memories";
     constructor(session: ToolSession);
     static createIf(session: ToolSession): MemoryEditTool | null;
     execute(_id: string, params: MemoryEditParams): Promise<AgentToolResult>;

package/dist/types/tools/memory-recall.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolSession } from ".";
 declare const memoryRecallSchema: z.ZodObject<{
     query: z.ZodString;

package/dist/types/tools/memory-reflect.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolSession } from ".";
 declare const memoryReflectSchema: z.ZodObject<{
     query: z.ZodString;

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

@@ -4,7 +4,10 @@
  *
  * These keep the transcript terse — one status line plus, for `retain`, one
  * `Remember: …` line per stored item — instead of the generic JSON arg tree,
- * which exploded multi-line memory blobs into an unreadable wall.
+ * which exploded multi-line memory blobs into an unreadable wall. The tool
+ * container is a transparent passthrough, so these renderers stay frameless:
+ * a status line with a couple of dim bullets reads far cleaner than boxing a
+ * one-line memory note.
  */
 import type { Component } from "@prometheus-ai/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";

package/dist/types/tools/memory-retain.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolSession } from ".";
 declare const memoryRetainSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{

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

@@ -115,19 +115,27 @@ export interface ResolvedMultiSearchPath {
     exactFilePaths?: string[];
     targets?: ResolvedSearchTarget[];
 }
-export interface ResolvedMultiFindPattern {
+export interface ResolvedFindTarget {
     basePath: string;
     globPattern: string;
+    hasGlob: boolean;
+}
+export interface ResolvedMultiFindPattern {
+    targets: ResolvedFindTarget[];
     scopePath: string;
 }
+export declare function parseSearchPath(filePath: string): ParsedSearchPath;
 /**
- * Split a user path into a base path + glob pattern for tools that delegate to
- * APIs accepting separate `path` and `glob` arguments.
+ * Async sibling of {@link parseSearchPath} that prefers literal interpretation
+ * when a path containing glob metacharacters resolves to an existing entry on
+ * disk. Disambiguates Next.js/SvelteKit routes like `apps/[id]/page.tsx` —
+ * without this, `[id]` is parsed as a glob character class and silently
+ * matches nothing.
  */
-export declare function parseSearchPath(filePath: string): ParsedSearchPath;
+export declare function parseSearchPathPreferringLiteral(filePath: string, cwd: string): Promise<ParsedSearchPath>;
 export declare function parseFindPattern(pattern: string): ParsedFindPattern;
 export declare function combineSearchGlobs(prefixGlob?: string, suffixGlob?: string): string | undefined;
-export declare function resolveExplicitSearchPaths(pathItems: string[], cwd: string, suffixGlob?: string): Promise<ResolvedMultiSearchPath | undefined>;
+export declare function resolveExplicitSearchPaths(pathItems: string[], cwd: string, suffixGlob?: string, fanOutFileItems?: boolean): Promise<ResolvedMultiSearchPath | undefined>;
 export declare function resolveExplicitFindPatterns(patternItems: string[], cwd: string): Promise<ResolvedMultiFindPattern | undefined>;
 /**
  * Result of partitioning a list of user-supplied paths/globs into entries whose
@@ -168,6 +176,10 @@ export interface ToolScopeOptions {
     trackImmutableSources?: boolean;
     /** Honor `exactFilePaths` from {@link resolveExplicitSearchPaths} (search-only). */
     surfaceExactFilePaths?: boolean;
+    /** Fan plain-file entries out into per-target scans instead of folding them
+     * into a directory walk's glob union (search-only: the caller must dedupe
+     * matches from overlapping targets). */
+    fanOutFileTargets?: boolean;
     /** Extra hint appended to "Path not found" when stat fails and the user supplied multiple paths. */
     multipathStatHint?: string;
     /** Calling session's settings — forwarded to the internal-URL router so caller-aware handlers (issue://, pr://) honor it. */

package/dist/types/tools/plan-mode-guard.d.ts

@@ -1,16 +1,25 @@
 import type { ToolSession } from ".";
+/** Strip the hashline `[path#TAG]` wrapper from a write/edit target so the inner
+ *  filesystem path drives both authorization and resolution. Only unwraps inputs
+ *  that match the strict hashline header shape (`[path]` or `[path#XXXX]` with a
+ *  4-hex tag); anything else returns the original string so the downstream
+ *  resolver surfaces the real error. Exported for callers (e.g. `write`) that
+ *  make scheme/bridge-routing decisions before {@link resolvePlanPath} runs. */
+export declare function unwrapHashlineHeaderPath(targetPath: string): string;
 /**
- * Resolve a write/edit target to its absolute filesystem path.
- *
- * In plan mode, transparently redirects `PLAN.md` aliases and targets whose
- * basename matches the plan file's basename to the canonical plan file
- * location at `state.planFilePath`. This lets `write` and `edit` accept the
- * habitual plan filename after approval even when the active artifact has a
- * titled path such as `local://APPROVED.md`.
- *
- * Outside plan mode (or when the basename does not match) this is a no-op.
+ * Resolve a write/edit target to its absolute filesystem path, honoring the
+ * `local://` and `vault://` schemes. Plain paths resolve against the session cwd.
+ * Bracketed hashline headers (`[path#TAG]`) are unwrapped first so the inner
+ * filesystem path drives resolution — keeping the plan-mode guard and the
+ * eventual write in lockstep.
  */
 export declare function resolvePlanPath(session: ToolSession, targetPath: string): string;
+/**
+ * Plan mode keeps the working tree read-only while letting the agent draft its
+ * plan. Writes and edits to the `local://` artifact sandbox are allowed (that is
+ * where the plan and any scratch notes live); anything that would touch the
+ * working tree — or rename/delete a file — is rejected.
+ */
 export declare function enforcePlanModeWrite(session: ToolSession, targetPath: string, options?: {
     move?: string;
     op?: "create" | "update" | "delete";

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
@@ -39,6 +39,8 @@ export interface ReadToolDetails {
     };
     /** Number of unresolved git conflicts surfaced by this read (TUI uses for inline `⚠ N` badge). */
     conflictCount?: number;
+    /** Paths recovered from a delimited read argument; used only by the TUI to render one call as multiple read rows. */
+    displayReadTargets?: string[];
 }
 type ReadParams = ReadToolInput;
 /**
@@ -58,7 +60,6 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
     readonly parameters: z.ZodObject<{
         path: z.ZodString;
     }, z.core.$strict>;
-    readonly nonAbortable = true;
     readonly strict = true;
     constructor(session: ToolSession);
     execute(_toolCallId: string, params: ReadParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ReadToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<ReadToolDetails>>;

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

@@ -1,5 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolSession } from "./index";
 declare const renderMermaidSchema: z.ZodObject<{
     mermaid: z.ZodString;

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

@@ -46,8 +46,8 @@ export declare const TRUNCATE_LENGTHS: {
     /** Very short (task previews, badges) */
     readonly SHORT: 40;
 };
-/** Standard expand hint text */
-export declare const EXPAND_HINT = "(Ctrl+O for more)";
+/** 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.
  */
@@ -76,24 +76,16 @@ export declare function formatBadge(label: string, color: ToolUIColor, theme: Th
  * 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;
 /**
- * Maximum rows a tool's streaming/pending *call* preview may render before it is
- * capped. This is intentionally conservative: the preview still sits inside a
- * transcript that already consumed some viewport rows, and tool blocks carry
- * extra chrome (status/header/border/"more lines"), so a "reasonable" raw code
- * or command preview like 10-12 lines can still overflow and strand its top
- * while the block is volatile. Keeping the live call window short avoids that
- * across terminals without turning the transcript into an interactive scroller.
- */
-export declare const CALL_PREVIEW_MAX_LINES = 6;
-/**
- * Cap a pre-rendered pending/call preview to a bounded window. When truncated,
- * show both the head and the live tail so the user can still see what the tool
- * is currently writing while the volatile block stays short enough not to strand
- * its top above the viewport. `Ctrl+O` widens the bounded window, but does not
- * fully uncap live tool previews for the same reason.
+ * 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 summary line so
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the marker line so
  * nested previews stay aligned.
  */
 export declare function capPreviewLines(lines: string[], theme: Theme, options?: {
@@ -103,10 +95,18 @@ export declare function capPreviewLines(lines: string[], theme: Theme, options?:
 }): 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" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
+export type ToolUIStatus = "success" | "done" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
 export type ToolUIColor = "success" | "error" | "warning" | "accent" | "muted";
 export interface ToolUITitleOptions {
     bold?: boolean;
@@ -116,7 +116,9 @@ export declare function formatDiagnostics(diag: {
     errored: boolean;
     summary: string;
     messages: string[];
-}, expanded: boolean, theme: Theme, getLangIcon: (filePath: string) => string): string;
+}, expanded: boolean, theme: Theme, getLangIcon: (filePath: string) => string, options?: {
+    title?: string;
+}): string;
 export interface DiffStats {
     added: number;
     removed: number;
@@ -155,18 +157,36 @@ export declare function capParseErrors(errors: string[] | undefined, limit?: num
     errors: string[];
     total: number;
 };
-/**
- * Group `rawLines` by blank-line separators, mirroring the historical search /
- * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
- * runs of blank lines; otherwise collapses non-empty lines into a single group.
- */
-export declare function splitGroupsByBlankLine(rawLines: string[]): string[][];
 /**
  * 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[]): Component;
+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

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

@@ -6,7 +6,7 @@
 import type { Component } from "@prometheus-ai/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-type ToolRenderer = {
+export type ToolRenderer = {
     renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
     renderResult: (result: {
         content: Array<{
@@ -21,6 +21,14 @@ type ToolRenderer = {
     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";
 };
 export declare const toolRenderers: Record<string, ToolRenderer>;
-export {};

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

@@ -13,7 +13,7 @@
  * (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.prometheus.trivlab.com`). Each
+ * bundled endpoint (`dev.autoqaPush.endpoint`, default `qa.prometheus.sh`). Each
  * insert schedules a background flush that POSTs pending rows and deletes
  * them on HTTP 2xx. `PROMETHEUS_AUTO_QA_PUSH=1` forces push in non-interactive
  * environments where the consent dialog never fires. Tool execution is
@@ -21,6 +21,7 @@
  */
 import { Database } from "bun:sqlite";
 import type { AgentTool } from "@prometheus-ai/agent-core";
+import type { FetchImpl } from "@prometheus-ai/ai";
 import type { Settings } from "..";
 import type { ToolSession } from "./index";
 export declare function isAutoQaEnabled(settings?: Settings): boolean;
@@ -97,6 +98,10 @@ export interface FlushOptions {
      * 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

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";

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

@@ -6,7 +6,7 @@
  * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
  */
 import type { AgentTool } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { Theme, ThemeColor } from "../modes/theme/theme";
 import type { ReviewFinding } from "../task/types";
 export type FindingPriority = "P0" | "P1" | "P2" | "P3";

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import { type DiscoverableTool } from "../tool-discovery/tool-index";

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import { type TruncationResult } from "../session/streaming-output";
@@ -11,7 +11,7 @@ declare const searchSchema: z.ZodObject<{
     paths: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     i: z.ZodOptional<z.ZodBoolean>;
     gitignore: z.ZodOptional<z.ZodBoolean>;
-    skip: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strict>;
 export type SearchToolInput = z.infer<typeof searchSchema>;
 export declare function toPathList(input: string | string[] | undefined): string[];
@@ -47,6 +47,10 @@ export interface SearchToolDetails {
     /** 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. The renderer resolves the display-relative
+     * (cwd-relative) header/match paths against this for OSC 8 hyperlinks;
+     * `searchPath` is the scope label target, not the display-path base. */
+    cwd?: string;
     /** User-supplied paths whose base directory was missing on disk. The tool
      * skipped these and continued with the surviving entries; surfaced as a
      * non-fatal warning in the renderer and in the model-facing text. */
@@ -66,7 +70,7 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
         paths: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
         i: z.ZodOptional<z.ZodBoolean>;
         gitignore: z.ZodOptional<z.ZodBoolean>;
-        skip: z.ZodOptional<z.ZodNumber>;
+        skip: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$strict>;
     readonly strict = true;
     constructor(session: ToolSession);

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

@@ -1,4 +1,7 @@
 import type { Database } from "bun:sqlite";
+export declare function looksLikeSqlite(bytes: Uint8Array): boolean;
+/** Row cap for raw `?q=` SQL — protects against `SELECT *` on multi-million-row tables. */
+export declare const MAX_RAW_QUERY_ROWS = 1000;
 export interface SqlitePathCandidate {
     sqlitePath: string;
     subPath: string;
@@ -83,6 +86,7 @@ export declare function getRowByRowId(db: Database, table: string, key: string):
 export declare function executeReadQuery(db: Database, sql: string): {
     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: {

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { 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";
@@ -65,5 +65,6 @@ export declare const sshToolRenderer: {
         renderContext?: SshRenderContext;
     }, uiTheme: Theme, args?: SshRenderArgs): Component;
     mergeCallAndResult: boolean;
+    provisionalPendingPreview: string;
 };
 export {};

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

@@ -1,21 +1,14 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { 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";
+import type { SessionEntry } from "../session/session-entries";
 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;
@@ -37,9 +30,9 @@ declare const todoSchema: z.ZodObject<{
             done: "done";
             drop: "drop";
             init: "init";
-            note: "note";
             rm: "rm";
             start: "start";
+            view: "view";
         }>;
         list: z.ZodOptional<z.ZodArray<z.ZodObject<{
             phase: z.ZodString;
@@ -48,7 +41,6 @@ declare const todoSchema: z.ZodObject<{
         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 TodoParams = z.infer<typeof todoSchema>;
@@ -110,9 +102,9 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
                 done: "done";
                 drop: "drop";
                 init: "init";
-                note: "note";
                 rm: "rm";
                 start: "start";
+                view: "view";
             }>;
             list: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 phase: z.ZodString;
@@ -121,7 +113,6 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
             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";
@@ -146,14 +137,15 @@ export declare const TODO_STRIKE_HOLD_FRAMES = 2;
 export declare const TODO_STRIKE_REVEAL_FRAMES = 12;
 export declare const TODO_STRIKE_TOTAL_FRAMES: number;
 export declare const todoToolRenderer: {
-    renderCall(args: TodoRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{
             type: string;
             text?: string;
         }>;
         details?: TodoToolDetails;
-    }, options: RenderResultOptions, uiTheme: Theme, _args?: TodoRenderArgs): Component;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: TodoRenderArgs): Component;
     mergeCallAndResult: boolean;
 };
 export {};

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

@@ -26,6 +26,8 @@ export declare class ToolResultBuilder<TDetails extends DetailsWithMeta> {
     diagnostics(summary: string, messages: string[]): this;
     /** Flag the result as a non-throwing failure (agent-loop surfaces it as a tool error). */
     error(value?: boolean): this;
+    /** Marks the result contextually useless — compaction may elide it once consumed. */
+    useless(value?: boolean): this;
     done(): AgentToolResult<TDetails>;
 }
 export declare function toolResult<TDetails extends DetailsWithMeta>(details?: TDetails): ToolResultBuilder<TDetails>;

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

@@ -15,7 +15,7 @@ export declare const TOOL_TIMEOUTS: {
     readonly eval: {
         readonly default: 30;
         readonly min: 1;
-        readonly max: 600;
+        readonly max: 3600;
     };
     readonly browser: {
         readonly default: 30;