@gajae-code/coding-agent 0.2.5 → 0.3.1

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -1,5 +1,6 @@
 import type { Component } from "@gajae-code/tui";
 import type { InteractiveModeContext } from "../../modes/types";
+import type { JobsObserver } from "../jobs-observer";
 import type { SessionObserverRegistry } from "../session-observer-registry";
 export declare class SelectorController {
     #private;
@@ -44,4 +45,11 @@ export declare class SelectorController {
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
     showDebugSelector(): void;
     showSessionObserver(registry: SessionObserverRegistry): void;
+    /**
+     * Jobs overlay: navigate ongoing monitor + cron jobs (Monitors then Crons,
+     * newest-first), drill into per-type detail, and cancel/delete with a y/N
+     * confirm. Built from nested SelectLists (list -> detail -> confirm) so focus
+     * stays on the active SelectList.
+     */
+    showJobsOverlay(observer: JobsObserver): void;
 }

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

@@ -2,6 +2,7 @@
  * Run modes for the coding agent.
  */
 export { runAcpMode } from "./acp";
+export { runBridgeMode } from "./bridge/bridge-mode";
 export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
 export { type PrintModeOptions, runPrintMode } from "./print-mode";
 export { defineRpcClientTool, type ModelInfo, RpcClient, type RpcClientCustomTool, type RpcClientOptions, type RpcClientToolContext, type RpcClientToolResult, type RpcEventListener, } from "./rpc/rpc-client";

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

@@ -86,6 +86,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     retryLoader: Loader | undefined;
     autoCompactionEscapeHandler?: () => void;
     retryEscapeHandler?: () => void;
+    retryCountdownTimer?: ReturnType<typeof setInterval>;
     unsubscribe?: () => void;
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;
@@ -190,6 +191,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleSTTToggle(): Promise<void>;
     showDebugSelector(): void;
     showSessionObserver(): void;
+    showJobsOverlay(): void;
     resetObserverRegistry(): void;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;

package/dist/types/modes/jobs-observer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * JobsObserver
+ *
+ * Single, event-driven aggregator over the two background-work sources surfaced
+ * by the status-line jobs widget and the jobs overlay:
+ *  - monitor jobs (bash jobs started by the `monitor` tool, tracked in `AsyncJobManager`)
+ *  - cron jobs (tracked in the cron module's owner-scoped schedule store)
+ *
+ * It subscribes to change hooks on both sources (no polling), debounces bursts
+ * to a microtask, and exposes a precomputed snapshot so the status-line render
+ * loop never scans the underlying stores. A failure latch keeps the widget red
+ * until `acknowledgeFailures()` is called (when the overlay opens), so a failed
+ * job that evicts before the user looks is not silently lost.
+ */
+import type { AsyncJob, AsyncJobManager } from "../async";
+export type JobsWorstState = "none" | "running" | "failed";
+export interface MonitorJobView {
+    id: string;
+    label: string;
+    status: AsyncJob["status"];
+    startTime: number;
+}
+export interface CronJobView {
+    id: string;
+    humanSchedule: string;
+    cronExpression: string;
+    prompt: string;
+    recurring: boolean;
+    nextFireAt?: number;
+    createdAt: number;
+}
+export interface JobsSnapshot {
+    monitors: MonitorJobView[];
+    crons: CronJobView[];
+    activeMonitorCount: number;
+    activeCronCount: number;
+    worstState: JobsWorstState;
+    failedUnacknowledged: boolean;
+}
+export declare const EMPTY_JOBS_SNAPSHOT: JobsSnapshot;
+export declare class JobsObserver {
+    #private;
+    constructor(manager: AsyncJobManager, ownerId: string | undefined);
+    /** Subscribe to debounced change events. Returns an unsubscribe function. */
+    onChange(cb: () => void): () => void;
+    /** Return the precomputed snapshot (recomputed on each upstream change). */
+    getSnapshot(): JobsSnapshot;
+    /** Clear the failure latch (called when the user opens the jobs overlay). */
+    acknowledgeFailures(): void;
+    /** Cancel a running monitor job. Returns true when the job was cancelled. */
+    cancelMonitor(id: string): boolean;
+    /** Delete a visible scheduled cron job. Returns true when removed. */
+    deleteCron(id: string): boolean;
+    /** Bounded tail of a monitor job's captured output (for the detail view). */
+    getMonitorOutput(id: string): string;
+    dispose(): void;
+}

package/dist/types/modes/rpc/host-tools.d.ts

@@ -1,16 +1 @@
-import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
-import type { RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostToolDefinition, RpcHostToolResult, RpcHostToolUpdate } from "./rpc-types";
-type RpcHostToolOutput = (frame: RpcHostToolCallRequest | RpcHostToolCancelRequest) => void;
-export declare function isRpcHostToolResult(value: unknown): value is RpcHostToolResult;
-export declare function isRpcHostToolUpdate(value: unknown): value is RpcHostToolUpdate;
-export declare class RpcHostToolBridge {
-    #private;
-    constructor(output: RpcHostToolOutput);
-    getToolNames(): string[];
-    setTools(tools: RpcHostToolDefinition[]): AgentTool[];
-    handleResult(frame: RpcHostToolResult): boolean;
-    handleUpdate(frame: RpcHostToolUpdate): boolean;
-    requestExecution(definition: RpcHostToolDefinition, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<unknown>): Promise<AgentToolResult<unknown>>;
-    rejectAllPending(message: string): void;
-}
-export {};
+export * from "../shared/agent-wire/host-tool-bridge";

package/dist/types/modes/rpc/host-uris.d.ts

@@ -1,38 +1 @@
-import { InternalUrlRouter } from "../../internal-urls";
-import type { InternalResource, InternalUrl, ResolveContext, WriteContext } from "../../internal-urls/types";
-import type { RpcHostUriCancelRequest, RpcHostUriRequest, RpcHostUriResult, RpcHostUriSchemeDefinition } from "./rpc-types";
-type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
-/** Type guard for inbound `host_uri_result` frames coming from the host. */
-export declare function isRpcHostUriResult(value: unknown): value is RpcHostUriResult;
-/**
- * Bidirectional bridge that lets the RPC host own a set of URI schemes.
- *
- * The host registers schemes via `set_host_uri_schemes`; the bridge installs
- * a `RpcHostUriProtocolHandler` per scheme into the process-global
- * {@link InternalUrlRouter}. Reads land on the read tool through the existing
- * router; writes are intercepted by the write tool and dispatched through
- * `requestWrite`.
- */
-export declare class RpcHostUriBridge {
-    #private;
-    constructor(output: RpcHostUriOutput, router?: InternalUrlRouter);
-    getSchemes(): string[];
-    /**
-     * Replace the registered set of host URI schemes. Previously registered
-     * schemes that no longer appear in the new set are unregistered from the
-     * router; surviving and new schemes get fresh handler instances.
-     */
-    setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[];
-    /**
-     * Unregister every host scheme from the router and reject any in-flight
-     * requests. Called on RPC shutdown to keep the global router clean for
-     * subsequent sessions in the same process (used by tests).
-     */
-    clear(message?: string): void;
-    /** Resolve a pending request by id; called by `rpc-mode` on inbound results. */
-    handleResult(frame: RpcHostUriResult): boolean;
-    rejectAllPending(message: string): void;
-    requestRead(scheme: string, url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
-    requestWrite(_scheme: string, url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
-}
-export {};
+export * from "../shared/agent-wire/host-uri-bridge";

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

@@ -0,0 +1,20 @@
+import type { AgentTool } from "@gajae-code/agent-core";
+import type { ExtensionUIContext } from "../../../extensibility/extensions";
+import type { AgentSession } from "../../../session/agent-session";
+import type { RpcCommand, RpcExtensionUIRequest, RpcHostToolDefinition, RpcHostUriSchemeDefinition, RpcResponse } from "../../rpc/rpc-types";
+export type RpcCommandDispatchOutput = (obj: RpcResponse | RpcExtensionUIRequest | object) => void;
+export interface RpcHostToolRegistry {
+    setTools(tools: RpcHostToolDefinition[]): AgentTool[];
+}
+export interface RpcHostUriRegistry {
+    setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[];
+}
+export interface RpcCommandDispatchContext {
+    session: AgentSession;
+    output: RpcCommandDispatchOutput;
+    hostToolRegistry: RpcHostToolRegistry;
+    hostUriRegistry: RpcHostUriRegistry;
+    createUiContext: () => Pick<ExtensionUIContext, "notify">;
+}
+export declare function normalizeHostToolDefinitions(tools: RpcHostToolDefinition[]): RpcHostToolDefinition[];
+export declare function dispatchRpcCommand(command: RpcCommand, context: RpcCommandDispatchContext): Promise<RpcResponse>;

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

@@ -0,0 +1,2 @@
+import type { RpcCommand } from "../../rpc/rpc-types";
+export declare function isRpcCommand(value: unknown): value is RpcCommand;

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

@@ -0,0 +1,24 @@
+import type { AgentSessionEvent } from "../../../session/agent-session";
+import { type AgentSessionEventType, type BridgeEventFrame, type BridgeFrameEnvelope, type BridgeFrameType } from "./protocol";
+/**
+ * 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;
+/**
+ * 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 {
+    #private;
+    constructor(sessionId: string);
+    /** The session id stamped onto every frame this sequencer produces. */
+    get sessionId(): string;
+    /** 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>;
+}
+/** Serialize a single `AgentSessionEvent` into an `event` wire frame. */
+export declare function toBridgeEventFrame(event: AgentSessionEvent, sequencer: BridgeFrameSequencer): BridgeEventFrame;

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

@@ -0,0 +1,46 @@
+import { BRIDGE_PROTOCOL_VERSION, type BridgeFrameType } from "./protocol";
+import type { BridgeCommandScope } from "./scopes";
+export type BridgeCapability = "events" | "prompt" | "permission" | "elicitation" | "ui.declarative" | "ui.editor" | "ui.terminal_input" | "host_tools" | "host_uri" | "client_bridge.read_text_file" | "client_bridge.write_text_file" | "client_bridge.create_terminal";
+export interface BridgeProtocolRange {
+    min: number;
+    max: number;
+}
+export interface BridgeHandshakeRequest {
+    protocol_version_range: BridgeProtocolRange;
+    capabilities: BridgeCapability[];
+    requested_scopes: BridgeCommandScope[];
+    last_seq?: number;
+}
+export interface BridgeEndpointDescriptor {
+    events: string;
+    commands: string;
+    uiResponses: string;
+    claimControl: string;
+    disconnectControl: string;
+    hostToolResults: string;
+    hostUriResults: string;
+}
+export interface BridgeHandshakeAccepted {
+    status: "accepted";
+    protocol_version: typeof BRIDGE_PROTOCOL_VERSION;
+    session_id: string;
+    accepted_capabilities: BridgeCapability[];
+    accepted_scopes: BridgeCommandScope[];
+    unsupported: BridgeCapability[];
+    endpoints: BridgeEndpointDescriptor;
+    frame_types: BridgeFrameType[];
+}
+export interface BridgeHandshakeRejected {
+    status: "rejected";
+    reason: "incompatible_version" | "unauthorized" | "invalid_request";
+    message: string;
+}
+export type BridgeHandshakeResponse = BridgeHandshakeAccepted | BridgeHandshakeRejected;
+export declare function isBridgeHandshakeRequest(value: unknown): value is BridgeHandshakeRequest;
+export declare function negotiateBridgeHandshake(request: BridgeHandshakeRequest, server: {
+    sessionId: string;
+    capabilities: readonly BridgeCapability[];
+    scopes: readonly BridgeCommandScope[];
+    endpoints: BridgeEndpointDescriptor;
+    frameTypes: readonly BridgeFrameType[];
+}): BridgeHandshakeResponse;

package/dist/types/modes/shared/agent-wire/host-tool-bridge.d.ts

@@ -0,0 +1,16 @@
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostToolDefinition, RpcHostToolResult, RpcHostToolUpdate } from "../../rpc/rpc-types";
+type RpcHostToolOutput = (frame: RpcHostToolCallRequest | RpcHostToolCancelRequest) => void;
+export declare function isRpcHostToolResult(value: unknown): value is RpcHostToolResult;
+export declare function isRpcHostToolUpdate(value: unknown): value is RpcHostToolUpdate;
+export declare class RpcHostToolBridge {
+    #private;
+    constructor(output: RpcHostToolOutput);
+    getToolNames(): string[];
+    setTools(tools: RpcHostToolDefinition[]): AgentTool[];
+    handleResult(frame: RpcHostToolResult): boolean;
+    handleUpdate(frame: RpcHostToolUpdate): boolean;
+    requestExecution(definition: RpcHostToolDefinition, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<unknown>): Promise<AgentToolResult<unknown>>;
+    rejectAllPending(message: string): void;
+}
+export {};

package/dist/types/modes/shared/agent-wire/host-uri-bridge.d.ts

@@ -0,0 +1,17 @@
+import { InternalUrlRouter } from "../../../internal-urls";
+import type { InternalResource, InternalUrl, ResolveContext, WriteContext } from "../../../internal-urls/types";
+import type { RpcHostUriCancelRequest, RpcHostUriRequest, RpcHostUriResult, RpcHostUriSchemeDefinition } from "../../rpc/rpc-types";
+type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
+export declare function isRpcHostUriResult(value: unknown): value is RpcHostUriResult;
+export declare class RpcHostUriBridge {
+    #private;
+    constructor(output: RpcHostUriOutput, router?: InternalUrlRouter);
+    getSchemes(): string[];
+    setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[];
+    clear(message?: string): void;
+    handleResult(frame: RpcHostUriResult): boolean;
+    rejectAllPending(message: string): void;
+    requestRead(scheme: string, url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+    requestWrite(_scheme: string, url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,44 @@
+/**
+ * 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`.
+ */
+import type { AgentSessionEvent } from "../../../session/agent-session";
+/** Wire protocol version. Bump on breaking envelope/semantic changes. */
+export declare const BRIDGE_PROTOCOL_VERSION: 1;
+/** The discriminant of every `AgentSessionEvent` the agent can emit. */
+export type AgentSessionEventType = AgentSessionEvent["type"];
+/** 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" | "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;
+}
+/** An `AgentSessionEvent` serialized into a versioned wire frame. */
+export type BridgeEventFrame = BridgeFrameEnvelope<"event", BridgeEventPayload>;

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

@@ -0,0 +1,4 @@
+/** Shared RPC-compatible response helpers for agent-wire consumers. */
+import type { RpcCommand, RpcResponse } from "../../rpc/rpc-types";
+export declare function rpcSuccess<T extends RpcCommand["type"]>(id: string | undefined, command: T, data?: object | null): RpcResponse;
+export declare function rpcError(id: string | undefined, command: string, message: string): RpcResponse;

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

@@ -0,0 +1,18 @@
+/**
+ * Coarse bridge authorization scopes for RPC commands.
+ *
+ * The v1 bridge exposes a network-reachable control surface, so every
+ * `RpcCommand` must be assigned to one coarse scope before any REST handler can
+ * dispatch it. The registry is intentionally typed as `Record<RpcCommandType,
+ * BridgeCommandScope>` so adding a new RPC command without a scope is a compile
+ * failure.
+ */
+import type { RpcCommand } from "../../rpc/rpc-types";
+export type RpcCommandType = RpcCommand["type"];
+export type BridgeCommandScope = "prompt" | "control" | "bash" | "export" | "session" | "model" | "message:read" | "host_tools" | "host_uri" | "admin";
+export declare const BRIDGE_COMMAND_SCOPES: readonly BridgeCommandScope[];
+export declare const RPC_COMMAND_TYPES: readonly RpcCommandType[];
+export declare function isRpcCommandType(value: unknown): value is RpcCommandType;
+export declare const MANDATORY_FLOOR_COMMAND_SCOPES: readonly BridgeCommandScope[];
+export declare function scopeForRpcCommand(type: RpcCommandType): BridgeCommandScope;
+export declare function isRpcCommandAllowed(type: RpcCommandType, scopes: ReadonlySet<BridgeCommandScope>): boolean;

package/dist/types/modes/shared/agent-wire/ui-request-broker.d.ts

@@ -0,0 +1,42 @@
+export type UiRequestCancelReason = "timeout" | "abort" | "disconnect";
+export interface UiRequestCancelled {
+    status: "cancelled";
+    reason: UiRequestCancelReason;
+}
+export type UiRequestResolution<TResponse> = TResponse | UiRequestCancelled;
+export type UiBrokerResponseResult = {
+    status: "accepted";
+} | {
+    status: "rejected";
+    code: "not_controller" | "already_resolved" | "unknown_request";
+};
+export interface UiRequestBrokerOptions<TRequest> {
+    emitRequest: (correlationId: string, request: TRequest) => void;
+}
+export interface UiRequestOptions {
+    correlationId?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Broker for one active session. v1 supports one controller token at a time;
+ * other clients may observe frames but cannot answer correlated requests.
+ */
+export declare class UiRequestBroker<TRequest, TResponse> {
+    #private;
+    constructor(options: UiRequestBrokerOptions<TRequest>);
+    get ownerToken(): string | undefined;
+    get pendingCount(): number;
+    claimController(ownerToken?: string): {
+        status: "claimed";
+        ownerToken: string;
+    } | {
+        status: "busy";
+    };
+    releaseController(ownerToken: string): boolean;
+    request(request: TRequest, options?: UiRequestOptions): Promise<UiRequestResolution<TResponse>>;
+    respond(correlationId: string, ownerToken: string, response: TResponse): UiBrokerResponseResult;
+    cancelAll(reason: UiRequestCancelReason): void;
+    cancel(correlationId: string, reason: UiRequestCancelReason): boolean;
+    disconnectController(ownerToken: string): boolean;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Typed UI/manipulation result semantics for bridge-capability handling.
+ *
+ * `unsupported` is distinct from both a real value and user cancellation. This
+ * prevents local-only or undeclared `ExtensionUIContext` surfaces from becoming
+ * silent no-ops that look like user intent.
+ */
+export interface BridgeUiValue<TValue> {
+    status: "value";
+    value: TValue;
+}
+export interface BridgeUiCancelled {
+    status: "cancelled";
+    reason?: "user" | "timeout" | "abort" | "disconnect";
+}
+export interface BridgeUiUnsupported {
+    status: "unsupported";
+    capability: string;
+    reason: string;
+}
+export type BridgeUiResult<TValue> = BridgeUiValue<TValue> | BridgeUiCancelled | BridgeUiUnsupported;
+export declare function uiValue<TValue>(value: TValue): BridgeUiValue<TValue>;
+export declare function uiCancelled(reason?: BridgeUiCancelled["reason"]): BridgeUiCancelled;
+export declare function uiUnsupported(capability: string, reason: string): BridgeUiUnsupported;
+export declare function isUiUnsupported<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiUnsupported;
+export declare function isUiCancelled<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiCancelled;
+export declare function isUiValue<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiValue<TValue>;

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

@@ -93,6 +93,7 @@ export interface InteractiveModeContext {
     retryLoader: Loader | undefined;
     autoCompactionEscapeHandler?: () => void;
     retryEscapeHandler?: () => void;
+    retryCountdownTimer?: ReturnType<typeof setInterval>;
     unsubscribe?: () => void;
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;
@@ -227,6 +228,7 @@ export interface InteractiveModeContext {
     showHookConfirm(title: string, message: string): Promise<boolean>;
     showDebugSelector(): void;
     showSessionObserver(): void;
+    showJobsOverlay(): void;
     resetObserverRegistry(): void;
     handleCtrlC(): void;
     handleCtrlD(): void;

package/dist/types/sdk.d.ts

@@ -93,6 +93,8 @@ export interface CreateAgentSessionOptions {
     requireYieldTool?: boolean;
     /** Task recursion depth (for subagent sessions). Default: 0 */
     taskDepth?: number;
+    /** Current role-agent type/name for nested task sessions. */
+    currentAgentType?: string;
     /** Parent Hindsight state to alias for subagent memory tools. */
     parentHindsightSessionState?: HindsightSessionState;
     /** Pre-allocated agent identity for IRC routing. Default: "0-Main" for top-level, parentTaskPrefix-derived for sub. */
@@ -127,6 +129,8 @@ export interface CreateAgentSessionOptions {
     forkContextSeed?: ForkContextSeed;
     /** Optional provider state override. Fork-context children should omit this by default. */
     providerSessionState?: Map<string, ProviderSessionState>;
+    /** Cooperative pause checkpoint passed through to Agent. */
+    shouldPause?: () => boolean;
 }
 /** Result from createAgentSession */
 export interface CreateAgentSessionResult {

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

@@ -90,6 +90,7 @@ export type AgentSessionEvent = AgentEvent | {
     maxAttempts: number;
     delayMs: number;
     errorMessage: string;
+    unbounded?: boolean;
 } | {
     type: "auto_retry_end";
     success: boolean;
@@ -132,7 +133,7 @@ export type AgentSessionEvent = AgentEvent | {
 };
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime">;
+export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime" | "metadata">;
 export interface AsyncJobSnapshot {
     running: AsyncJobSnapshotItem[];
     recent: AsyncJobSnapshotItem[];
@@ -357,6 +358,7 @@ export declare class AgentSession {
      *  Does NOT push to the agent's steering/followUp queue — that happens
      *  separately inside `sendCustomMessage`. */
     enqueueCustomMessageDisplay(text: string, mode: "steer" | "followUp"): string;
+    getAgentId(): string | undefined;
     getAsyncJobSnapshot(options?: {
         recentLimit?: number;
     }): AsyncJobSnapshot | null;
@@ -576,6 +578,10 @@ export declare class AgentSession {
     };
     /** Number of pending messages (includes steering, follow-up, and next-turn messages) */
     get queuedMessageCount(): number;
+    /** Whether the agent has queued steering messages that a `user_interrupt`
+     *  abort would resume into (steer-on-interrupt). Drives the Esc-on-steer UX:
+     *  the first Esc consumes the steer and auto-continues, a second Esc aborts. */
+    get hasQueuedSteering(): boolean;
     /** Get pending messages (read-only). Returns the public text-only view;
      *  internal `{text, tag?}` records are mapped to `.text` so callers
      *  (`updatePendingMessagesDisplay`, `restoreQueuedMessagesToEditor`) see
@@ -604,6 +610,12 @@ export declare class AgentSession {
     abort(options?: {
         goalReason?: "interrupted" | "internal";
         timeoutMs?: number;
+        cause?: "user_interrupt" | "new_session" | "session_switch" | "compaction" | "handoff" | "tool_abort" | "internal";
+        /** Suppress the "Operation aborted" line on the resulting aborted message
+         *  by stamping `SILENT_ABORT_MARKER`. Used when Esc consumes a queued steer
+         *  and resumes via steer-on-interrupt, so the interrupt reads as a quiet
+         *  hand-off rather than a failure. */
+        silent?: boolean;
     }): Promise<void>;
     /**
      * Start a new session, optionally with initial messages and parent tracking.
@@ -752,6 +764,12 @@ export declare class AgentSession {
      * Cancel in-progress retry.
      */
     abortRetry(): void;
+    /**
+     * Skip the current retry backoff and re-attempt immediately. Distinct from
+     * abortRetry(), which cancels the retry and returns to idle. No-op when no
+     * retry backoff is active.
+     */
+    retryNow(): void;
     /** Whether auto-retry is currently in progress */
     get isRetrying(): boolean;
     /** Whether auto-retry is enabled */

package/dist/types/skill-state/active-state.d.ts

@@ -46,6 +46,8 @@ export interface SkillActiveState {
     session_id?: string;
     thread_id?: string;
     turn_id?: string;
+    initialized_mode?: CanonicalGjcWorkflowSkill;
+    initialized_state_path?: string;
     active_skills?: SkillActiveEntry[];
     [key: string]: unknown;
 }

package/dist/types/skill-state/deep-interview-mutation-guard.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool } from "@gajae-code/agent-core";
 export declare const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE = "Deep-interview phase boundary: continue gathering context/questions/risks and emit a handoff/spec before code edits. Mutation tools and patch execution are blocked while deep-interview is active; finalize specs through `gjc deep-interview --write --stage final` or hand off to an execution phase.";
-export declare const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE = "Workflow state JSON is runtime-owned. Use `gjc state <skill> read|write --input '<json>'` for deep-interview, ralplan, ultragoal, and team. Planning artifacts under `.gjc/specs/` and `.gjc/plans/` remain allowed.";
+export declare const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE = ".gjc workflow state and artifacts are runtime-owned. Agent mutation tools cannot edit `.gjc/**`; use the sanctioned `gjc` CLI instead.";
 type ToolWithEditMode = AgentTool & {
     mode?: unknown;
     customWireName?: unknown;

package/dist/types/skill-state/workflow-state-contract.d.ts

@@ -1,9 +1,14 @@
 import { type CanonicalGjcWorkflowSkill } from "./active-state";
+export { WORKFLOW_STATE_RECEIPT_FRESH_MS, WORKFLOW_STATE_RECEIPT_VERSION, WORKFLOW_STATE_VERSION, } from "./workflow-state-version";
 export type { CanonicalGjcWorkflowSkill };
-export declare const WORKFLOW_STATE_RECEIPT_VERSION = 1;
-export declare const WORKFLOW_STATE_RECEIPT_FRESH_MS: number;
 export type WorkflowStateMutationOwner = "gjc-state-cli" | "gjc-runtime" | "gjc-hook";
 export type WorkflowStateReceiptStatus = "fresh" | "stale";
+export interface WorkflowStateContentChecksum {
+    algorithm: "sha256";
+    value: string;
+    covered_path: string;
+    computed_at: string;
+}
 export interface WorkflowStateReceipt {
     version: 1;
     skill: CanonicalGjcWorkflowSkill;
@@ -15,6 +20,24 @@ export interface WorkflowStateReceipt {
     fresh_until: string;
     status: WorkflowStateReceiptStatus;
     mutation_id: string;
+    verb?: string;
+    from_phase?: string;
+    to_phase?: string;
+    forced?: boolean;
+    paths?: string[];
+    content_sha256?: WorkflowStateContentChecksum;
+}
+export interface AuditEntry {
+    ts: string;
+    skill?: string;
+    category: string;
+    verb: string;
+    owner: WorkflowStateMutationOwner;
+    mutation_id: string;
+    from_phase?: string;
+    to_phase?: string;
+    forced: boolean;
+    paths: string[];
 }
 export declare function workflowModeStateFileName(skill: CanonicalGjcWorkflowSkill): string;
 export declare function workflowStateStoragePath(cwd: string, skill: CanonicalGjcWorkflowSkill, sessionId?: string): string;

package/dist/types/skill-state/workflow-state-version.d.ts

@@ -0,0 +1,3 @@
+export declare const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export declare const WORKFLOW_STATE_VERSION = 2;
+export declare const WORKFLOW_STATE_RECEIPT_FRESH_MS: number;

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

@@ -29,6 +29,9 @@ export interface ExecutorOptions {
     index: number;
     id: string;
     modelOverride?: string | string[];
+    runMode?: "initial" | "resume" | "message";
+    resumeMessage?: string;
+    subagentId?: string;
     /**
      * Active model selector of the parent session, used as an auth-aware fallback
      * if the resolved subagent model has no working credentials. See #985.

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

@@ -0,0 +1,7 @@
+export declare const TASK_ID_PATTERN: RegExp;
+export declare const TASK_ID_DESCRIPTION = "filesystem-safe identifier matching ^[A-Za-z0-9][A-Za-z0-9_-]{0,47}$";
+export declare function isValidTaskId(id: string): boolean;
+export declare function getTaskIdValidationError(id: unknown): string | undefined;
+export declare function validateTaskId(id: string): string;
+export declare function isValidAllocatedTaskId(id: string): boolean;
+export declare function validateAllocatedTaskId(id: string): string;

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

@@ -1,4 +1,5 @@
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { Model } from "@gajae-code/ai";
 import type { ToolSession } from "..";
 import type { Theme } from "../modes/theme/theme";
 import { type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
@@ -7,9 +8,13 @@ import { renderResult, renderCall as renderTaskCall } from "./render";
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";
+export { isValidAllocatedTaskId, isValidTaskId, TASK_ID_DESCRIPTION, TASK_ID_PATTERN, validateAllocatedTaskId, validateTaskId, } from "./id";
 export { AgentOutputManager } from "./output-manager";
+export type { TaskResultReceipt } from "./receipt";
+export { assertNoRawTaskFields, buildTaskReceipt, buildTaskRoi, buildTaskRoiSummary, findRawTaskLeakKeys, sanitizeTaskToolDetails, } from "./receipt";
 export type { AgentDefinition, AgentProgress, SingleResult, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
 export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
+export declare function resolveForkContextMaxTokens(configured: number, model: Model | undefined): number;
 /**
  * Task tool - Delegate tasks to specialized agents.
  *