@oh-my-pi/pi-coding-agent 16.4.2 → 16.4.3

package/dist/types/advisor/config.d.ts

@@ -3,9 +3,10 @@
  * with an optional `:level` thinking suffix (e.g. `x-ai/grok-code-fast:high`),
  * resolved exactly like any other model override; `tools` is a subset of
  * `BUILTIN_TOOL_NAMES` — any built-in name, including mutating tools such as
- * `edit`/`write`/`bash` (the advisor is a full agent). Omitted or empty falls
- * back to the default `read`/`grep`/`glob` subset. `instructions` is the
- * advisor's specialization, appended to the shared baseline.
+ * `edit`/`write`/`bash` (the advisor is a full agent). Omitted falls back to
+ * the default `read`/`grep`/`glob` subset; an explicit empty list grants no
+ * tools. `instructions` is the advisor's specialization, appended to the shared
+ * baseline.
  */
 export interface AdvisorConfig {
     name: string;

package/dist/types/commit/agentic/agent.d.ts

@@ -20,6 +20,7 @@ export interface CommitAgentInput {
     requireChangelog: boolean;
     diffText?: string;
     existingChangelogEntries?: ExistingChangelogEntries[];
+    onComplete?: (state: CommitAgentState) => Promise<void> | void;
 }
 export interface ExistingChangelogEntries {
     path: string;

package/dist/types/config/settings-schema.d.ts

@@ -4569,10 +4569,38 @@ export declare const SETTINGS_SCHEMA: {
                 readonly value: "searxng";
                 readonly label: "SearXNG";
                 readonly description: "Requires SEARXNG_ENDPOINT or searxng.endpoint";
+            }, {
+                readonly value: "startpage";
+                readonly label: "Startpage";
+                readonly description: "Credential-free scrape of Startpage (Google-backed) results; may be bot-challenged";
             }, {
                 readonly value: "duckduckgo";
                 readonly label: "DuckDuckGo";
                 readonly description: "Credential-free best-effort fallback; may be bot-challenged on datacenter/shared-egress IPs";
+            }, {
+                readonly value: "bing";
+                readonly label: "Bing";
+                readonly description: "Credential-free HTML scrape of Bing results; may be bot-challenged";
+            }, {
+                readonly value: "yahoo";
+                readonly label: "Yahoo";
+                readonly description: "Credential-free HTML scrape of Yahoo (Bing-backed) results";
+            }, {
+                readonly value: "ecosia";
+                readonly label: "Ecosia";
+                readonly description: "Credential-free browser-backed scrape of Ecosia (Google-backed) results";
+            }, {
+                readonly value: "google";
+                readonly label: "Google";
+                readonly description: "Credential-free browser-backed fallback; slower and may be bot-challenged";
+            }, {
+                readonly value: "mojeek";
+                readonly label: "Mojeek";
+                readonly description: "Credential-free browser-backed scrape of Mojeek's independent index";
+            }, {
+                readonly value: "public";
+                readonly label: "Public Web";
+                readonly description: "Queries every credential-free engine in parallel and consolidates deduplicated results";
             }];
         };
     };

package/dist/types/extensibility/plugins/legacy-pi-compat.d.ts

@@ -1,16 +1,8 @@
 import * as path from "node:path";
