@oh-my-pi/pi-coding-agent 17.0.1 → 17.0.3

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

@@ -24,7 +24,7 @@ import type { ConfiguredThinkingLevel } from "../thinking.js";
 import type { ContextFileEntry } from "../tools/index.js";
 import type { EventBus } from "../utils/event-bus.js";
 import type { WorkspaceTree } from "../workspace-tree.js";
-import { type AgentDefinition, type AgentProgress, type SingleResult, type YieldItem } from "./types.js";
+import { type AgentDefinition, type AgentProgress, type SingleResult, type StructuredSubagentOutput, type StructuredSubagentSchemaMode, type StructuredSubagentSchemaSource, type YieldItem } from "./types.js";
 export type { YieldItem } from "./types.js";
 /**
  * Soft per-agent request budgets (assistant requests per run). Crossing the
@@ -78,7 +78,12 @@ export interface ExecutorOptions {
      */
     parentActiveModelPattern?: string;
     thinkingLevel?: ConfiguredThinkingLevel;
+    /** Schema used to validate the final structured completion. */
     outputSchema?: unknown;
+    /** Enforcement policy for {@link outputSchema}; defaults to legacy permissive behavior. */
+    outputSchemaMode?: StructuredSubagentSchemaMode;
+    /** Origin of the selected schema, preserved in {@link SingleResult.structuredOutput}. */
+    outputSchemaSource?: StructuredSubagentSchemaSource;
     /**
      * Caller supplied a schema that supersedes the agent's native output prompt.
      * Eval `agent(..., schema=...)` sets this so built-in agents ignore stale yield labels.
@@ -93,7 +98,20 @@ export interface ExecutorOptions {
      * watchdog is already suspended for the call's duration.
      */
     maxRuntimeMs?: number;
+    /** Include IRC only when the invocation policy permits collaboration. */
+    enableIrc?: boolean;
     enableLsp?: boolean;
+    /**
+     * Enable MCP capabilities for this child. `false` suppresses both inherited
+     * MCP proxy tools and session MCP discovery; it never consults the
+     * process-global MCP manager. Defaults to `true`.
+     */
+    enableMCP?: boolean;
+    /**
+     * Limit the child to its explicit host tool names and the required yield
+     * tool, suppressing discovered and always-included capabilities.
+     */
+    restrictToolNames?: boolean;
     signal?: AbortSignal;
     onProgress?: (progress: AgentProgress) => void;
     /**
@@ -183,6 +201,8 @@ interface FinalizeSubprocessOutputArgs {
     signalAborted: boolean;
     yieldItems?: YieldItem[];
     outputSchema: unknown;
+    outputSchemaMode?: StructuredSubagentSchemaMode;
+    outputSchemaSource?: StructuredSubagentSchemaSource;
     lastAssistantText?: string;
 }
 interface FinalizeSubprocessOutputResult {
@@ -191,6 +211,7 @@ interface FinalizeSubprocessOutputResult {
     stderr: string;
     abortedViaYield: boolean;
     hasYield: boolean;
+    structuredOutput?: StructuredSubagentOutput;
 }
 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.";
@@ -230,6 +251,10 @@ export interface FollowUpTurnOptions {
     message: string;
     index?: number;
     description?: string;
+    /** Structured-output state retained from the original invocation. */
+    outputSchema?: unknown;
+    outputSchemaMode?: StructuredSubagentSchemaMode;
+    outputSchemaSource?: StructuredSubagentSchemaSource;
     signal?: AbortSignal;
     onProgress?: (progress: AgentProgress) => void;
     eventBus?: EventBus;

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

@@ -64,7 +64,7 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
     readonly formatApprovalDetails: (args: unknown) => string[];
     readonly label = "Task";
     readonly summary = "Spawn subagents to complete delegated tasks";
-    readonly strict = true;
+    readonly strict = false;
     readonly loadMode = "essential";
     readonly renderResult: typeof renderResult;
     readonly mergeCallAndResult = true;

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

@@ -1,4 +1,4 @@
 import type { ModelRegistry } from "../config/model-registry.js";
 import type { Settings } from "../config/settings.js";
 /** Compresses a delegated assignment into a one-sentence UI label via the tiny title model — fired by the executor spawn path because the task wire schema no longer carries a `description`; null on empty input or failure. */
