@gajae-code/coding-agent 0.3.0 → 0.3.2

package/dist/types/modes/bridge/bridge-ui-context.d.ts

@@ -0,0 +1,88 @@
+import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions";
+import type { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
+import { type Theme } from "../theme/theme";
+export type BridgeUiRequestPayload = {
+    kind: "select";
+    title: string;
+    options: string[];
+    timeout?: number;
+} | {
+    kind: "confirm";
+    title: string;
+    message: string;
+    timeout?: number;
+} | {
+    kind: "input";
+    title: string;
+    placeholder?: string;
+    timeout?: number;
+} | {
+    kind: "editor";
+    title: string;
+    prefill?: string;
+    promptStyle?: boolean;
+} | {
+    kind: "notify";
+    message: string;
+    type?: "info" | "warning" | "error";
+} | {
+    kind: "status";
+    key: string;
+    text: string | undefined;
+} | {
+    kind: "widget";
+    key: string;
+    lines: string[] | undefined;
+    placement?: "aboveEditor" | "belowEditor";
+} | {
+    kind: "title";
+    title: string;
+} | {
+    kind: "set_editor_text";
+    text: string;
+} | {
+    kind: "unsupported";
+    capability: string;
+    reason: string;
+};
+export type BridgeUiBroker = UiRequestBroker<BridgeUiRequestPayload, BridgeUiResult<unknown>>;
+export type BridgeUiEmitter = (payload: BridgeUiRequestPayload) => void;
+export declare class BridgeExtensionUIContext implements ExtensionUIContext {
+    #private;
+    constructor(options: {
+        broker: BridgeUiBroker;
+        emit: BridgeUiEmitter;
+    });
+    select(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    confirm(title: string, message: string, dialogOptions?: ExtensionUIDialogOptions): Promise<boolean>;
+    input(title: string, placeholder?: string, dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    notify(message: string, type?: "info" | "warning" | "error"): void;
+    onTerminalInput(_handler: TerminalInputHandler): () => void;
+    setStatus(key: string, text: string | undefined): void;
+    setWorkingMessage(message?: string): void;
+    setWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
+    setFooter(_factory?: unknown): void;
+    setHeader(_factory?: unknown): void;
+    setTitle(title: string): void;
+    custom<T>(): Promise<T>;
+    setEditorText(text: string): void;
+    pasteToEditor(text: string): void;
+    getEditorText(): string;
+    editor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
+    setEditorComponent(_factory?: unknown): void;
+    get theme(): Theme;
+    getAllThemes(): Promise<{
+        name: string;
+        path: string | undefined;
+    }[]>;
+    getTheme(_name: string): Promise<Theme | undefined>;
+    setTheme(_theme: string | Theme): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getToolsExpanded(): boolean;
+    setToolsExpanded(_expanded: boolean): void;
+}

package/dist/types/modes/bridge/event-stream.d.ts

@@ -0,0 +1,8 @@
+import type { BridgeFrameEnvelope } from "../shared/agent-wire/protocol";
+export declare class BridgeEventStream {
+    #private;
+    constructor(replayLimit?: number);
+    get frameCount(): number;
+    publish(frame: BridgeFrameEnvelope): void;
+    response(lastSeq?: number): Response;
+}

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,6 +1,7 @@
 import { Editor, type KeyId } from "@gajae-code/tui";
 import type { AppKeybinding } from "../../config/keybindings";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
+type PastePendingClearReason = "timeout" | "queue-limit";
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
@@ -25,6 +26,10 @@ export declare class CustomEditor extends Editor {
     onCopyPrompt?: () => void;
     /** Called when the configured image-paste shortcut is pressed. */
     onPasteImage?: () => Promise<boolean>;
+    /** Called before bracketed paste content is inserted. Return true to consume it. */
+    onPasteText?: (text: string) => boolean | Promise<boolean>;
+    /** Called when async paste handling drops queued input instead of replaying it. */
+    onPastePendingInputCleared?: (reason: PastePendingClearReason, droppedInputCount: number) => void;
     /** Called when the configured dequeue shortcut is pressed. */
     onDequeue?: () => void;
     /** Called when Caps Lock is pressed. */
@@ -42,6 +47,7 @@ export declare class CustomEditor extends Editor {
      * Clear all custom key handlers.
      */
     clearCustomKeyHandlers(): void;
+    dispose(): void;
     handleInput(data: string): void;
 }
 export {};

package/dist/types/modes/components/custom-provider-wizard.d.ts

@@ -0,0 +1,10 @@
+import { Container } from "@gajae-code/tui";
+import type { ProviderSetupInput } from "../../setup/provider-onboarding";
+export type CustomProviderCredentialSource = "env" | "literal";
+export type CustomProviderWizardSubmit = ProviderSetupInput;
+export declare class CustomProviderWizardComponent extends Container {
+    #private;
+    constructor(onSubmit: (input: CustomProviderWizardSubmit) => void, onCancel: () => void, onRender?: () => void);
+    setSubmitError(error: string): void;
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/jobs-overlay-model.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure model helpers for the jobs overlay.
+ *
+ * Kept free of UI/Component dependencies so the grouping/ordering and
+ * detail-formatting logic is unit-testable. The selector controller wires these
+ * SelectItem lists into nested SelectLists (list -> detail -> confirm).
+ */
+import type { SelectItem } from "@gajae-code/tui";
+import type { JobsSnapshot } from "../jobs-observer";
+export type JobRefKind = "monitor" | "cron";
+export interface JobRef {
+    kind: JobRefKind;
+    id: string;
+}
+/** Compact relative time, e.g. "in 5m", "2m ago", "now". */
+export declare function formatRelative(targetMs: number | undefined, nowMs?: number): string;
+/** Parse a list item value back into a job reference. */
+export declare function parseJobRef(value: string): JobRef | null;
+/**
+ * Build the grouped jobs list: monitors first (newest-first), then crons
+ * (newest-first). The snapshot arrays are already sorted newest-first.
+ */
+export declare function buildJobsListItems(snapshot: JobsSnapshot): SelectItem[];
+/**
+ * Build the detail-level items for a job: read-only info rows (value "noop"),
+ * then the destructive action, then a back row. `output` is the bounded monitor
+ * output tail (ignored for cron jobs).
+ */
+export declare function buildJobDetailItems(snapshot: JobsSnapshot, ref: JobRef, output?: string): SelectItem[];
+/** Yes/No confirm items for a destructive action. */
+export declare function buildConfirmItems(actionLabel: string): SelectItem[];

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

@@ -0,0 +1,30 @@
+import { Container, type SelectItem, SelectList } from "@gajae-code/tui";
+import type { JobsSnapshot } from "../jobs-observer";
+/**
+ * Generic single-level selector used by the jobs overlay. The selector
+ * controller mounts a fresh instance per navigation level (list -> detail ->
+ * confirm); focus is placed on the inner SelectList, matching the existing
+ * selector components (e.g. ThemeSelectorComponent).
+ */
+export declare class JobsSelectorComponent extends Container {
+    #private;
+    constructor(items: SelectItem[], onSelect: (item: SelectItem) => void, onCancel: () => void, maxVisible?: number);
+    getSelectList(): SelectList;
+}
+export interface JobsOverlayController {
+    acknowledgeFailures(): void;
+    getSnapshot(): JobsSnapshot;
+    getMonitorOutput(id: string): string;
+    cancelMonitor(id: string): boolean;
+    deleteCron(id: string): boolean;
+}
+export interface JobsOverlayCallbacks {
+    close(): void;
+    requestRender(): void;
+}
+export declare class JobsOverlayComponent extends Container {
+    #private;
+    constructor(controller: JobsOverlayController, callbacks: JobsOverlayCallbacks);
+    getFocus(): SelectList;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/model-selector.d.ts

@@ -23,8 +23,12 @@ export type ModelSelectorSelection = {
     selector: string;
     preset: ModelAssignmentPreset;
     assignments: Record<GjcModelAssignmentTargetId, ThinkingLevel>;
+} | {
+    kind: "profile";
+    profileName: string;
+    setDefault: boolean;
 };
-type RoleSelectCallback = (selection: ModelSelectorSelection) => void;
+type RoleSelectCallback = (selection: ModelSelectorSelection) => void | Promise<void>;
 /**
  * Component that renders a canonical model selector with provider tabs.
  * - Tab/Arrow Left/Right: Switch between provider tabs
@@ -40,5 +44,6 @@ export declare class ModelSelectorComponent extends Container {
     });
     handleInput(keyData: string): void;
     getSearchInput(): Input;
+    __testSelectProfile(profileName: string, setDefault: boolean): Promise<void>;
 }
 export {};

package/dist/types/modes/components/provider-onboarding-selector.d.ts

@@ -1,5 +1,5 @@
 import { Container } from "@gajae-code/tui";
-export type ProviderOnboardingAction = "oauth-login" | "api-guide";
+export type ProviderOnboardingAction = "custom-provider-wizard" | "oauth-login" | "api-guide";
 export declare class ProviderOnboardingSelectorComponent extends Container {
     #private;
     constructor(onSelect: (action: ProviderOnboardingAction) => void, onCancel: () => void);

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

@@ -1,5 +1,6 @@
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../../config/settings-schema";
 import type { AgentSession } from "../../../session/agent-session";
+import type { JobsSnapshot } from "../../jobs-observer";
 import type { StatusLineSegmentOptions, StatusLineSettings } from "../status-line";
 export type { StatusLinePreset, StatusLineSegmentId, StatusLineSegmentOptions, StatusLineSeparatorStyle, StatusLineSettings, };
 export type RGB = readonly [number, number, number];
@@ -28,6 +29,7 @@ export interface SegmentContext {
     contextWindow: number;
     autoCompactEnabled: boolean;
     subagentCount: number;
+    jobs: JobsSnapshot;
     sessionStartTime: number;
     git: {
         branch: string | null;

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

@@ -2,6 +2,7 @@ import { type Component } from "@gajae-code/tui";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import type { AgentSession } from "../../session/agent-session";
 import { type SkillActiveEntry } from "../../skill-state/active-state";
+import { type JobsSnapshot } from "../jobs-observer";
 export interface StatusLineSegmentOptions {
     model?: {
         showThinkingLevel?: boolean;
@@ -39,6 +40,7 @@ export declare class StatusLineComponent implements Component {
     updateSettings(settings: StatusLineSettings): void;
     setAutoCompactEnabled(enabled: boolean): void;
     setSubagentCount(count: number): void;
+    setJobs(jobs: JobsSnapshot): void;
     setSessionStartTime(time: number): void;
     setPlanModeStatus(status: {
         enabled: boolean;

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

@@ -17,6 +17,7 @@ export declare class InputController {
         currentText?: string;
     }): number;
     handleBackgroundCommand(): void;
+    handleTextPaste(text: string): boolean | Promise<boolean>;
     handleImagePaste(): Promise<boolean>;
     createAutocompleteProvider(commands: SlashCommand[], basePath: string): AutocompleteProvider;
     /** Copy the current editor line to the system clipboard. */

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;
@@ -14,6 +15,7 @@ export declare class SelectorController {
         focus: Component;
     }): void;
     showProviderOnboarding(): void;
+    showCustomProviderWizard(): void;
     showSettingsSelector(): void;
     showThemeSelector(): void;
     showHistorySearch(): void;
@@ -44,4 +46,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

@@ -191,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;