-/**
- * Test seam: builds the synthetic ES module source for a virtual specifier
- * against an explicit registry. Pure (no globalThis read); the emitted source
- * still routes runtime lookups through `globalThis[BUNDLED_REGISTRY_GLOBAL]`.
- */
-export declare function __synthesizeLegacyPiBundledSourceWithRegistry(registryKey: string, registry: Readonly<Record<string, Readonly<Record<string, unknown>>>>): string;
-/**
- * Test seam: returns the globalThis key the synthetic loader reads from. Tests
- * assert that the emitted source addresses the exact stash key the install
- * function writes to, so a rename can't break extension loads silently.
- */
-export declare function __getLegacyPiBundledRegistryGlobal(): string;
+/** Test seam for the virtual module's named/default export forwarding. */
+export declare function __synthesizeLegacyPiBundledSourceWithModules(moduleKey: string, modules: Readonly<Record<string, Readonly<Record<string, unknown>>>>): string;
+/** Test seam for the global bridge key shared with synthetic module source. */
+export declare function __getLegacyPiBundledModulesGlobal(): string;
 /**
  * Compute the package root for the npm prebuilt `dist/cli.js` bundle.
  *
@@ -42,8 +34,8 @@ export declare function __resolveTypeBoxShimPath(isCompiled: boolean, sourcePath
 /**
  * Drop overrides whose filesystem targets are missing so they can fall
  * through to the canonical-resolution path. Virtual `omp-legacy-pi-bundled:`
- * entries always pass — the bundled registry is the source of truth in
- * compiled-binary mode where bunfs paths are unreachable (issue #3423).
+ * entries always pass — live bundled module references are the source of truth
+ * in compiled mode where bunfs paths are unreachable (issue #3423).
  *
  * `pathExistsSync` defaults to `fs.existsSync`; tests inject a stub to
  * simulate the missing-entrypoint failure mode without touching the real FS.
@@ -52,15 +44,11 @@ export declare function __validateLegacyPiPackageRootOverrides(candidates: Recor
 /**
  * Compute the override map keyed by every canonical specifier the host serves
  * directly: the pi-ai / pi-coding-agent roots (compat shims that re-attach
- * legacy helpers) plus, in compiled-binary mode, every other canonical pi-*
- * package root AND every non-wildcard subpath registered in the bundled
- * registry (see `legacy-pi-bundled-keys.ts`). Subpath coverage is what stops
- * `@(scope)/pi-ai/oauth` and friends from falling through to the extension's
- * own — possibly absent — peer install when bunfs filesystem walks fail
- * (issue #3442 follow-up to #3423). Exported as a test seam so the
- * compiled-binary branch is verifiable from dev tests.
+ * legacy helpers) plus, in compiled mode, every build-supplied module key.
+ * Subpath coverage stops `@(scope)/pi-ai/oauth` and friends from falling
+ * through to the extension's absent peer install when bunfs walks fail.
  */
-export declare function __buildLegacyPiPackageRootOverrides(isCompiled: boolean): Record<string, string>;
+export declare function __buildLegacyPiPackageRootOverrides(isCompiled: boolean, bundledModuleKeys?: Iterable<string>): Record<string, string>;
 /** Test seam for compiled-binary legacy extension source rewriting. */
 export declare function __rewriteLegacyExtensionSourceForTests(source: string, importerPath: string, mtimeTag?: string | null): Promise<string>;
 /**

package/dist/types/lsp/deferred-diagnostics.d.ts

@@ -0,0 +1,11 @@
+import type { ToolSession } from "../tools/index.js";
+import type { WritethroughDeferredHandle } from "./index.js";
+/** Coordinates late LSP diagnostics for one mutation tool instance. */
+export declare class DeferredDiagnostics {
+    #private;
+    private readonly session;
+    private readonly deduplicate;
+    constructor(session: ToolSession, deduplicate: boolean);
+    /** Begin a file mutation and return the handle consumed by LSP writethrough. */
+    begin(path: string): WritethroughDeferredHandle;
+}

package/dist/types/modes/components/move-overlay.d.ts

@@ -18,6 +18,6 @@ export declare class MoveOverlay implements Component, Focusable {
     get focused(): boolean;
     set focused(value: boolean);
     handleInput(data: string): void;
-    render(_width: number): readonly string[];
+    render(width: number): readonly string[];
     invalidate(): void;
 }

package/dist/types/modes/components/status-line/component.d.ts

@@ -62,6 +62,9 @@ export declare class StatusLineComponent implements Component {
         enabled: boolean;
         paused: boolean;
     } | undefined): void;
+    setVibeModeStatus(status: {
+        enabled: boolean;
+    } | undefined): void;
     setCollabStatus(status: CollabStatus | null): void;
     setHookStatus(key: string, text: string | undefined): void;
     watchBranch(onBranchChange: () => void): void;

package/dist/types/modes/components/status-line/types.d.ts

@@ -67,6 +67,9 @@ export interface SegmentContext {
         enabled: boolean;
         paused: boolean;
     } | null;