-export declare function generateTaskLabel(assignment: string, registry: ModelRegistry, settings: Settings, sessionId?: string): Promise<string | null>;
+export declare function generateTaskLabel(assignment: string, registry: ModelRegistry, settings: Settings, sessionId?: string, signal?: AbortSignal): Promise<string | null>;

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

@@ -23,6 +23,20 @@ export interface ParallelResult<R> {
  * @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, signal: AbortSignal) => Promise<R>, signal?: AbortSignal): Promise<ParallelResult<R>>;
+/** Result of a concurrency-limited operation that waits for every launched item. */
+export interface ParallelSettledResult<R> {
+    /** Settled results in original input order; absent entries were never launched after cancellation. */
+    results: (PromiseSettledResult<R> | undefined)[];
+    /** Whether cancellation prevented scheduling all items. */
+    aborted: boolean;
+}
+/**
+ * Execute items with a concurrency limit without failing fast. Rejections are
+ * captured at their input position and already launched siblings always settle
+ * before this function returns. Cancellation stops new launches but preserves
+ * the settled state of every item that began.
+ */
+export declare function mapWithConcurrencyLimitAllSettled<T, R>(items: T[], concurrency: number, fn: (item: T, index: number, signal: AbortSignal) => Promise<R>, signal?: AbortSignal): Promise<ParallelSettledResult<R>>;
 /**
  * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
  *

package/dist/types/task/structured-subagent.d.ts

@@ -0,0 +1,111 @@
+import type { ToolSession } from "../tools/index.js";
+import { type DiscoveryResult } from "./discovery.js";
+import { type AgentDefinition, type AgentProgress, type SingleResult, type StructuredSubagentOutput } from "./types.js";
+/** Validation behavior requested for an effective output schema. */
+export type StructuredSubagentSchemaMode = "permissive" | "strict";
+/** Where an effective output schema came from. */
+export type StructuredSubagentSchemaSource = "caller" | "agent" | "session" | "none";
+/** Final structured completion metadata returned for a schema-bearing run. */
+export type StructuredSubagentSchemaResult = StructuredSubagentOutput;
+/** A schema validation or extraction error attached to structured completion metadata. */
+export type StructuredSubagentSchemaError = NonNullable<StructuredSubagentOutput["error"]>;
+/** A selected schema paired with its source and enforcement mode. */
+export interface StructuredSubagentSchemaResolution {
+    schema: unknown;
+    source: StructuredSubagentSchemaSource;
+    mode: StructuredSubagentSchemaMode;
+    outputSchemaOverridesAgent: boolean;
+}
+/** Isolation controls shared by the task and eval surfaces. */
+export interface StructuredSubagentIsolationControls {
+    requested?: boolean;
+    merge?: "patch" | "branch";
+    apply?: boolean;
+}
+/** Identity and presentation metadata supplied by the calling surface. */
+export interface StructuredSubagentIdentity {
+    /** A previously reserved output/registry id. */
+    id?: string;
+    /** Stable user-facing label used when allocating a new id. */
+    label?: string;
+}
+/** One normalized child invocation. */
+export interface StructuredSubagentRequest {
+    session: ToolSession;
+    invocationKind: "task" | "eval";
+    assignment: string;
+    context?: string;
+    agent?: string;
+    model?: string | string[];
+    /** Presence, rather than truthiness, makes this the highest-priority schema. */
+    outputSchema?: unknown;
+    schemaMode?: StructuredSubagentSchemaMode;
+    identity?: StructuredSubagentIdentity;
+    index?: number;
+    parentToolCallId?: string;
+    detached?: boolean;
+    invokedAt?: number;
+    acquiredAt?: number;
+    isolation?: StructuredSubagentIsolationControls;
+    /** The parent agent name forbidden from recursively spawning itself. */
+    blockedAgent?: string;
+    /** Preserve a completed temporary artifacts directory for an agent:// handle. */
+    retainArtifacts?: boolean;
+    /** Task UI agents keep live registry references; eval one-shots normally do not. */
+    keepAlive?: boolean;
+    /** Task subagents share their parent's eval kernel; eval bridge children must not. */
+    shareEvalSession?: boolean;
+    /** Task frontends may inherit LSP; eval frontends normally set this false. */
+    enableLsp?: boolean;
+    /** Explicitly pass false for plan mode or invocation kinds that must not use IRC. */
+    enableIrc?: boolean;
+    /** `0` disables executor wall-clock timeout. Undefined inherits settings. */
+    maxRuntimeMs?: number;
+    signal?: AbortSignal;
+    onProgress?: (progress: AgentProgress) => void;
+}
+/** A normalized preflight result, reusable by tests and adapters. */
+export interface EffectiveSubagentPolicy {
+    discovery: DiscoveryResult;
+    agentName: string;
+    agent: AgentDefinition;
+    effectiveAgent: AgentDefinition;
+    modelOverride?: string | string[];
+    parentActiveModelPattern?: string;
+    schema: StructuredSubagentSchemaResolution;
+    planMode: boolean;
+    isIsolated: boolean;
+    mergeMode: "patch" | "branch";
+    applyChanges: boolean;
+    enableLsp: boolean;
+    enableIrc: boolean;
+}
+/** Settled child execution plus data needed by the frontends' own rendering. */
+export interface StructuredSubagentResult {
+    result: SingleResult;
+    policy: EffectiveSubagentPolicy;
+    mergeSummary: string;
+    changesApplied: boolean | null;
+    artifactsDir: string;
+    temporaryArtifacts: boolean;
+}
+/** Machine-readable failure category so adapters can retain their native errors. */
+export declare class StructuredSubagentError extends Error {
+    readonly kind: "preflight" | "isolation" | "execution";
+    constructor(kind: "preflight" | "isolation" | "execution", message: string, options?: ErrorOptions);
+}
+/**
+ * Resolve every policy shared by task and eval before allocating artifacts or
+ * dispatching work. Callers translate {@link StructuredSubagentError} into
+ * their own wire-level error surface.
+ */
+export declare function resolveEffectiveSubagentPolicy(request: StructuredSubagentRequest): Promise<EffectiveSubagentPolicy>;
+/** Reserve a session-global agent id only after preflight has succeeded. */
+export declare function reserveStructuredSubagentId(session: ToolSession, identity: StructuredSubagentIdentity | undefined): Promise<string>;
+/**
+ * Execute a validated subagent. Preflight errors occur before any artifact
+ * lease or child dispatch; callers keep responsibility for their result text.
+ */
+export declare function runStructuredSubagent(request: StructuredSubagentRequest): Promise<StructuredSubagentResult>;
+/** Build the recovery suffix used by adapters after an isolated failure. */
+export declare function buildStructuredSubagentRecoveryHint(result: SingleResult, artifactsDir: string): Promise<string>;

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

