@gajae-code/coding-agent 0.3.0 → 0.3.1

package/dist/types/harness-control-plane/control-endpoint.d.ts

@@ -24,7 +24,8 @@ export declare class ControlServer {
 }
 export declare class EndpointUnreachableError extends Error {
     readonly socketPath: string;
-    constructor(socketPath: string);
+    readonly reason: string;
+    constructor(socketPath: string, reason?: string);
 }
-/** Call the owner's control endpoint. Rejects with {@link EndpointUnreachableError} when no owner listens. */
+/** Call the owner's control endpoint. Rejects with {@link EndpointUnreachableError} when no owner listens or responds. */
 export declare function callEndpoint(socketPath: string, req: EndpointRequest, timeoutMs?: number): Promise<unknown>;

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

@@ -59,6 +59,27 @@ import { initialPhaseForSkill } from "../skill-state/initial-phase";
 export { initialPhaseForSkill };
 export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string, stateDir?: string): Promise<SkillActiveState | null>;
 export declare function recordSkillActivation(input: RecordSkillActivationInput): Promise<SkillActiveState | null>;
+export interface EnsureWorkflowSkillActivationInput {
+    cwd: string;
+    skill: string;
+    sessionId?: string;
+    threadId?: string;
+    turnId?: string;
+    nowIso?: string;
+    stateDir?: string;
+}
+/**
+ * Idempotently seed `.gjc/state` for a workflow skill that was invoked directly
+ * (e.g. via `/skill:<name>`) rather than through keyword detection. This ensures
+ * the mutation guard and Stop hook engage the moment a workflow skill becomes
+ * active, instead of relying on the skill prompt to run its own state-init steps.
+ *
+ * The seed is non-destructive: if an active entry for this skill already exists
+ * (for example after a `gjc state handoff` promotion that carries
+ * `handoff_from`/`handoff_at` lineage), nothing is written so lineage is
+ * preserved. Non-workflow skills are ignored.
+ */
+export declare function ensureWorkflowSkillActivationState(input: EnsureWorkflowSkillActivationInput): Promise<SkillActiveState | null>;
 export declare function buildActiveUltragoalPromptContext(input: UserPromptSubmitStateInput): Promise<string | null>;
 export declare function buildSkillStopOutput(input: StopHookInput): Promise<Record<string, unknown> | null>;
 export declare function buildSkillActivationAdditionalContext(state: SkillActiveState, effectiveSkillConfig?: EffectiveSkillConfigInput): string;

package/dist/types/internal-urls/agent-protocol.d.ts

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
 /**
  * Handler for agent:// URLs.
  *
@@ -8,5 +8,5 @@ import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 export declare class AgentProtocolHandler implements ProtocolHandler {
     readonly scheme = "agent";
     readonly immutable = true;
-    resolve(url: InternalUrl): Promise<InternalResource>;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
 }

package/dist/types/internal-urls/artifact-protocol.d.ts

@@ -1,6 +1,6 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
 export declare class ArtifactProtocolHandler implements ProtocolHandler {
     readonly scheme = "artifact";
     readonly immutable = true;
-    resolve(url: InternalUrl): Promise<InternalResource>;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
 }

package/dist/types/internal-urls/registry-helpers.d.ts

@@ -1,10 +1,11 @@
+import type { ResolveContext } from "./types";
 /**
- * Snapshot of artifacts dirs for every registered session, deduped.
+ * Snapshot of artifacts dirs explicitly authorized for the calling session.
  *
- * Prefers `sessionManager.getArtifactsDir()` because subagents adopt their
- * parent's `ArtifactManager` and report the parent's dir there; dedup then
- * collapses parent + N subagents (the whole agent tree) to one entry. Falls
- * back to the raw session file (with the `.jsonl` suffix stripped) when no
- * live session reference is attached.
+ * Normal reads are scoped to the caller's artifacts directory. Parent/child
+ * agent tree sharing is allowed only when the caller supplies explicit
+ * authorized directories at the ResolveContext boundary. This intentionally
+ * does not enumerate AgentRegistry.global(); live but unrelated sessions are
+ * not an authorization source.
  */
-export declare function artifactsDirsFromRegistry(): string[];
+export declare function authorizedArtifactsDirsFromContext(context?: ResolveContext): string[];

package/dist/types/internal-urls/types.d.ts

@@ -56,6 +56,10 @@ export interface ResolveContext {
     cwd?: string;
     /** Settings of the calling session (used by `issue://`/`pr://` for cache TTLs). */
     settings?: unknown;
+    /** Artifacts directory of the calling session. */
+    getArtifactsDir?: () => string | null;
+    /** Additional artifacts directories explicitly authorized for this caller (for parent/child agent trees). */
+    getAuthorizedArtifactsDirs?: () => readonly string[];
     /** Caller's abort signal. */
     signal?: AbortSignal;
 }

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

