@gajae-code/coding-agent 0.4.2 → 0.4.4

package/dist/types/modes/shared/agent-wire/event-contract.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Canonical agent-wire contract: the single transport-neutral source of truth
+ * for AgentSession events and bounded owner observations.
+ *
+ * Two distinct consumer-facing shapes, deliberately NOT collapsed into one:
+ * - `AgentWireEventPayload`: rich, full `AgentSessionEvent` for renderers
+ *   (ACP SDK notifications, RPC/Bridge event frames).
+ * - `AgentWireOwnerObservation`: bounded/redacted owner evidence for control
+ *   planes (Harness). Never carries assistant text, message deltas, raw tool
+ *   args, raw command output, raw tool results, answers, or oversize strings.
+ *
+ * The exhaustive `AGENT_SESSION_EVENT_TYPE_REGISTRY` lives here so that adding
+ * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
+ * conformance tests can assert fixture coverage equals the registry exactly.
+ */
+import type { AgentSessionEvent } from "../../../session/agent-session";
+/** Wire protocol version. Bump on breaking envelope/semantic changes. */
+export declare const AGENT_WIRE_PROTOCOL_VERSION: 2;
+export type AgentWireProtocolVersion = typeof AGENT_WIRE_PROTOCOL_VERSION;
+/** The discriminant of every `AgentSessionEvent` the agent can emit. */
+export type AgentWireEventType = AgentSessionEvent["type"];
+/** Every agent-session event type, derived from the exhaustive registry. */
+export declare const AGENT_WIRE_EVENT_TYPES: readonly AgentWireEventType[];
+/**
+ * Rich event payload. Carries the full `AgentSessionEvent` so renderers (ACP,
+ * RPC, Bridge) can present message content, tool args/results, todo state, etc.
+ */
+export interface AgentWireEventPayload {
+    event_type: AgentWireEventType;
+    event: AgentSessionEvent;
+}
+/**
+ * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
+ * the Harness `ObservedSignal` set; the Harness type aliases this in a later
+ * step so there is a single source of truth.
+ */
+export type AgentWireObservedSignal = "SessionStart" | "prompt-accepted" | "tool-call" | "test-running" | "commit-created" | "completed" | "error" | "streaming" | "idle";
+export type AgentWireSeverity = "info" | "warn" | "critical";
+/**
+ * Bounded, redacted owner observation. Evidence may include ids, names,
+ * categories, statuses, cursors, timestamps, short codes, and bounded short
+ * messages ONLY. It must never carry assistant text, message deltas, raw tool
+ * args, raw command output, raw tool result content, answers, or oversize
+ * strings.
+ */
+export interface AgentWireOwnerObservation {
+    /** Set when this observation derives from an `AgentSessionEvent`. */
+    eventType?: AgentWireEventType;
+    /** Set when this observation derives from a non-event wire frame. */
+    frameType?: string;
+    /** Owner event kind (e.g. `rpc_tool_started`). */
+    kind: string;
+    /** Bounded observed signal, or null when the frame carries no signal. */
+    signal: AgentWireObservedSignal | null;
+    /** Bounded evidence — ids/names/statuses/cursors/timestamps/short codes only. */
+    evidence: Record<string, unknown>;
+    /** Severity for the emitted event. */
+    severity: AgentWireSeverity;
+    /** Never-drop observations: must be enqueued in order, never coalesced away. */
+    semantic: boolean;
+    /** Coalescing key for high-frequency non-semantic frames; null otherwise. */
+    coalesceKey: string | null;
+}
+/** Top-level frame categories carried over any agent-wire transport. */
+export type AgentWireFrameType = "ready" | "event" | "response" | "ui_request" | "permission_request" | "host_tool_call" | "host_uri_request" | "reset" | "workflow_gate" | "error";
+/**
+ * Universal frame envelope. Every frame on every transport carries these
+ * fields so clients can order (`seq`), resume (`seq` cursor), and correlate
+ * request/response pairs (`correlation_id`).
+ */
+export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = AgentWireFrameType, TPayload = unknown> {
+    protocol_version: AgentWireProtocolVersion;
+    session_id: string;
+    /** Monotonic per-session sequence number, starting at 1. */
+    seq: number;
+    /** Unique id for this frame. */
+    frame_id: string;
+    /** Ties a request frame to its response frame, when applicable. */
+    correlation_id?: string;
+    type: TType;
+    payload: TPayload;
+}
+/** An `AgentSessionEvent` serialized into a versioned wire frame. */
+export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;