+    vibeMode: {
+        enabled: boolean;
+    } | null;
     collab: CollabStatus | null;
     usageStats: {
         input: number;

package/dist/types/modes/interactive-mode.d.ts

@@ -105,6 +105,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     planModePaused: boolean;
     goalModeEnabled: boolean;
     goalModePaused: boolean;
+    vibeModeEnabled: boolean;
     planModePlanFilePath: string | undefined;
     loopModeEnabled: boolean;
     loopPrompt: string | undefined;
@@ -243,6 +244,13 @@ export declare class InteractiveMode implements InteractiveModeContext {
         slider?: HookSelectorSlider;
     }): Promise<string | undefined>;
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
+    /**
+     * `/vibe` toggle. Entering installs the ephemeral vibe tools, strips the
+     * active toolset down to `read` plus those tools, and injects the director
+     * context. Exiting unregisters them, restores the previous toolset, and kills
+     * every worker session so workers cannot outlive the mode that directs them.
+     */
+    handleVibeModeCommand(initialPrompt?: string): Promise<void>;
     handleGoalModeCommand(rest?: string): Promise<void>;
     handleGuidedGoalCommand(rest?: string): Promise<void>;
     /** Manually (re-)open the plan-review overlay — bound to `/plan-review`. Lets

package/dist/types/modes/types.d.ts

@@ -133,6 +133,7 @@ export interface InteractiveModeContext {
     toolOutputExpanded: boolean;
     todoExpanded: boolean;
     planModeEnabled: boolean;
+    vibeModeEnabled: boolean;
     goalModeEnabled: boolean;
     goalModePaused: boolean;
     loopModeEnabled: boolean;
@@ -369,6 +370,7 @@ export interface InteractiveModeContext {
     openExternalEditor(): void;
     registerExtensionShortcuts(): void;
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
+    handleVibeModeCommand(initialPrompt?: string): Promise<void>;
     handleGoalModeCommand(rest?: string): Promise<void>;
     handleGuidedGoalCommand(rest?: string): Promise<void>;
     handleLoopCommand(args?: string): Promise<string | undefined>;

package/dist/types/session/agent-session.d.ts

@@ -47,6 +47,7 @@ import { type ConfiguredThinkingLevel } from "../thinking.js";
 import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool-discovery/tool-index.js";
 import type { CheckpointState, CompletedRewindState } from "../tools/checkpoint.js";
 import { type TodoItem, type TodoPhase } from "../tools/todo.js";
+import type { VibeModeState } from "../vibe/state.js";
 import type { ClientBridge } from "./client-bridge.js";
 import { type CustomMessage, type CustomMessagePayload } from "./messages.js";
 import type { BuildSessionContextOptions, SessionContext } from "./session-context.js";
@@ -182,6 +183,8 @@ export interface AgentSessionConfig {
     modelRegistry: ModelRegistry;
     /** Tool registry for LSP and settings */
     toolRegistry?: Map<string, AgentTool>;
+    /** Creates the tools registered only while `/vibe` mode is active. */
+    createVibeTools?: () => AgentTool[];
     /** Tool names whose current registry entry is still the built-in implementation. */
     builtInToolNames?: Iterable<string>;
     /** Update tool-session predicates that render guidance from the live active tool set. */