@@ -5,6 +5,32 @@ import type { ConfiguredThinkingLevel } from "../thinking.js";
 import type { NestedRepoPatch } from "./worktree.js";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
+/**
+ * Enforcement policy for a structured subagent output schema.
+ *
+ * `permissive` preserves legacy retry-budget overrides; `strict` turns every
+ * invalid final payload, including an exhausted retry override, into a failed
+ * `schema_violation` result.
+ */
+export type StructuredSubagentSchemaMode = "permissive" | "strict";
+/** Origin of the schema selected for a structured subagent invocation. */
+export type StructuredSubagentSchemaSource = "caller" | "agent" | "session" | "none";
+/** Final validation state of a structured subagent invocation. */
+export type StructuredSubagentValidationStatus = "valid" | "invalid" | "unavailable";
+/**
+ * Parsed structured completion and its schema-validation metadata.
+ *
+ * `data` is present whenever a payload could be assembled or parsed, even when
+ * strict validation rejects it. `error` explains unavailable or invalid
+ * validation without requiring consumers to parse presentation text.
+ */
+export interface StructuredSubagentOutput {
+    source: StructuredSubagentSchemaSource;
+    mode: StructuredSubagentSchemaMode;
+    status: StructuredSubagentValidationStatus;
+    data?: unknown;
+    error?: string;
+}
 /** Maximum output bytes per agent */
 export declare const MAX_OUTPUT_BYTES: number;
 /** Maximum output lines per agent */