package/dist/types/modes/shared/agent-wire/event-envelope.d.ts

@@ -1,16 +1,16 @@
 import type { AgentSessionEvent } from "../../../session/agent-session";
-import { type AgentSessionEventType, type BridgeEventFrame, type BridgeFrameEnvelope, type BridgeFrameType } from "./protocol";
+import { type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
 /**
  * Resolve the stable wire event-type for an `AgentSessionEvent`.
  *
  * Exhaustive over the union; adding a variant without a case is a type error.
  */
-export declare function agentSessionEventType(event: AgentSessionEvent): AgentSessionEventType;
+export declare function agentSessionEventType(event: AgentSessionEvent): AgentWireEventType;
 /**
  * Per-session monotonic frame builder. One instance per active session; `seq`
  * starts at 1 and increments per frame so clients can order and resume.
  */
-export declare class BridgeFrameSequencer {
+export declare class AgentWireFrameSequencer {
     #private;
     constructor(sessionId: string);
     /** The session id stamped onto every frame this sequencer produces. */
@@ -18,14 +18,21 @@ export declare class BridgeFrameSequencer {
     /** The seq assigned to the most recently produced frame (0 before any). */
     get lastSeq(): number;
     /** Build the next envelope of the given type with a fresh seq + frame id. */
-    next<TType extends BridgeFrameType, TPayload>(type: TType, payload: TPayload, correlationId?: string): BridgeFrameEnvelope<TType, TPayload>;
+    next<TType extends AgentWireFrameType, TPayload>(type: TType, payload: TPayload, correlationId?: string): AgentWireFrameEnvelope<TType, TPayload>;
 }
-/** Serialize a single `AgentSessionEvent` into an `event` wire frame. */
-export declare function toBridgeEventFrame(event: AgentSessionEvent, sequencer: BridgeFrameSequencer): BridgeEventFrame;
+/** Back-compat alias for {@link AgentWireFrameSequencer}. */
+export declare const BridgeFrameSequencer: typeof AgentWireFrameSequencer;
+export type BridgeFrameSequencer = AgentWireFrameSequencer;
+/** Serialize a single `AgentSessionEvent` into a canonical `event` wire frame. */
+export declare function toAgentWireEventFrame(event: AgentSessionEvent, sequencer: AgentWireFrameSequencer): AgentWireEventFrame;
+/** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
+export declare function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload;
+/** Back-compat alias for {@link toAgentWireEventFrame}. */
+export declare const toBridgeEventFrame: typeof toAgentWireEventFrame;
 /**
  * Serialize a `workflow_gate` event into a sequenced wire frame (#321). The
  * gate_id is stamped as the correlation id so the answer (posted to the
  * ui-responses endpoint) can be matched, and the monotonic `seq` gives replay
  * while `frame_id` + gate_id give idempotency.
  */
-export declare function toBridgeWorkflowGateFrame(gate: import("../../rpc/rpc-types").RpcWorkflowGate, sequencer: BridgeFrameSequencer): import("./protocol").BridgeWorkflowGateFrame;
+export declare function toBridgeWorkflowGateFrame(gate: import("../../rpc/rpc-types").RpcWorkflowGate, sequencer: AgentWireFrameSequencer): import("./protocol").BridgeWorkflowGateFrame;

package/dist/types/modes/shared/agent-wire/event-observation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Canonical AgentSession event observation: the single semantic mapping from
+ * `AgentSessionEvent` (and non-event wire frames) to bounded owner observations.
+ *
+ * This is the one place that derives `AgentWireOwnerObservation`s. Harness (and
+ * any other owner control plane) consumes these instead of re-parsing the wire
+ * protocol with private knowledge.
+ *
+ * Hard rule: evidence is BOUNDED — only ids, names, categories, statuses,
+ * cursors, timestamps, and short codes/messages. Never assistant text, message
+ * deltas, command output, raw args, or raw tool results.
+ */
+import type { AgentSessionEvent } from "../../../session/agent-session";
+import type { AgentWireEventPayload, AgentWireOwnerObservation } from "./event-contract";
+import { toAgentWireEventPayload } from "./event-envelope";
+/** True when a tool name or command indicates a test-runner invocation. */
+export declare function isTestRunnerTool(toolName?: unknown, command?: unknown): boolean;
+/** Only accept a known closed-vocabulary tool status; reject arbitrary strings. */
+export declare function boundedStatus(v: unknown): string | undefined;
+/** Accept only identifier-shaped tokens (e.g. RPC command names); reject free text. */
+export declare function boundedToken(v: unknown): string | undefined;
+/**
+ * Map a single `AgentSessionEvent` to its bounded owner observation, or null
+ * when the event carries no owner-facing signal.
+ */
+export declare function observeAgentSessionEvent(event: AgentSessionEvent): AgentWireOwnerObservation | null;
+/** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
+export { toAgentWireEventPayload };
+/** Observe the bounded owner signal carried by a rich event payload. */
+export declare function observeAgentWireEventPayload(payload: AgentWireEventPayload): AgentWireOwnerObservation | null;
+/**
+ * Map a single outbound RPC wire frame (docs/rpc.md) to a bounded owner
+ * observation, or null when the frame carries no owner-facing signal. Event
+ * frames delegate to {@link observeAgentWireEventPayload}; non-event frames are
+ * mapped here so owners never re-parse protocol semantics privately.
+ */
+export declare function observeRpcOutboundFrame(frame: Record<string, unknown>): AgentWireOwnerObservation | null;

package/dist/types/modes/shared/agent-wire/protocol.d.ts

@@ -1,46 +1,25 @@
 /**
  * Shared agent-wire protocol primitives for GJC bridge surfaces.
  *
- * This module is the transport-agnostic, versioned frame contract that the
- * RPC mode and the (in-progress) `--mode bridge` wiring site both build on.
- * It carries the SEMANTIC agent surface — events, responses, and UI/permission
- * requests — never pixels. See `.gjc/specs/deep-interview-gjc-backend-bridge.md`
- * and `.gjc/plans/ralplan/gjc-backend-bridge/pending-approval.md`.
+ * The canonical event/frame contract now lives in `event-contract.ts`. This
+ * module re-exports it under the historical `Bridge*` names so existing RPC and
+ * Bridge code keeps compiling while the adapters migrate to the canonical
+ * `AgentWire*` names. See `.gjc/specs/deep-interview-reconcile-rpc-adapters.md`.
  */
-import type { AgentSessionEvent } from "../../../session/agent-session";
+import type { AgentWireEventFrame, AgentWireEventPayload, AgentWireEventType, AgentWireFrameEnvelope, AgentWireFrameType } from "./event-contract";
 /** Wire protocol version. Bump on breaking envelope/semantic changes. */
-export declare const BRIDGE_PROTOCOL_VERSION: 1;
+export declare const BRIDGE_PROTOCOL_VERSION: 2;
 /** The discriminant of every `AgentSessionEvent` the agent can emit. */
-export type AgentSessionEventType = AgentSessionEvent["type"];
+export type AgentSessionEventType = AgentWireEventType;
 /** Every agent-session event type, derived from the exhaustive registry. */
 export declare const AGENT_SESSION_EVENT_TYPES: readonly AgentSessionEventType[];
 /** Top-level frame categories carried over any bridge transport. */
-export type BridgeFrameType = "ready" | "event" | "response" | "ui_request" | "permission_request" | "host_tool_call" | "host_uri_request" | "reset" | "workflow_gate" | "error";
-/**
- * Universal frame envelope. Every frame on every transport carries these
- * fields so clients can order (`seq`), resume (`seq` cursor), and correlate
- * request/response pairs (`correlation_id`). `session_id` is present from v1
- * even though v1 runs one session per process, so in-process multiplexing is
- * an additive, non-breaking change later.
- */
-export interface BridgeFrameEnvelope<TType extends BridgeFrameType = BridgeFrameType, TPayload = unknown> {
-    protocol_version: typeof BRIDGE_PROTOCOL_VERSION;
-    session_id: string;
-    /** Monotonic per-session sequence number, starting at 1. */
-    seq: number;
-    /** Unique id for this frame. */
-    frame_id: string;
-    /** Ties a request frame to its response frame, when applicable. */
-    correlation_id?: string;
-    type: TType;
-    payload: TPayload;
-}
-/** Payload carried by an `event` frame. */
-export interface BridgeEventPayload {
-    event_type: AgentSessionEventType;
-    event: AgentSessionEvent;
-}
+export type BridgeFrameType = AgentWireFrameType;
+/** Universal frame envelope. See {@link AgentWireFrameEnvelope}. */
+export type BridgeFrameEnvelope<TType extends BridgeFrameType = BridgeFrameType, TPayload = unknown> = AgentWireFrameEnvelope<TType, TPayload>;
+/** Payload carried by an `event` frame. See {@link AgentWireEventPayload}. */
+export type BridgeEventPayload = AgentWireEventPayload;
 /** An `AgentSessionEvent` serialized into a versioned wire frame. */
-export type BridgeEventFrame = BridgeFrameEnvelope<"event", BridgeEventPayload>;
+export type BridgeEventFrame = AgentWireEventFrame;
 /** A `workflow_gate` event serialized into a versioned wire frame (#321). */
 export type BridgeWorkflowGateFrame = BridgeFrameEnvelope<"workflow_gate", import("../../rpc/rpc-types").RpcWorkflowGate>;

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

@@ -25,6 +25,14 @@ export interface ForkContextSeedMetadata {
     maxTokens: number;
     skippedReasons: Record<string, number>;
 }
+export interface PurgeQueuedCustomMessagesResult {
+    agentSteering: number;
+    agentFollowUp: number;
+    pendingNextTurn: number;
+    displaySteering: number;
+    displayFollowUp: number;
+    totalExecutable: number;
+}
 export interface ForkContextSeed {
     messages: Message[];
     agentMessages: AgentMessage[];
@@ -568,6 +576,7 @@ export declare class AgentSession {
      */
     followUp(text: string, images?: ImageContent[]): Promise<void>;
     queueDeferredMessage(message: CustomMessage): void;
+    queueDeferredMessageForTests(message: CustomMessage, triggerTurn?: boolean): void;
     /**
      * Send a custom message to the session. Creates a CustomMessageEntry.
      *
@@ -580,6 +589,8 @@ export declare class AgentSession {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
     }): Promise<void>;
+    /** Remove undelivered queued custom messages matching `predicate` from executable queues and tagged display mirrors. */
+    purgeQueuedCustomMessages(predicate: (message: CustomMessage) => boolean): PurgeQueuedCustomMessagesResult;
     /**
      * Send a user message to the agent.
      * When deliverAs is set, queue the message instead of starting a new turn.
@@ -683,7 +694,7 @@ export declare class AgentSession {
     /**
      * Cycle through configured role models in a fixed order.
      * Skips missing roles.
-     * @param roleOrder - Order of roles to cycle through (e.g., ["slow", "default", "smol"])
+     * @param roleOrder - Order of roles to cycle through (e.g., ["default"])
      * @param options - Optional settings: `temporary` to not persist to settings
      */
     cycleRoleModels(roleOrder: readonly string[], options?: {

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

@@ -38,7 +38,7 @@ export interface ModelChangeEntry extends SessionEntryBase {
     type: "model_change";
     /** Model in "provider/modelId" format */
     model: string;
-    /** Role: "default", "smol", "slow", etc. Undefined treated as "default" */
+    /** Role: "default" or an agent role. Undefined treated as "default" */
     role?: string;
 }
 export interface ServiceTierChangeEntry extends SessionEntryBase {

package/dist/types/setup/hermes-setup.d.ts

@@ -0,0 +1,71 @@
+import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME } from "../coordinator/contract";
+export type HermesMutationClass = "sessions" | "questions" | "reports";
+export type HermesSetupMode = "render" | "install" | "check" | "smoke";
+export interface HermesSetupFlags {
+    json?: boolean;
+    check?: boolean;
+    smoke?: boolean;
+    install?: boolean;
+    force?: boolean;
+    root?: string[];
+    repo?: string;
+    profile?: string;
+    sessionCommand?: string;
+    stateRoot?: string;
+    mutation?: string[];
+    artifactByteCap?: string;
+    serverKey?: string;
+    gjcCommand?: string;
+    target?: string;
+    profileDir?: string;
+}
+export interface CoordinatorSetupSpec {
+    schemaVersion: 1;
+    coordinator: "hermes";
+    serverKey: string;
+    serverName: typeof COORDINATOR_MCP_SERVER_NAME;
+    protocolVersion: typeof COORDINATOR_MCP_PROTOCOL_VERSION;
+    gjcCommand: string;
+    args: ["mcp-serve", "coordinator"];
+    roots: string[];
+    namespace: {
+        profile?: string;
+        repo?: string;
+    };
+    sessionCommand?: string;
+    stateRoot?: string;
+    mutationPolicy: {
+        classes: HermesMutationClass[];
+        perCallConsentRequired: true;
+    };
+    artifactByteCap?: number;
+    installTarget?: {
+        kind: "profile-dir" | "config-file";
+        path: string;
+    };
+    operatorTemplateVersion: 1;
+    contractDocVersion: 1;
+}
+export interface HermesSetupResult {
+    ok: boolean;
+    mode: HermesSetupMode;
+    files_written: string[];
+    previews: Array<{
+        path: string;
+        content: string;
+    }>;
+    warnings: string[];
+    smoke: null | {
+        ok: boolean;
+        protocolVersion: string;
+        serverName: string;
+        requiredTools: string[];
+        missingTools: string[];
+    };
+}
+export declare function buildHermesSetupSpec(flags: HermesSetupFlags): CoordinatorSetupSpec;
+export declare function computeHermesSetupSignature(spec: CoordinatorSetupSpec): string;
+export declare function renderHermesServerBlock(spec: CoordinatorSetupSpec): Record<string, unknown>;
+export declare function runHermesSetup(flags: HermesSetupFlags): Promise<HermesSetupResult>;
+export declare function formatHermesSetupResult(result: HermesSetupResult): string;
+export declare function hermesSetupExitCode(error: unknown): number;

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

@@ -1,11 +1,17 @@
 import type { Component } from "@gajae-code/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import type { TaskParams, TaskToolDetails } from "./types";
+import type { AgentProgress, TaskParams, TaskToolDetails } from "./types";
 /**
  * Render the tool call arguments.
  */
 export declare function renderCall(args: TaskParams, _options: RenderResultOptions, theme: Theme): Component;
+/**
+ * Public wrapper to render a single subagent's live `AgentProgress` for the
+ * `subagent` await panel. Reuses the internal task-progress renderer so the
+ * await panel stays at parity with the inline task panel.
+ */
+export declare function renderSubagentLiveProgress(progress: AgentProgress, expanded: boolean, theme: Theme, spinnerFrame?: number): string[];
 /**
  * Render the tool result.
  */

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

@@ -78,6 +78,8 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
         label?: string;
         ctx?: AgentToolContext;
         onRawLine?: (line: string, jobId: string) => void;
+        shouldAcceptRawLine?: (jobId: string) => boolean;
+        lifecycle?: import("../async").AsyncJobLifecycleCleanup;
     }): Promise<{
         jobId: string;
         label: string;

package/dist/types/tools/browser/actions.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Structured browser action space.
+ *
+ * Adapts the SOTA computer-use / browser-use pattern: instead of authoring raw
+ * JavaScript for every interaction, the model emits a list of structured verbs
+ * (navigate / click / type / …) that reference elements by the numeric `id`
+ * returned from {@link Observation}. Each verb is compiled onto the existing
+ * in-tab `tab.*` helpers and executed through the same worker `run` path, so the
+ * worker protocol is unchanged and the raw-JS `run` escape hatch still works.
+ */
+export type BrowserActionVerb = "navigate" | "click" | "type" | "fill" | "select" | "press" | "scroll" | "back" | "wait" | "observe" | "extract" | "screenshot";
+export interface BrowserActionStep {
+    verb: BrowserActionVerb;
+    /** Element id from a prior `observe` (preferred for click/type). */
+    id?: number;
+    /** CSS / puppeteer selector when not addressing by `id`. */
+    selector?: string;
+    /** Text to type. */
+    text?: string;
+    /** Value for `fill`. */
+    value?: string;
+    /** Option value(s) for `select`. */
+    values?: string[];
+    /** URL for `navigate`. */
+    url?: string;
+    /** Key for `press` (e.g. "Enter"). */
+    key?: string;
+    /** Horizontal scroll delta. */
+    dx?: number;
+    /** Vertical scroll delta. */
+    dy?: number;
+    /** Sleep duration for `wait` when no selector is given. */
+    ms?: number;
+    /** Extract format. */
+    format?: "markdown" | "text" | "html";
+    /** Navigation wait condition for `navigate`. */
+    wait_until?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
+    /** Only return interactive/viewport elements for `observe`. */
+    viewport_only?: boolean;
+    include_all?: boolean;
+}
+/**
+ * Validate a single step's required fields. Returns an error string, or
+ * `undefined` when the step is well-formed.
+ */
+export declare function validateActionStep(step: BrowserActionStep, index: number): string | undefined;
+/** Validate the full step list. Throws on the first invalid step. */
+export declare function validateActionSteps(steps: readonly BrowserActionStep[]): void;
+/**
+ * Compile structured steps into a JS program for the in-tab `run` worker. Steps
+ * are embedded as parsed JSON (no string interpolation, so values cannot inject
+ * code) and dispatched by a fixed interpreter against the `tab` / `page` helpers.
+ */
+export declare function compileActionSteps(steps: readonly BrowserActionStep[]): string;

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

@@ -8,6 +8,7 @@ export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } fro
 export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 declare const browserSchema: z.ZodObject<{
     action: z.ZodEnum<{
+        act: "act";
         close: "close";
         open: "open";
         run: "run";
@@ -36,6 +37,45 @@ declare const browserSchema: z.ZodObject<{
         dismiss: "dismiss";
     }>>;
     code: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        verb: z.ZodEnum<{
+            back: "back";
+            click: "click";
+            extract: "extract";
+            fill: "fill";
+            navigate: "navigate";
+            observe: "observe";
+            press: "press";
+            screenshot: "screenshot";
+            scroll: "scroll";
+            select: "select";
+            type: "type";
+            wait: "wait";
+        }>;
+        id: z.ZodOptional<z.ZodNumber>;
+        selector: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodString>;
+        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        url: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        dx: z.ZodOptional<z.ZodNumber>;
+        dy: z.ZodOptional<z.ZodNumber>;
+        ms: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodEnum<{
+            html: "html";
+            markdown: "markdown";
+            text: "text";
+        }>>;
+        wait_until: z.ZodOptional<z.ZodEnum<{
+            domcontentloaded: "domcontentloaded";
+            load: "load";
+            networkidle0: "networkidle0";
+            networkidle2: "networkidle2";
+        }>>;
+        viewport_only: z.ZodOptional<z.ZodBoolean>;
+        include_all: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
     timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     all: z.ZodOptional<z.ZodBoolean>;
     kill: z.ZodOptional<z.ZodBoolean>;
@@ -73,6 +113,7 @@ export declare class BrowserTool implements AgentTool<typeof browserSchema, Brow
     readonly summary = "Control a headless browser to navigate and interact with web pages";
     readonly parameters: z.ZodObject<{
         action: z.ZodEnum<{
+            act: "act";
             close: "close";
             open: "open";
             run: "run";
@@ -101,6 +142,45 @@ export declare class BrowserTool implements AgentTool<typeof browserSchema, Brow
             dismiss: "dismiss";
         }>>;
         code: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            verb: z.ZodEnum<{
+                back: "back";
+                click: "click";
+                extract: "extract";
+                fill: "fill";
+                navigate: "navigate";
+                observe: "observe";
+                press: "press";
+                screenshot: "screenshot";
+                scroll: "scroll";
+                select: "select";
+                type: "type";
+                wait: "wait";
+            }>;
+            id: z.ZodOptional<z.ZodNumber>;
+            selector: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodString>;
+            values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            url: z.ZodOptional<z.ZodString>;
+            key: z.ZodOptional<z.ZodString>;
+            dx: z.ZodOptional<z.ZodNumber>;
+            dy: z.ZodOptional<z.ZodNumber>;
+            ms: z.ZodOptional<z.ZodNumber>;
+            format: z.ZodOptional<z.ZodEnum<{
+                html: "html";
+                markdown: "markdown";
+                text: "text";
+            }>>;
+            wait_until: z.ZodOptional<z.ZodEnum<{
+                domcontentloaded: "domcontentloaded";
+                load: "load";
+                networkidle0: "networkidle0";
+                networkidle2: "networkidle2";
+            }>>;
+            viewport_only: z.ZodOptional<z.ZodBoolean>;
+            include_all: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
         timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         all: z.ZodOptional<z.ZodBoolean>;
         kill: z.ZodOptional<z.ZodBoolean>;

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

@@ -72,6 +72,7 @@ interface InlineImageData {
 }
 /** Set the preferred image provider from settings */
 export declare function setPreferredImageProvider(provider: ImageProvider | "auto"): void;
+export declare function isOpenAIHostedImageModel(model: Model | undefined): model is Model;
 export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;
 export declare function getImageGenTools(modelRegistry?: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
 export declare function getImageGenToolsWithRegistry(modelRegistry: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;

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

@@ -8,7 +8,7 @@ import type { HindsightSessionState } from "../hindsight/state";
 import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
 import type { PlanModeState } from "../plan-mode/state";
 import type { AgentRegistry } from "../registry/agent-registry";
-import type { ForkContextSeed, ForkContextSeedOptions } from "../session/agent-session";
+import type { ForkContextSeed, ForkContextSeedOptions, PurgeQueuedCustomMessagesResult } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { ClientBridge } from "../session/client-bridge";
 import type { CustomMessage } from "../session/messages";
@@ -117,6 +117,8 @@ export interface ToolSession {
     /** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
     getAgentId?: () => string | null;
     /** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+    /** Purge undelivered queued custom messages matching the predicate. Returns counts. */
+    purgeQueuedCustomMessages?: (predicate: (message: CustomMessage) => boolean) => PurgeQueuedCustomMessagesResult;
     getToolByName?: (name: string) => AgentTool | undefined;
     /** Agent registry for IRC routing across live sessions. */
     agentRegistry?: AgentRegistry;

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

@@ -19,7 +19,7 @@ interface JobSnapshot {
     resultText?: string;
     errorText?: string;
 }
-type CancelStatus = "cancelled" | "not_found" | "already_completed";
+type CancelStatus = "cancelled" | "not_found" | "already_completed" | "already_cancelled";
 export interface JobToolDetails {
     jobs: JobSnapshot[];
     cancelled?: {

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

@@ -0,0 +1,25 @@
+/**
+ * TUI renderer for the `subagent` tool.
+ *
+ * The await panel surfaces each awaited subagent's live streaming status at
+ * parity with the inline `task` panel by reusing `renderSubagentLiveProgress`.
+ * Falls back to a `running, no activity yet` placeholder when a live producer
+ * exists but has not emitted yet, and to a static status line when no live
+ * producer is available (resumed-from-disk or backward-compat records).
+ */
+import type { Component } from "@gajae-code/tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { SubagentToolDetails } from "./subagent";
+export declare const subagentToolRenderer: {
+    inline: boolean;
+    renderCall(_args: unknown, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SubagentToolDetails;
+    }, options: RenderResultOptions, theme: Theme): Component;
+    mergeCallAndResult: boolean;
+};

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import * as z from "zod/v4";
-import type { AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource } from "../task/types";
 import type { ToolSession } from "./index";
 declare const subagentSchema: z.ZodObject<{
     action: z.ZodEnum<{
@@ -42,6 +42,10 @@ export interface SubagentSnapshot {
     outputRef?: string;
     truncated?: boolean;
     guidance?: string;
+    /** Live streaming progress for the awaited subagent (await panel only; UI detail). */
+    progress?: AgentProgress;
+    /** True when a live in-session progress producer exists for this subagent. */
+    liveProgressAvailable?: boolean;
 }
 export interface SubagentToolDetails {
     subagents: SubagentSnapshot[];