@@ -624,6 +627,14 @@ export declare class AgentSession {
      * Get all configured tool names (built-in via --tools or default, plus custom tools).
      */
     getAllToolNames(): string[];
+    /**
+     * Registers the ephemeral vibe tools and activates them alongside `baseToolNames`.
+     *
+     * @throws When this session cannot create vibe tools or the factory returns duplicate names.
+     */
+    activateVibeTools(baseToolNames: string[]): Promise<void>;
+    /** Removes tools installed by {@link activateVibeTools} and activates `nextToolNames`. */
+    deactivateVibeTools(nextToolNames: string[]): Promise<void>;
     isMCPDiscoveryEnabled(): boolean;
     /**
      * Flip MCP discovery on after deferred discovery learns the real tool count.
@@ -728,6 +739,8 @@ export declare class AgentSession {
     setPlanModeState(state: PlanModeState | undefined): void;
     getGoalModeState(): GoalModeState | undefined;
     setGoalModeState(state: GoalModeState | undefined): void;
+    getVibeModeState(): VibeModeState | undefined;
+    setVibeModeState(state: VibeModeState | undefined): void;
     get goalRuntime(): GoalRuntime;
     markPlanReferenceSent(): void;
     setPlanReferencePath(path: string): void;
@@ -746,6 +759,9 @@ export declare class AgentSession {
     sendGoalModeContext(options?: {
         deliverAs?: "steer" | "followUp" | "nextTurn";
     }): Promise<void>;
+    sendVibeModeContext(options?: {
+        deliverAs?: "steer" | "followUp" | "nextTurn";
+    }): Promise<void>;
     resolveRoleModel(role: string): Model | undefined;
     /**
      * Resolve a role to its model AND thinking level.

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

@@ -208,6 +208,37 @@ export declare function finalizeSubagentLifecycle(args: {
     agentIdleTtlMs: number;
     reviveSession: (() => Promise<AgentSession>) | null;
 }): Promise<void>;
+/** Options for {@link runSubagentFollowUpTurn}. */
+export interface FollowUpTurnOptions {
+    /** Registry id of the (live or parked) subagent to continue. */
+    id: string;
+    /** Agent definition the session was originally spawned with (drives progress labels + finalize). */
+    agent: AgentDefinition;
+    /** The follow-up message; sent as the turn's user prompt. */
+    message: string;
+    index?: number;
+    description?: string;
+    signal?: AbortSignal;
+    onProgress?: (progress: AgentProgress) => void;
+    eventBus?: EventBus;
+    parentToolCallId?: string;
+    /** When set, the turn's raw output is (re)written to `<artifactsDir>/<id>.md` so `agent://<id>` tracks the latest turn. */
+    artifactsDir?: string;
+    /** Wall-clock cap in ms for this turn; 0 disables. */
+    maxRuntimeMs?: number;
+}
+/**
+ * Continue a previously spawned (keep-alive) subagent with one more monitored
+ * turn: revive it if parked, send `message` as a real prompt, drive it to
+ * `yield`, and finalize a {@link SingleResult} exactly like a first run.
+ *
+ * The session's full conversation history is retained (live session, or JSONL
+ * replay through the lifecycle reviver), so the turn sees all prior context.
+ * Unlike {@link runSubprocess}, the session is NOT torn down afterwards — it
+ * stays adopted by the {@link AgentLifecycleManager} (idle → TTL park →
+ * revive), and an aborted turn only aborts the in-flight turn.
+ */
+export declare function runSubagentFollowUpTurn(options: FollowUpTurnOptions): Promise<SingleResult>;
 /**
  * Run a single agent in-process.
  */

package/dist/types/tools/__tests__/vibe-render.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tools/browser/cmux/cmux-tab.d.ts

@@ -2,6 +2,7 @@ import { JsRuntime } from "../../../eval/js/shared/runtime.js";
 import type { ToolSession } from "../../index.js";
 import { type AriaSnapshotOptions } from "../aria/aria-snapshot.js";
 import { type ReadableFormat } from "../readable.js";
+import { RunOutput } from "../run-output.js";
 import type { Observation, ReadyInfo, RunResultOk, ScreenshotResult, SessionSnapshot } from "../tab-protocol.js";
 import type { CmuxSocketClient } from "./socket-client.js";
 interface ScreenshotOptions {
@@ -17,7 +18,7 @@ interface ObserveOptions {
 }
 interface RunContext {
     session: SessionSnapshot;
-    displays: RunResultOk["displays"];
+    output: RunOutput;
     screenshots: ScreenshotResult[];
     signal: AbortSignal;
     timeoutMs: number;
@@ -142,6 +143,7 @@ declare class CmuxElementHandle {
     click(): Promise<void>;
     type(text: string): Promise<void>;
     fill(value: string): Promise<void>;
+    press(key: string): Promise<void>;
     focus(): Promise<void>;
     hover(): Promise<void>;
     evaluate<TResult, TArgs extends unknown[]>(fn: (element: unknown, ...args: TArgs) => TResult | Promise<TResult>, ...args: TArgs): Promise<TResult>;

package/dist/types/tools/browser/cmux/rpc.d.ts

@@ -62,6 +62,26 @@ export interface CmuxGeometry {
 export declare const GEOMETRY_SCRIPT = "(() => ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, dpr: window.devicePixelRatio||1, scrollX: window.scrollX, scrollY: window.scrollY, scrollWidth: document.documentElement.scrollWidth, scrollHeight: document.documentElement.scrollHeight }))()";
 export declare function cmuxSnapshotToObservation(result: CmuxSnapshotResult, viewport: Observation["viewport"], geometry: CmuxGeometry): Observation;
 export declare function serializeEval(fn: string | ((...args: unknown[]) => unknown), args: unknown[]): string;
+/**
+ * Like {@link serializeEval}, but wraps the expression in a page-side
+ * try/catch envelope so a throwing script surfaces its message + stack
+ * instead of the daemon's opaque `js_error: A JavaScript exception occurred`,
+ * and a Promise return (which the daemon cannot serialize) is flagged
+ * explicitly rather than failing as "unsupported type".
+ *
+ * String scripts run through indirect eval to keep global-scope semantics;
+ * function sources are already expressions and are invoked directly.
+ * `undefined` results come back as `null` (JSON cannot carry `undefined`).
+ * Decode with {@link unwrapEvalEnvelope}.
+ */
+export declare function serializeEvalWithEnvelope(fn: string | ((...args: unknown[]) => unknown), args: unknown[]): string;
+/**
+ * Decode a {@link serializeEvalWithEnvelope} result: rethrow page-side
+ * exceptions as rich {@link ToolError}s, reject unserializable Promise
+ * returns with an actionable message, and pass through values from daemons
+ * that did not run the wrapper.
+ */
+export declare function unwrapEvalEnvelope<TResult>(value: unknown, label: string): TResult;
 export declare function mapWaitUntil(waitUntil: string | undefined): "interactive" | "complete";
 export interface ResolveCmuxKindOptions {
     surface?: string;

package/dist/types/tools/browser/run-output.d.ts

@@ -0,0 +1,25 @@
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import type { JsDisplayOutput } from "../../eval/js/shared/types.js";
+/**
+ * Accumulates a browser run's result entries: explicit `display()` payloads,
+ * screenshot captions/images, and buffered stream text (`console.*`, `print`,
+ * `display()` of strings/primitives — `JsRuntime.displayValue` emits those via
+ * `onText`). Stream text is buffered and flushed as one entry before the next
+ * display/screenshot (and on `finish()`) so it reaches the tool result in
+ * order instead of vanishing into the debug log.
+ */
+export declare class RunOutput {
+    #private;
+    /** Buffer a stream-text chunk; it joins the entries at the next push or on finish(). */
+    pushText(chunk: string): void;
+    /** Append a `display()` payload (image/json/status), flushing buffered text first. */
+    pushDisplay(output: JsDisplayOutput): void;
+    /** Append a pre-built entry (e.g. a screenshot caption/image), flushing buffered text first. */
+    push(entry: TextContent | ImageContent): void;
+    /** Flush any remaining stream text and return the ordered entries. */
+    finish(): Array<TextContent | ImageContent>;
+}
+/** JSON.stringify that never throws (cycles/BigInt → String(value)). */
+export declare function safeJsonStringify(value: unknown): string;
+/** Pass a return value across the run boundary: structured-cloneable as-is, else JSON round-trip, else String. */
+export declare function cloneSafe(value: unknown): unknown;

package/dist/types/tools/browser/tab-worker.d.ts

@@ -37,6 +37,22 @@ interface ScreenshotOptions {
     silent?: boolean;
 }
 export declare function normalizeSelector(selector: string): string;
+/** ElementHandle enriched with the `fill()` the tool docs promise on handles from `tab.id()`/`tab.ref()`/`tab.waitFor()`. */
+export type ActionableHandle = ElementHandle & {
+    fill(value: string): Promise<void>;
+};
+/**
+ * Attach `fill()` to a puppeteer ElementHandle before handing it to user code.
+ * Puppeteer handles expose `type()` but no `fill()`; the semantics mirror the
+ * selector-based `tab.fill()`: focus, clear any existing value, then type.
+ */
+export declare function toActionableHandle(handle: ElementHandle): ActionableHandle;
+/**
+ * Hint appended to a selector op's fail-fast timeout, given the selector's current
+ * match count: a missing element (consent wall, wrong page) reads differently from
+ * a present-but-unactionable one.
+ */
+export declare function formatSelectorMatchHint(count: number): string;
 export interface InflightOp {
     label: string;
     startedAt: number;

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

@@ -62,6 +62,7 @@ export * from "./search-tool-bm25.js";
 export * from "./ssh.js";
 export * from "./todo.js";
 export * from "./tts.js";
+export * from "./vibe.js";
 export * from "./write.js";
 export * from "./yield.js";
 /** Tool type (AgentTool from pi-ai) */

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

@@ -0,0 +1,161 @@
+/**
+ * Vibe mode tools — the director's entire non-read surface.
+ *
+ * Five thin tools over {@link VibeSessionRegistry}: spawn/send/wait/kill/list
+ * persistent worker sessions ("fast"/"good" CLIs). Spawns and sends return
+ * immediately; turn results self-deliver through the async job manager.
+ *
+ * The TUI renderers lean into the "you are driving little CLIs" fiction:
+ * spawn/send draw a mini composer (a message typed into a tiny Claude-Code-like
+ * terminal), and wait/list draw the "TV wall" — one live screen per worker,
+ * stacked, each showing its tool calls and streamed text as it works.
+ */
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
+import type { Theme } from "../modes/theme/theme.js";
+import { type VibeCli, type VibeKillOutcome, type VibeScreenSnapshot, type VibeSendOutcome } from "../vibe/runtime.js";
+import type { Tool, ToolSession } from "./index.js";
+export declare const VIBE_TOOL_NAMES: readonly ["vibe_spawn", "vibe_send", "vibe_wait", "vibe_kill", "vibe_list"];
+declare const vibeSpawnSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    cli: "fast" | "good";
+    name?: string | undefined;
+    prompt: string;
+}, {}>;
+declare const vibeSendSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    session: string;
+    message: string;
+}, {}>;
+declare const vibeWaitSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    sessions?: string[] | undefined;
+    timeout?: number | undefined;
+}, {}>;
+declare const vibeKillSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    session: string;
+}, {}>;
+declare const vibeListSchema: import("arktype/internal/variants/object.ts").ObjectType<object, {}>;
+type VibeOp = "spawn" | "send" | "wait" | "kill" | "list";
+/** Details payload shared by every vibe tool for TUI rendering. */
+export interface VibeToolDetails {
+    op: VibeOp;
+    /** Live TV-wall snapshot of the owner's worker sessions at (or during) the call. */
+    screens: VibeScreenSnapshot[];
+    spawned?: {
+        id: string;
+        cli: VibeCli;
+        jobId: string;
+    };
+    send?: VibeSendOutcome;
+    wait?: {
+        settled: Array<{
+            id: string;
+            jobId: string;
+            status: "completed" | "failed" | "cancelled";
+        }>;
+        stillRunning: string[];
+        timedOut: boolean;
+        /** True on interim progress emissions while the wait is still blocking. */
+        waiting?: boolean;
+    };
+    killed?: VibeKillOutcome;
+}
+export declare class VibeSpawnTool implements AgentTool<typeof vibeSpawnSchema, VibeToolDetails> {
+    private readonly session;
+    readonly name = "vibe_spawn";
+    readonly approval: "exec";
+    readonly label = "Vibe Spawn";
+    readonly summary = "Start a persistent fast/good worker session";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        cli: "fast" | "good";
+        name?: string | undefined;
+        prompt: string;
+    }, {}>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: typeof vibeSpawnSchema.infer): Promise<AgentToolResult<VibeToolDetails>>;
+}
+export declare class VibeSendTool implements AgentTool<typeof vibeSendSchema, VibeToolDetails> {
+    private readonly session;
+    readonly name = "vibe_send";
+    readonly approval: "exec";
+    readonly label = "Vibe Send";
+    readonly summary = "Message a worker session (steer or next turn)";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        session: string;
+        message: string;
+    }, {}>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: typeof vibeSendSchema.infer): Promise<AgentToolResult<VibeToolDetails>>;
+}
+export declare class VibeWaitTool implements AgentTool<typeof vibeWaitSchema, VibeToolDetails> {
+    private readonly session;
+    readonly name = "vibe_wait";
+    readonly approval: "read";
+    readonly label = "Vibe Wait";
+    readonly summary = "Block until a worker session finishes its turn";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        sessions?: string[] | undefined;
+        timeout?: number | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly interruptible = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: typeof vibeWaitSchema.infer, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<VibeToolDetails>): Promise<AgentToolResult<VibeToolDetails>>;
+}
+export declare class VibeKillTool implements AgentTool<typeof vibeKillSchema, VibeToolDetails> {
+    private readonly session;
+    readonly name = "vibe_kill";
+    readonly approval: "read";
+    readonly label = "Vibe Kill";
+    readonly summary = "Terminate a worker session";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        session: string;
+    }, {}>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: typeof vibeKillSchema.infer): Promise<AgentToolResult<VibeToolDetails>>;
+}
+export declare class VibeListTool implements AgentTool<typeof vibeListSchema, VibeToolDetails> {
+    private readonly session;
+    readonly name = "vibe_list";
+    readonly approval: "read";
+    readonly label = "Vibe List";
+    readonly summary = "List worker sessions and their states";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<object, {}>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(): Promise<AgentToolResult<VibeToolDetails>>;
+}
+/** Creates the ephemeral tools installed while `/vibe` mode is active. */
+export declare function createVibeTools(session: ToolSession): Tool[];
+interface VibeRenderArgs {
+    cli?: VibeCli;
+    prompt?: string;
+    name?: string;
+    session?: string;
+    message?: string;
+    sessions?: string[];
+}
+/** Build the shared vibe renderer for one tool name. */
+export declare function createVibeToolRenderer(op: VibeOp): {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    animatedPendingPreview: boolean;
+    animatedPartialResult: boolean;
+    renderCall(args: VibeRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: VibeToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: VibeRenderArgs): Component;
+};
+export {};

