@prometheus-ai/agent 0.5.4 → 0.5.8

package/dist/types/task/executor.d.ts

@@ -4,9 +4,13 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import type { AgentTelemetryConfig, ThinkingLevel } from "@prometheus-ai/agent-core";
+import type { Rule } from "../capability/rule";
 import { ModelRegistry } from "../config/model-registry";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
+import { type SettingPath } from "../config/settings-schema";
+import type { ToolPathWithSource } from "../extensibility/custom-tools";
+import type { CustomTool } from "../extensibility/custom-tools/types";
 import { type Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
@@ -18,6 +22,16 @@ import type { ContextFileEntry } from "../tools";
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
 import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult } from "./types";
+/**
+ * Soft per-agent request budgets (assistant requests per run). When a subagent
+ * crosses its budget it receives ONE steering notice asking it to wrap up; at
+ * 1.5x the budget the run is aborted gracefully so partial output is salvaged.
+ * The `default` key applies to agents without an explicit entry and can be
+ * overridden via the `task.softRequestBudget` setting (0 disables the guard).
+ */
+export declare const SOFT_REQUEST_BUDGET: Record<string, number>;
+/** Steering notice injected once when a subagent crosses its soft request budget. */
+export declare function buildBudgetNotice(requests: number): string;
 /** Options for subagent execution */
 export interface ExecutorOptions {
     cwd: string;
@@ -25,6 +39,7 @@ export interface ExecutorOptions {
     agent: AgentDefinition;
     task: string;
     assignment?: string;
+    /** Shared background from the task call (`task.batch`), rendered into the subagent's system prompt. */
     context?: string;
     /**
      * The session's active overall plan, handed off so subagents spawned during
@@ -36,8 +51,18 @@ export interface ExecutorOptions {
         content: string;
     };
     description?: string;
+    /** Specialist role/expertise for this spawn; drives the system-prompt preamble, display name, and telemetry identity. */
+    role?: string;
     index: number;
     id: string;
+    parentToolCallId?: string;
+    /**
+     * Spawn runs as a detached background job (parent turn not blocked on it).
+     * Rides the subagent lifecycle/progress payloads so HUD-style surfaces can
+     * skip spawns the transcript already renders inline. See
+     * {@link SubagentLifecyclePayload.detached}.
+     */
+    detached?: boolean;
     modelOverride?: string | string[];
     /**
      * Active model selector of the parent session, used as an auth-aware fallback
@@ -48,19 +73,38 @@ export interface ExecutorOptions {
     outputSchema?: unknown;
     /** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */
     taskDepth?: number;
+    /**
+     * Override the `task.maxRuntimeMs` wall-clock cap for this run. When provided
+     * it wins over the settings value; `0` disables the per-subagent wall-clock
+     * limit entirely. Used by the eval `agent()` bridge, whose parent cell
+     * watchdog is already suspended for the call's duration.
+     */
+    maxRuntimeMs?: number;
     enableLsp?: boolean;
     signal?: AbortSignal;
     onProgress?: (progress: AgentProgress) => void;
     sessionFile?: string | null;
     persistArtifacts?: boolean;
     artifactsDir?: string;
-    /** Path to parent conversation context file */
-    contextFile?: string;
     eventBus?: EventBus;
     contextFiles?: ContextFileEntry[];
     skills?: Skill[];
     promptTemplates?: PromptTemplate[];
     workspaceTree?: WorkspaceTree;
+    /** Parent-discovered rules, forwarded to skip rule discovery in the subagent. */
+    rules?: Rule[];
+    /**
+     * Parent's discovered extension source paths. Forwarded to skip the
+     * extension FS scan in the subagent; the subagent then re-binds each
+     * extension against its own `ExtensionAPI` (cwd, eventBus, runtime).
+     */
+    preloadedExtensionPaths?: string[];
+    /**
+     * Parent's discovered custom-tool source paths. Forwarded to skip the
+     * `.prometheus/tools/` FS scan in the subagent; the subagent then re-binds each
+     * tool against its own `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
+     */
+    preloadedCustomToolPaths?: ToolPathWithSource[];
     mcpManager?: MCPManager;
     authStorage?: AuthStorage;
     modelRegistry?: ModelRegistry;
@@ -93,6 +137,15 @@ export interface YieldItem {
     data?: unknown;
     status?: "success" | "aborted";
     error?: string;
+    /**
+     * Set by the in-tool yield validator when it exhausted its retry budget
+     * (MAX_SCHEMA_RETRIES) and accepted a schema-invalid payload anyway.
+     * `finalizeSubprocessOutput` honors this by serializing the payload and
+     * surfacing a stderr warning, instead of re-emitting `schema_violation`
+     * — which would silently swap the subagent's "accepted" view for a
+     * different, opaque error blob in the parent's view of the result.
+     */
+    schemaOverridden?: boolean;
 }
 interface FinalizeSubprocessOutputArgs {
     rawOutput: string;
@@ -111,9 +164,15 @@ interface FinalizeSubprocessOutputResult {
     abortedViaYield: boolean;
     hasYield: boolean;
 }
+export declare const SUBAGENT_WARNING_SCHEMA_OVERRIDDEN = "SYSTEM WARNING: Subagent exhausted schema-retry budget; result was accepted despite failing the output schema.";
 export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
 export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
 export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
+/**
+ * Create proxy tools that reuse the parent's MCP connections.
+ */
+export declare function createMCPProxyTools(mcpManager: MCPManager): CustomTool[];
+export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>): Settings;
 /**
  * Run a single agent in-process.
  */

package/dist/types/task/index.d.ts

@@ -1,22 +1,52 @@
+/**
+ * Task tool - Delegate tasks to specialized agents.
+ *
+ * Discovers agent definitions from:
+ *   - Bundled agents (shipped with prometheus-coding-agent)
+ *   - ~/.prometheus/agent/agents/*.md (user-level)
+ *   - .prometheus/agents/*.md (project-level)
+ *
+ * Supports:
+ *   - Single agent spawn per call (parallelism = parallel task calls)
+ *   - Batch spawning + shared context per call when `task.batch` is enabled
+ *   - Background execution through AsyncJobManager when `async.enabled` is enabled
+ *   - Progress tracking via JSON events
+ *   - Session artifacts for debugging
+ */
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { ToolSession } from "..";
 import type { Theme } from "../modes/theme/theme";
-import { type AgentDefinition, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
+import { type AgentDefinition, type SingleResult, type TaskItem, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
 import "../tools/review";
 import { renderResult, renderCall as renderTaskCall } from "./render";
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";
 export { AgentOutputManager } from "./output-manager";
-export type { AgentDefinition, AgentProgress, SingleResult, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
+export type { AgentDefinition, AgentProgress, SingleResult, SubagentEventPayload, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
 export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
 export declare const READ_ONLY_TOOL_NAMES: ReadonlySet<string>;
 export declare function isReadOnlyAgent(agent: AgentDefinition): boolean;
+/**
+ * Preview text for a child result. Falls back to "(no output)" — annotated
+ * with the request count when the child actually did work, so the parent can
+ * tell a no-op child from one that burned requests before being cancelled.
+ */
+export declare function formatResultOutputFallback(result: Pick<SingleResult, "output" | "stderr" | "requests">): string;
+/**
+ * Advisory — never a rejection — nudging the spawner toward tailored
+ * specialists when it spawns generic role-less workers and still holds spawn
+ * capacity (DepthCapacity: it currently has the `task` tool). Fires when a
+ * generic `task`/`quick_task` spawn carries no `role`, or when one call clones
+ * the same agent ≥2× all without roles. Returns undefined when no nudge applies.
+ */
+export declare function buildSpecializationAdvisory(agentName: string | undefined, items: TaskItem[], depthCapacity: boolean): string | undefined;
 /**
  * Task tool - Delegate tasks to specialized agents.
  *
- * Requires async initialization to discover available agents.
- * Use `TaskTool.create(session)` to instantiate.
+ * Each call spawns one subagent — or, with `task.batch`, one per `tasks[]`
+ * item. When `async.enabled` is on, spawns run as AsyncJobManager jobs; when
+ * disabled, the tool blocks until every spawn finishes.
  */
 export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetails, Theme> {
     #private;
@@ -25,10 +55,11 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
     readonly approval: "exec";
     readonly formatApprovalDetails: (args: unknown) => string[];
     readonly label = "Task";
-    readonly summary = "Spawn a subagent to complete a parallel task";
+    readonly summary = "Spawn subagents to complete delegated tasks";
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly renderResult: typeof renderResult;
+    readonly mergeCallAndResult = true;
     get parameters(): TaskToolSchemaInstance;
     renderCall(args: unknown, options: Parameters<typeof renderTaskCall>[1], theme: Theme): import("@prometheus-ai/tui").Component;
     /** Dynamic description that reflects current disabled-agent settings */
@@ -38,5 +69,5 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
      * Create a TaskTool instance with async agent discovery.
      */
     static create(session: ToolSession): Promise<TaskTool>;
-    execute(_toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
+    execute(toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
 }

package/dist/types/task/output-manager.d.ts

@@ -17,11 +17,4 @@ export declare class AgentOutputManager {
      * @returns Unique ID ("Anna" first, then "Anna-2", "Anna-3", …)
      */
     allocate(id: string): Promise<string>;
-    /**
-     * Allocate unique IDs for a batch of tasks.
-     *
-     * @param ids Array of requested IDs
-     * @returns Array of unique IDs in same order
-     */
-    allocateBatch(ids: string[]): Promise<string[]>;
 }

package/dist/types/task/parallel.d.ts

@@ -19,10 +19,10 @@ export interface ParallelResult<R> {
  *
  * @param items - Items to process
  * @param concurrency - Maximum concurrent operations
- * @param fn - Async function to execute for each item
+ * @param fn - Async function to execute for each item; receives a worker signal that fires on abort or fail-fast so in-flight siblings can cancel
  * @param signal - Optional abort signal to stop scheduling new work
  */
-export declare function mapWithConcurrencyLimit<T, R>(items: T[], concurrency: number, fn: (item: T, index: number) => Promise<R>, signal?: AbortSignal): Promise<ParallelResult<R>>;
+export declare function mapWithConcurrencyLimit<T, R>(items: T[], concurrency: number, fn: (item: T, index: number, signal: AbortSignal) => Promise<R>, signal?: AbortSignal): Promise<ParallelResult<R>>;
 /**
  * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
  */

package/dist/types/task/prometheus-command.d.ts

@@ -1,7 +1,7 @@
-interface OmpCommand {
+interface PrometheusCommand {
     cmd: string;
     args: string[];
     shell: boolean;
 }
-export declare function resolveOmpCommand(): OmpCommand;
+export declare function resolvePrometheusCommand(): PrometheusCommand;
 export {};

package/dist/types/task/render.d.ts

@@ -1,15 +1,25 @@
 import type { Component } from "@prometheus-ai/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
+import { type Theme } from "../modes/theme/theme";
 import type { TaskParams, TaskToolDetails } from "./types";
+/** Render context threaded in from `ToolExecutionComponent.#buildRenderContext`. */
+interface TaskRenderContext {
+    hasResult?: boolean;
+    /**
+     * The block left the transcript live region (detached spawn the transcript
+     * has moved past, or a sealed block): progress rows render static gray, so
+     * commit-eligible rows do not repaint after entering native scrollback.
+     */
+    frozen?: boolean;
+}
+type TaskRenderOptions = RenderResultOptions & {
+    renderContext?: TaskRenderContext;
+};
+export declare function formatTaskId(id: string): string;
 /**
  * Render the tool call arguments.
  */
-export declare function renderCall(args: TaskParams, options: RenderResultOptions & {
-    renderContext?: {
-        hasResult?: boolean;
-    };
-}, theme: Theme): Component;
+export declare function renderCall(args: TaskParams, options: TaskRenderOptions, theme: Theme): Component;
 /**
  * Render the tool result.
  */
@@ -19,8 +29,11 @@ export declare function renderResult(result: {
         text?: string;
     }>;
     details?: TaskToolDetails;
-}, options: RenderResultOptions, theme: Theme): Component;
+    isError?: boolean;
+}, options: TaskRenderOptions, theme: Theme, args?: TaskParams): Component;
 export declare const taskToolRenderer: {
     renderCall: typeof renderCall;
     renderResult: typeof renderResult;
+    mergeCallAndResult: boolean;
 };
+export {};

package/dist/types/task/repair-args.d.ts

@@ -2,7 +2,7 @@
  * Repair double-encoded JSON string arguments for the task tool.
  *
  * Models occasionally JSON-escape a string value twice when emitting a
- * `task` tool call, so a `context`/`assignment` that should read
+ * `task` tool call, so an `assignment` that should read
  *
  *     # Role
  *     You are a judge … "describe this" … return —
@@ -24,7 +24,7 @@
  * string.
  *
  * This is deliberately scoped to the task tool's natural-language fields
- * (`context`, `assignment`, `description`). It is NOT applied to code-bearing
+ * (`assignment`, `description`). It is NOT applied to code-bearing
  * tools (write/edit/bash/search), where a backslash or quote is load-bearing
  * and a false-positive unescape would silently corrupt a file or command.
  */
@@ -43,10 +43,11 @@ import type { TaskParams } from "./types";
  */
 export declare function repairDoubleEncodedJsonString(value: string): string;
 /**
- * Repair double-encoded prose in task-tool params (`context` and each task's
- * `assignment`/`description`). Returns the same reference when nothing changed
- * so callers can cheaply skip work. Defensive against partially-streamed args
- * (missing/undefined fields, partial task arrays) so it is safe on the render
- * path as well as on execution.
+ * Repair double-encoded prose in task-tool params (`assignment`,
+ * `description`, shared `context`, and each batch task item's prose fields).
+ * Returns the same reference when nothing changed so callers can cheaply skip
+ * work. Defensive against partially-streamed args (missing/undefined fields,
+ * partial task arrays) so it is safe on the render path as well as on
+ * execution.
  */
 export declare function repairTaskParams(params: TaskParams): TaskParams;

package/dist/types/task/types.d.ts

@@ -1,7 +1,7 @@
 import type { ThinkingLevel } from "@prometheus-ai/agent-core";
 import type { Usage } from "@prometheus-ai/ai";
-import * as z from "zod/v4";
-import { type TaskSimpleMode } from "./simple-mode";
+import { z } from "zod/v4";
+import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
@@ -21,9 +21,17 @@ export interface SubagentProgressPayload {
     agent: string;
     agentSource: AgentSource;
     task: string;
+    parentToolCallId?: string;
     assignment?: string;
     progress: AgentProgress;
     sessionFile?: string;
+    /** See {@link SubagentLifecyclePayload.detached}. */
+    detached?: boolean;
+}
+/** Payload emitted on TASK_SUBAGENT_EVENT_CHANNEL */
+export interface SubagentEventPayload {
+    id: string;
+    event: AgentSessionEvent;
 }
 /** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
 export interface SubagentLifecyclePayload {
@@ -33,89 +41,134 @@ export interface SubagentLifecyclePayload {
     description?: string;
     status: "started" | "completed" | "failed" | "aborted";
     sessionFile?: string;
+    parentToolCallId?: string;
     index: number;
+    /**
+     * Spawn runs as a detached background job: the parent turn keeps working
+     * while this agent runs. Sync task spawns (parent blocked on the call) and
+     * eval `agent()` bridge spawns (rendered inside their eval cell) leave this
+     * unset — surfaces like the subagent HUD only list detached spawns.
+     */
+    detached?: boolean;
 }
-/** Single task item for parallel execution (default shape with context enabled). */
+/** Display cap for a normalized one-line label (roster line, registry `displayName`, prompt field). */
+export declare const ROLE_LABEL_MAX = 80;
+/** Schema bound on the raw `role` input, before it is label-normalized at every use site. */
+export declare const ROLE_INPUT_MAX = 256;
 export declare const taskItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    description: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
     assignment: z.ZodString;
 }, z.core.$strip>;
-export type TaskItem = z.infer<typeof taskItemSchema>;
+/** Single task item. Fields are optional defensively: args stream in token by token. */
+export interface TaskItem {
+    /** Stable agent id; default = generated AdjectiveNoun. */
+    id?: string;
+    /** UI label, not seen by the subagent. */
+    description?: string;
+    /** Specialist role/expertise this subagent embodies; shapes its system-prompt identity and display name. */
+    role?: string;
+    /** The work; required by the schema. */
+    assignment?: string;
+    /** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
+    isolated?: boolean;
+}
 export declare const taskSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    assignment: z.ZodString;
+    isolated: z.ZodOptional<z.ZodBoolean>;
     agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const taskSchemaNoIsolation: z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    assignment: z.ZodString;
+    isolated: z.ZodOptional<z.ZodBoolean>;
     agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    assignment: z.ZodString;
     agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
+    context: z.ZodString;
     tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
         assignment: z.ZodString;
+        isolated: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
+    context: z.ZodString;
     tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
         assignment: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
 export type TaskSchema = typeof taskSchema;
-/** Active task tool parameter schema for the current simple-mode / isolation flags */
+/** Active task tool parameter schema for the current isolation / batch flags */
 export type TaskToolSchemaInstance = DynamicTaskSchema;
 export declare function getTaskSchema(options: {
     isolationEnabled: boolean;
-    simpleMode: TaskSimpleMode;
+    batchEnabled: boolean;
 }): DynamicTaskSchema;
+/**
+ * Runtime params union over both wire shapes. The model sees exactly one shape
+ * (`{ agent, context, tasks[] }` when `task.batch` is on, `{ agent, ...item }`
+ * otherwise); runtime stays permissive so internal callers and stale
+ * transcripts using the flat form keep working under either setting.
+ */
 export interface TaskParams {
-    agent: string;
+    /** Agent type; required. */
+    agent?: string;
+    /** Stable agent id (flat form); default = generated AdjectiveNoun. */
+    id?: string;
+    /** UI label (flat form), not seen by the subagent. */
+    description?: string;
+    /** Specialist role/expertise this subagent embodies; shapes its system-prompt identity and display name. */
+    role?: string;
+    /** The work (flat form). */
+    assignment?: string;
+    /** Batch form (`task.batch`): one subagent per item. */
+    tasks?: TaskItem[];
+    /** Batch form: shared background prepended to every assignment; required by the batch schema. */
     context?: string;
-    schema?: string;
-    tasks: TaskItem[];
+    /** Run in an isolated worktree (flat form; per-item in batch form). */
     isolated?: boolean;
 }
+/**
+ * One-line, length-capped label safe for a single roster line, a registry
+ * `displayName`, or a system-prompt field. Collapses every run of whitespace
+ * AND control/format characters — including U+0085 NEL, ESC/ANSI, and the
+ * zero-width separators that `\s` misses — to a single space, then caps length.
+ * So untrusted text (a spawn `role`, a peer activity gist) can neither break the
+ * line, inject prompt structure, nor smuggle terminal escapes. Caps at `max`
+ * characters (clamped to >= 1; default `ROLE_LABEL_MAX`), appending an ellipsis when truncated.
+ */
+export declare function oneLineLabel(text: string, max?: number): string;
+/**
+ * Display name for a spawned subagent: its tailored `role` (label-normalized)
+ * when one is given, else the agent type's name. Empty/whitespace roles fall
+ * back to the agent name.
+ */
+export declare function resolveSubagentDisplayName(role: string | undefined, agentName: string): string;
+/**
+ * Whether an agent at `taskDepth` may still spawn children — i.e. it currently
+ * holds the `task` tool. Mirrors the task-tool availability gate;
+ * `maxRecursionDepth < 0` disables the cap entirely.
+ */
+export declare function canSpawnAtDepth(maxRecursionDepth: number, taskDepth: number): boolean;
 /** A code review finding reported by the reviewer agent */
 export interface ReviewFinding {
     title: string;
@@ -175,6 +228,8 @@ export interface AgentProgress {
     }>;
     recentOutput: string[];
     toolCount: number;
+    /** Count of assistant requests (assistant message_end events) across the run. Drives the soft request budget guard. */
+    requests: number;
     /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
     tokens: number;
     /**
@@ -244,6 +299,8 @@ export interface SingleResult {
     durationMs: number;
     /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
     tokens: number;
+    /** Count of assistant requests (assistant message_end events) across the run. */
+    requests: number;
     /** Latest per-turn context size at task completion. See `AgentProgress.contextTokens`. */
     contextTokens?: number;
     /** Model's context window in tokens, when known. */

package/dist/types/task/worktree.d.ts

@@ -78,6 +78,8 @@ export interface MergeBranchResult {
     merged: string[];
     failed: string[];
     conflict?: string;
+    /** Set when cherry-picks landed on HEAD but restoring the stashed working tree failed. */
+    stashConflict?: string;
 }
 /**
  * Cherry-pick task branch commits sequentially onto HEAD.

package/dist/types/telemetry-export.d.ts

@@ -1,7 +1,7 @@
 /**
  * OTLP trace export bootstrap.
  *
- * prometheus's agent core (`@prometheus-ai/agent-core`) emits OpenTelemetry GenAI
+ * Prometheus's agent core (`@prometheus-ai/agent-core`) emits OpenTelemetry GenAI
  * spans through the global `@opentelemetry/api` tracer, but only when a
  * TracerProvider is registered in the process — otherwise the API returns a
  * no-op tracer and the spans are silently dropped. The shipped CLI never
@@ -34,7 +34,7 @@ export declare function isTelemetryExportEnabled(): boolean;
  * the OTEL kill-switches are engaged), so it is safe to call unconditionally at
  * startup.
  */
-export declare function initTelemetryExport(): void;
+export declare function initTelemetryExport(): Promise<void>;
 /**
  * Flush any buffered spans to the exporter. No-op when export is disabled.
  * Hosts embedding the agent can call this at natural boundaries (e.g. the end

package/dist/types/thinking.d.ts

@@ -24,6 +24,10 @@ export declare function getThinkingLevelMetadata(level: ThinkingLevel): Thinking
  * Converts an agent-local selector into the effort sent to providers.
  */
 export declare function toReasoningEffort(level: ThinkingLevel | undefined): Effort | undefined;
+/**
+ * True when a selector explicitly requests provider-side reasoning disablement.
+ */
+export declare function shouldDisableReasoning(level: ThinkingLevel | undefined): boolean;
 /**
  * Resolves a selector against the current model while preserving explicit "off".
  */

package/dist/types/tiny/models.d.ts

@@ -1,4 +1,4 @@
-/** Default session-title model: the online prometheus/smol path (no local download / on-device inference). */
+/** Default session-title model: the online pi/smol path (no local download / on-device inference). */
 export declare const ONLINE_TINY_TITLE_MODEL_KEY = "online";
 /** Local model the `tiny-models` CLI downloads when none is named. Not the session-title default — that is {@link ONLINE_TINY_TITLE_MODEL_KEY}. */
 export declare const DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY = "lfm2-700m";

package/dist/types/tiny/title-client.d.ts

@@ -18,6 +18,16 @@ export interface TinyTitleDownloadOptions {
     signal?: AbortSignal;
     onProgress?: (event: TinyTitleProgressEvent) => void;
 }
+/**
+ * Per-request controls for {@link TinyTitleClient.generate}.
+ *
+ * Carries the optional abort signal and title-system-prompt override used by
+ * callers that customize automatic session-title generation.
+ */
+export interface TinyTitleGenerateOptions {
+    signal?: AbortSignal;
+    systemPrompt?: string;
+}
 /**
  * Hidden subcommand on the main CLI that boots the tiny-model worker in the
  * spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
@@ -32,7 +42,7 @@ export declare const TINY_WORKER_ARG = "--tiny-worker";
  */
 export declare function tinyWorkerEnvOverlay(env: Record<string, string | undefined>, deviceSetting: string | undefined, dtypeSetting: string | undefined): Record<string, string>;
 interface SpawnedSubprocess {
-    proc: Subprocess<"ignore", "inherit", "inherit">;
+    proc: Subprocess<"ignore", "ignore", "ignore">;
     inbound: Set<(message: TinyTitleWorkerOutbound) => void>;
     errors: Set<(error: Error) => void>;
     /**
@@ -56,6 +66,7 @@ export declare class TinyTitleClient {
     constructor(spawnWorker?: () => WorkerHandle);
     onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
     generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
+    generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;
     complete(modelKey: string, prompt: string, options?: {
         maxTokens?: number;
         signal?: AbortSignal;

package/dist/types/tiny/title-protocol.d.ts

@@ -24,6 +24,7 @@ export type TinyTitleWorkerInbound = {
     id: string;
     modelKey: TinyTitleLocalModelKey;
     message: string;
+    systemPrompt?: string;
 } | {
     type: "complete";
     id: string;