@@ -57,6 +83,8 @@ export declare const taskItemSchema: import("arktype/internal/variants/object.ts
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    outputSchema?: unknown;
+    schemaMode?: "permissive" | "strict" | undefined;
 }, {}>;
 /** Single task item. Fields are optional defensively: args stream in token by token. */
 export interface TaskItem {
@@ -66,6 +94,10 @@ export interface TaskItem {
     agent?: string;
     /** The work; required by the schema. */
     task?: string;
+    /** Caller-provided output schema; its presence overrides the selected agent's schema. */
+    outputSchema?: unknown;
+    /** Validation behavior for a caller-provided or inherited output schema. */
+    schemaMode?: "permissive" | "strict";
     /** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
     isolated?: boolean;
 }
@@ -73,23 +105,31 @@ export declare const taskSchema: import("arktype/internal/variants/object.ts").O
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    outputSchema?: unknown;
+    schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
 }, {}>;
 declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/object.ts").ObjectType<{
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    outputSchema?: unknown;
+    schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    outputSchema?: unknown;
+    schemaMode?: "permissive" | "strict" | undefined;
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
     context: string;
     tasks: {
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
+        outputSchema?: unknown;
+        schemaMode?: "permissive" | "strict" | undefined;
         isolated?: boolean | undefined;
     }[];
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
@@ -98,6 +138,8 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
+        outputSchema?: unknown;
+        schemaMode?: "permissive" | "strict" | undefined;
     }[];
 }, {}>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
@@ -126,6 +168,10 @@ export interface TaskParams {
     agent?: string;
     /** The work (flat form). */
     task?: string;
+    /** Caller-provided output schema; its presence overrides the selected agent's schema. */
+    outputSchema?: unknown;
+    /** Validation behavior for a caller-provided or inherited output schema. */
+    schemaMode?: "permissive" | "strict";
     /** Batch form (`task.batch`): one subagent per item. */
     tasks?: TaskItem[];
     /** Batch form: shared background prepended to every assignment; required by the batch schema. */
@@ -294,6 +340,11 @@ export interface SingleResult {
     output: string;
     stderr: string;
     truncated: boolean;
+    /**
+     * Parsed structured completion and validation metadata, when this invocation
+     * selected an output schema or strict schema mode.
+     */
+    structuredOutput?: StructuredSubagentOutput;
     durationMs: number;
     /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
     tokens: number;

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

@@ -1,19 +1,44 @@
 /**
- * Whether {@link initTelemetryExport} registered a real provider. The CLI uses
- * this to decide whether to switch on the agent loop's telemetry config — there
- * is no point emitting spans into a no-op tracer.
+ * OTLP telemetry export bootstrap.
+ *
+ * oh-my-pi's agent core (`@oh-my-pi/pi-agent-core`) emits OpenTelemetry GenAI
+ * spans through the global `@opentelemetry/api` tracer, and exposes run-level
+ * callbacks for metrics/log pipelines. This module registers the OTLP/proto
+ * trace, log, and metric SDK providers when the standard `OTEL_*` endpoint env
+ * vars are set so `omp` can be observed by any OTLP collector without vendor
+ * coupling.
+ *
+ * Only the `http/protobuf` transport is supported — an
+ * `OTEL_EXPORTER_OTLP*_PROTOCOL` of `grpc` or `http/json` declines rather than
+ * misrouting protobuf payloads. The exporter line is pinned to the 0.218/2.7
+ * family validated under Bun; the 1.x OTLP line deadlocks when its
+ * `req.on("close")` handler fires after a successful export.
+ */
+import type { AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core";
+/**
+ * Whether {@link initTelemetryExport} registered any real OTLP signal provider.
+ * The CLI uses this to decide whether to switch on the agent loop's telemetry
+ * hooks; metrics and structured logs need those callbacks even when traces are
+ * disabled.
  */
 export declare function isTelemetryExportEnabled(): boolean;
 /**
- * Register the global TracerProvider + OTLP exporter when an OTLP endpoint is
- * configured via env. Idempotent, and a no-op when no endpoint is set (or when
- * the OTEL kill-switches are engaged), so it is safe to call unconditionally at
- * startup.
+ * Merge OTLP metrics/log hooks into an existing agent telemetry config.
+ *
+ * The caller still owns content-capture policy, cost estimation, and custom
+ * attributes. This only appends host-level metrics/log forwarding for the
+ * providers registered by {@link initTelemetryExport}.
+ */
+export declare function createTelemetryExportConfig(config: AgentTelemetryConfig | undefined): AgentTelemetryConfig | undefined;
+/**
+ * Register global trace/log/meter providers when OTLP endpoints are configured
+ * through env. Idempotent, and a no-op when no signal has an endpoint (or when
+ * the OTEL kill-switches are engaged), so startup can call it unconditionally.
  */
 export declare function initTelemetryExport(): Promise<void>;
 /**
- * Flush any buffered spans to the exporter. No-op when export is disabled.
+ * Flush buffered spans, log records, and metrics. No-op when export is disabled.
  * Hosts embedding the agent can call this at natural boundaries (e.g. the end
- * of a turn) so traces surface promptly rather than on the batch interval.
+ * of a turn) so telemetry surfaces promptly rather than on the batch interval.
  */
 export declare function flushTelemetryExport(): Promise<void>;

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

@@ -17,6 +17,14 @@ export interface ResolvedApproval {
     reason?: string;
     override: boolean;
 }
+/**
+ * Evaluate a tool's own approval declaration against `args` and return the
+ * resulting capability tier, defaulting to `exec` when the tool omits an
+ * approval. Unlike reading `tool.approval` directly, this runs function-valued
+ * approvals — the write tool's `xd://` gate uses it to take a mounted device's
+ * argument-dependent tier instead of falling back to `exec`.
+ */
+export declare function resolveToolTier(tool: ApprovalSubject, args: unknown): ToolTier;
 /**
  * Resolve approval policy for a tool call.
  *

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

@@ -76,6 +76,8 @@ export interface BashToolDetails {
     wallTimeMs?: number;
     /** Exit code of a command that ran to completion but failed (non-zero). */
     exitCode?: number;
+    /** True when the command was killed by its timeout deadline (not a failure). */
+    timedOut?: boolean;
     terminalId?: string;
     async?: {
         state: "running" | "completed" | "failed";

package/dist/types/tools/essential-tools.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Canonical set of built-in tools that must stay top-level.
+ *
+ * These are the coding essentials the model always needs directly in its
+ * callable schema. `read`/`write` are additionally the `xd://` transport
+ * (`read xd://` lists devices, `write xd://<tool>` executes them), so demoting
+ * them under xdev makes every mounted device unreachable.
+ *
+ * Adapter boundaries (extension `registerTool`, SDK custom tools, RPC host
+ * tools) default an omitted `loadMode` to `"discoverable"`. A UI-only
+ * re-register of a built-in — e.g. wrapping `read`/`write`/`bash`/`edit`/`glob`
+ * to customize rendering — would then silently demote it to `discoverable` and,
+ * with `tools.xdev` on, unmount it from the top-level schema (issue #5764).
+ * {@link defaultLoadModeForToolName} pins these names to `"essential"` when the
+ * definition omits `loadMode`, so re-registering a built-in never demotes it.
+ */
+import type { ToolLoadMode } from "@oh-my-pi/pi-agent-core";
+/**
+ * Built-in tool names whose classes declare `loadMode = "essential"`. Kept in
+ * sync with the tool classes by `essential-tools.test.ts` (drift guard).
+ */
+export declare const ESSENTIAL_BUILTIN_TOOL_NAMES: Record<string, true>;
+/**
+ * Resolve a tool's presentation mode at an adapter boundary. An explicit
+ * `declared` mode always wins. When omitted, known essential built-in names
+ * default to `"essential"` (so a re-register never demotes them); everything
+ * else defaults to `"discoverable"`.
+ */
+export declare function defaultLoadModeForToolName(name: string, declared?: ToolLoadMode): ToolLoadMode;

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

@@ -53,22 +53,21 @@ export interface ReadUrlToolDetails {
     notes: string[];
     meta?: OutputMeta;
 }
-interface ReadUrlCacheEntry {
+interface ReadUrlEntry {
     artifactId?: string;
     artifactPath?: string;
-    contentPath?: string;
     details: ReadUrlToolDetails;
     image?: FetchImagePayload;
     output: string;
     content: string;
 }
-export declare function loadReadUrlCacheEntry(session: ToolSession, params: {
+/** Fetch and render a URL for a read or search operation. */
+export declare function fetchReadUrl(session: ToolSession, params: {
     path: string;
     raw?: boolean;
 }, signal?: AbortSignal, options?: {
     ensureArtifact?: boolean;
-    preferCached?: boolean;
-}): Promise<ReadUrlCacheEntry>;
+}): Promise<ReadUrlEntry>;
 /** Materialize rendered URL body text to a local file for tools that require filesystem paths. */
 export declare function materializeReadUrlToFile(session: ToolSession, params: {
     path: string;

package/dist/types/tools/hub/messaging.d.ts

@@ -32,7 +32,11 @@ export declare function resolveMessageTimeoutMs(settings: Settings, explicit?: n
 export declare function drainPendingInbox(registry: AgentRegistry, senderId: string, from?: string): IrcMessage | undefined;
 /** `wait` result carrying a consumed message. */
 export declare function messageResult(senderId: string, waited: IrcMessage): AgentToolResult<CoordinationDetails>;
-export declare function executeList(registry: AgentRegistry, senderId: string): AgentToolResult<CoordinationDetails>;
+/**
+ * List every addressable peer, restoring parked refs from disk when a resumed
+ * session has no in-memory roster.
+ */
+export declare function executeList(registry: AgentRegistry, senderId: string): Promise<AgentToolResult<CoordinationDetails>>;
 export interface HubSendParams {
     to?: string;
     message?: string;

package/dist/types/tools/image-gen.d.ts

@@ -2,7 +2,7 @@ import { type Model } from "@oh-my-pi/pi-ai";
 import { type ModelRegistry } from "../config/model-registry.js";
 import type { CustomTool } from "../extensibility/custom-tools/types.js";
 export type ImageProvider = "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter" | "xai";
-export type ImageProviderPreference = Exclude<ImageProvider, "openai-codex"> | "auto";
+export type ImageProviderPreference = ImageProvider | "auto";
 declare const responseModalitySchema: import("arktype/internal/variants/string.ts").StringType<"IMAGE" | "TEXT", {}>;
 export declare const imageGenSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     subject: string;
@@ -20,6 +20,7 @@ export declare const imageGenSchema: import("arktype/internal/variants/object.ts
         data?: string | undefined;
         mime_type?: string | undefined;
     }[] | undefined;
+    provider?: "antigravity" | "auto" | "gemini" | "openai" | "openai-codex" | "openrouter" | "xai" | undefined;
 }, {}>;
 export type ImageGenParams = typeof imageGenSchema.infer;
 export type GeminiResponseModality = typeof responseModalitySchema.infer;

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

@@ -20,6 +20,7 @@ import type { CustomMessage } from "../session/messages.js";
 import type { UsageStatistics } from "../session/session-entries.js";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue.js";
 import type { AgentOutputManager } from "../task/output-manager.js";
+import { type StructuredSubagentSchemaMode } from "../task/types.js";
 import type { EventBus } from "../utils/event-bus.js";
 import type { WorkspaceTree } from "../workspace-tree.js";
 import { type BuiltinToolName, type HiddenToolName } from "./builtin-names.js";
@@ -40,6 +41,7 @@ export * from "./bash.js";
 export * from "./browser.js";
 export * from "./checkpoint.js";
 export * from "./debug.js";
+export * from "./essential-tools.js";
 export * from "./eval.js";
 export * from "./eval-backends.js";
 export * from "./gh.js";
@@ -143,17 +145,31 @@ export interface ToolSession {
     customToolPaths?: ToolPathWithSource[];
     /** Whether LSP integrations are enabled */
     enableLsp?: boolean;
+    /** Whether this invocation may expose IRC. `false` removes it even for subagents. */
+    enableIrc?: boolean;
+    /**
+     * Whether MCP capabilities may be forwarded to child sessions. `false`
+     * prohibits inherited-manager and process-global MCP fallback.
+     */
+    enableMCP?: boolean;
     /** Whether an edit-capable tool is available in this session (controls hashline output) */
     hasEditTool?: boolean;
     /** Event bus for tool/extension communication */
     eventBus?: EventBus;
-    /** Output schema for structured completion (subagents) */
+    /** Output schema for structured completion (subagents). */
     outputSchema?: unknown;
+    /** Enforcement policy for {@link outputSchema}; defaults to legacy permissive behavior. */
+    outputSchemaMode?: StructuredSubagentSchemaMode;
     /** Whether to include the yield tool by default */
     requireYieldTool?: boolean;
     /** Session starts with a prewalk hand-off armed. Keeps `todo` in yield-gated
      *  (subagent) registries: the prewalk plan nudge + todo gate need it. */
     prewalkArmed?: boolean;
+    /**
+     * Constrain the active set to the caller's explicit built-in names (plus a
+     * required yield tool). Suppresses automatic tool-set expansion.
+     */
+    restrictToolNames?: boolean;
     /** Task recursion depth (0 = top-level, 1 = first child, etc.) */
     taskDepth?: number;
     /** Get shared eval executor session ID. Subagents inherit this to share JS/Python/Ruby/Julia state. */

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

@@ -57,6 +57,35 @@ export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]):
  * the contained side.
  */
 export declare function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean;
+/** Result of {@link selectCollapsedTodos}: the rows to render plus an optional
+ *  summary line (empty string ⇒ no summary row). */
+export interface CollapsedTodoSelection<T> {
+    items: T[];
+    summary: string;
+}
+/**
+ * Walking-viewport selection for a phase's collapsed todo preview (#5873).
+ *
+ * Policy, applied to `tasks` in todo order:
+ * 1. While the phase has open work, completed/abandoned tasks are omitted. A
+ *    phase with no open tasks left falls back to its closed tasks so the sticky
+ *    HUD's closed-todo persistence still has something to render.
+ * 2. Every active task (in-progress, or pending matched to a live subagent) is
+ *    placed at the head in stable todo order — never dropped for lying outside
+ *    an ordinary window.
+ * 3. Remaining rows up to `cap` are filled with the pending tasks that follow
+ *    the first active one, in todo order (falling back to leading pending tasks
+ *    when no active task exists), so a freshly-promoted task leads the preview.
+ * 4. When active tasks alone exceed `cap`, only the first `cap` active tasks are
+ *    shown and the summary counts the hidden *active* todos, never replacing
+ *    them with unrelated pending rows.
+ *
+ * The summary otherwise counts the remaining tasks in the display base. Returns
+ * the whole base with an empty summary when it already fits.
+ */
+export declare function selectCollapsedTodos<T extends {
+    status: TodoStatus;
+}>(tasks: T[], isMatched: (task: T) => boolean, cap: number): CollapsedTodoSelection<T>;
 /** Apply an array of `todo`-style ops to existing phases. Used by /todo slash command. */
 export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoParams[]): {
     phases: TodoPhase[];
@@ -111,6 +140,8 @@ export declare function formatPhaseDisplayName(name: string, oneBasedIndex: numb
 export declare const TODO_STRIKE_HOLD_FRAMES = 2;
 export declare const TODO_STRIKE_REVEAL_FRAMES = 12;
 export declare const TODO_STRIKE_TOTAL_FRAMES: number;
+/** Wire the live-subagent description source for {@link todoToolRenderer}. */
+export declare function setActiveTodoDescriptionsProvider(provider: () => readonly string[]): void;
 export declare const todoToolRenderer: {
     renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {

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

@@ -37,11 +37,20 @@ import type { ToolRenderer } from "./renderers.js";
  * behind dispatch.
  */
 export declare const XDEV_KEEP_TOP_LEVEL: Record<string, true>;
+/**
+ * Tools that carry the `xd://` transport itself and therefore can never be
+ * mounted as devices: `read xd://` lists/documents devices and
+ * `write xd://<tool>` executes them. Demoting either leaves every mounted
+ * device unreachable (issue #5764), so they stay top-level regardless of a
+ * declared `loadMode`.
+ */
+export declare const XDEV_TRANSPORT_TOOLS: Record<string, true>;
 /**
  * Whether an enabled tool is presented under `xd://` (rather than top-level)
  * while the `xd://` transport is active. Discoverable tools mount unless they
- * are pinned top-level by {@link XDEV_KEEP_TOP_LEVEL}; essential tools never do.
- * The caller gates this on the transport being active (a session-owned
+ * are pinned top-level by {@link XDEV_KEEP_TOP_LEVEL} or carry the transport
+ * itself ({@link XDEV_TRANSPORT_TOOLS}); essential tools never do. The caller
+ * gates this on the transport being active (a session-owned
  * {@link XdevRegistry} existing).
  */
 export declare function isMountableUnderXdev(tool: {

package/dist/types/tui/tree-list.d.ts

@@ -13,6 +13,13 @@ export interface TreeListOptions<T> {
     maxCollapsedLines?: number;
     itemType?: string;
     truncateFrom?: "start" | "end";
+    /** Caller-supplied trailing summary line. When set (and not expanded),
+     *  `renderTreeList` renders exactly the provided `items` (the caller has
+     *  already applied its own selection/cap) and appends this text as the
+     *  final `└` row, with the last item using `├`. Empty string renders the
+     *  items with no summary. Bypasses the built-in truncation/`maxCollapsed`
+     *  path. */
+    trailingSummary?: string;
     /** Called once per item with `isLast: false` during budget calculation;
      *  line count MUST NOT vary based on `isLast`. */
     renderItem: (item: T, context: TreeContext) => string | string[];