@@ -93,8 +93,8 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
     readonly loadMode = "discoverable";
     readonly summary = "Query LSP (language server) for diagnostics, hover info, and references";
     readonly description: string;
-    readonly parameters: import("zod/v4").ZodObject<{
-        action: import("zod/v4").ZodEnum<{
+    readonly parameters: import("zod").ZodObject<{
+        action: import("zod").ZodEnum<{
             capabilities: "capabilities";
             code_actions: "code_actions";
             definition: "definition";
@@ -110,14 +110,14 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
             symbols: "symbols";
             type_definition: "type_definition";
         }>;
-        file: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        line: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
-        symbol: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        query: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        new_name: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        apply: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
-        timeout: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
-        payload: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        file: import("zod").ZodOptional<import("zod").ZodString>;
+        line: import("zod").ZodOptional<import("zod").ZodNumber>;
+        symbol: import("zod").ZodOptional<import("zod").ZodString>;
+        query: import("zod").ZodOptional<import("zod").ZodString>;
+        new_name: import("zod").ZodOptional<import("zod").ZodString>;
+        apply: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+        payload: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
     readonly renderCall: typeof renderCall;
     readonly renderResult: typeof renderResult;

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

@@ -0,0 +1,12 @@
+export interface BridgeAuthConfig {
+    token: string;
+}
+export interface BridgeBindConfig {
+    hostname: string;
+    port: number;
+    tlsConfigured: boolean;
+}
+export declare function extractBearerToken(authorization: string | null | undefined): string | undefined;
+export declare function isBridgeTokenAuthorized(authorization: string | null | undefined, config: BridgeAuthConfig): boolean;
+export declare function isLoopbackHost(hostname: string): boolean;
+export declare function assertSafeBridgeBind(config: BridgeBindConfig): void;

package/dist/types/modes/bridge/bridge-client-bridge.d.ts

@@ -0,0 +1,9 @@
+import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
+import type { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+export interface BridgePermissionRequestPayload {
+    kind: "permission";
+    toolCall: ClientBridgePermissionToolCall;
+    options: ClientBridgePermissionOption[];
+}
+export type BridgePermissionBroker = UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+export declare function createBridgeClientBridge(broker: BridgePermissionBroker): ClientBridge;

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

@@ -0,0 +1,44 @@
+import type { ExtensionUIContext } from "../../extensibility/extensions";
+import type { AgentSession } from "../../session/agent-session";
+import type { ClientBridgePermissionOutcome } from "../../session/client-bridge";
+import type { RpcCommand, RpcResponse } from "../rpc/rpc-types";
+import { RpcHostToolBridge } from "../shared/agent-wire/host-tool-bridge";
+import { RpcHostUriBridge } from "../shared/agent-wire/host-uri-bridge";
+import { type BridgeCommandScope } from "../shared/agent-wire/scopes";
+import { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
+import { type BridgePermissionRequestPayload } from "./bridge-client-bridge";
+import { type BridgeUiRequestPayload } from "./bridge-ui-context";
+import { BridgeEventStream } from "./event-stream";
+interface BridgeEndpointMatrix {
+    events: boolean;
+    commands: boolean;
+    control: boolean;
+    uiResponses: boolean;
+    hostToolResults: boolean;
+    hostUriResults: boolean;
+}
+interface BridgeFetchHandlerOptions {
+    sessionId: string;
+    token: string;
+    eventStream?: BridgeEventStream;
+    commandDispatcher?: (command: RpcCommand) => Promise<RpcResponse>;
+    commandScopes?: readonly BridgeCommandScope[];
+    idempotencyCache?: BridgeIdempotencyCache;
+    permissionBroker?: UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+    uiBroker?: UiRequestBroker<BridgeUiRequestPayload, BridgeUiResult<unknown>>;
+    hostToolBridge?: RpcHostToolBridge;
+    hostUriBridge?: RpcHostUriBridge;
+    endpointMatrix?: Partial<BridgeEndpointMatrix>;
+}
+interface BridgeIdempotencyRecord {
+    route: string;
+    ownerToken?: string;
+    body: string | Promise<string>;
+    response: unknown | Promise<unknown>;
+    pending?: boolean;
+}
+type BridgeIdempotencyCache = Map<string, BridgeIdempotencyRecord>;
+export declare function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (request: Request) => Promise<Response>;
+export declare function runBridgeMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
+export {};

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/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/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;
@@ -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

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