package/dist/types/utils/changelog.d.ts

@@ -4,6 +4,24 @@ export interface ChangelogEntry {
     patch: number;
     content: string;
 }
+/** Number of changelog releases shown by automatic and default recent views. */
+export declare const RECENT_CHANGELOG_ENTRY_LIMIT = 3;
+/** Maximum Markdown source bytes allowed in automatic startup release notes. */
+export declare const STARTUP_CHANGELOG_MAX_BYTES: number;
+/** Hint appended when automatic startup release notes are truncated. */
+export declare const STARTUP_CHANGELOG_FULL_HINT = "Use `/changelog full` to view the complete changelog.";
+/** Markdown generated from selected changelog entries and whether it hit a size cap. */
+export interface RenderedChangelog {
+    markdown: string;
+    truncated: boolean;
+}
+/** Automatic startup changelog decision, including whether the marker should advance. */
+export interface StartupChangelogSelection {
+    markdown: string | undefined;
+    persistCurrentVersion: boolean;
+    truncated: boolean;
+    selectedEntries: number;
+}
 /**
  * Parse changelog entries from the file at `changelogPath`. Scans for `## [x.y.z]`
  * headings and collects each block until the next heading or EOF.
@@ -19,9 +37,25 @@ export declare function parseChangelog(changelogPath: string | undefined): Promi
  */
 export declare function compareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number;
 /**
- * Get entries newer than lastVersion
+ * Parse an omp changelog marker version into comparable parts.
+ */
+export declare function parseChangelogVersion(version: string | undefined): ChangelogEntry | undefined;
+/**
+ * Get entries newer than lastVersion.
  */
 export declare function getNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[];
+/**
+ * Render changelog entries oldest-first by default and optionally cap the Markdown source size.
+ */
+export declare function renderChangelogEntries(entries: ChangelogEntry[], options?: {
+    maxBytes?: number;
+    truncationHint?: string;
+    oldestFirst?: boolean;
+}): RenderedChangelog;
+/**
+ * Select bounded release notes for interactive startup.
+ */
+export declare function selectStartupChangelog(entries: ChangelogEntry[], lastVersion: string | undefined, currentVersion: string): StartupChangelogSelection;
 export { getChangelogPath } from "../config.js";
 /**
  * Last omp version whose changelog the user has seen. Stored as a plain-text