@gajae-code/coding-agent 0.2.5 → 0.3.1

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

@@ -0,0 +1,162 @@
+/**
+ * Core types for the gajae-code-native coding-harness operations control plane (v1).
+ *
+ * See the approved consensus plan at
+ * `.gjc/plans/ralplan/2026-06-02-0853-3e33/stage-02-revision.md` and the spec at
+ * `.gjc/specs/deep-interview-harness-control-plane.md`.
+ *
+ * v1 implements the gajae-code adapter only. omx/codex/remote/auth are deferred seams.
+ */
+/** Harnesses the control plane can operate. v1 implements `gajae-code` only. */
+export type Harness = "gajae-code" | "codex" | "omx";
+/** Lifecycle states of an operated session. */
+export type HarnessLifecycle = "new" | "started" | "submitted" | "observing" | "recovering" | "validating" | "finalizing" | "completed" | "blocked" | "retired";
+/** Event severities emitted by the owner. */
+export type Severity = "info" | "warn" | "critical";
+/** Bounded git delta classification surfaced by `observe`. */
+export type GitDelta = "clean" | "dirty" | "zero-delta" | "unknown";
+/** Risk classification surfaced by `observe`. */
+export type RiskKind = "normal" | "prompt-not-accepted" | "deleted-worktree" | "vanished-dirty";
+/** Deterministic recovery classifications. */
+export type RecoveryClassification = "continue" | "send-enter" | "reinject-prompt" | "restart-clean" | "restart-preserve-delta" | "fallback-codex-exec" | "human-check";
+/** Receipt families persisted under the session storage dir. */
+export type ReceiptFamily = "vanish" | "prompt-acceptance" | "validation" | "completion";
+/** The CLI verbs / primitives exposed by `gjc harness <verb>`. */
+export type HarnessVerb = "start" | "submit" | "observe" | "classify" | "recover" | "validate" | "finalize" | "retire" | "events" | "monitor" | "operate";
+/** Submission transports. */
+export type SubmitMode = "paste-buffer" | "stdin" | "file";
+/** A single entry in the forcing-function `nextAllowedActions` list. */
+export interface NextAllowedAction {
+    verb: HarnessVerb;
+    available: boolean;
+    /** Present when `available` is false; explains why the verb is currently disallowed. */
+    reason?: string;
+}
+/** Compact, model-facing view of session state included in every response. */
+export interface SessionStateView {
+    sessionId: string;
+    lifecycle: HarnessLifecycle;
+    harness: Harness;
+    ownerLive: boolean;
+    blockers: string[];
+}
+/**
+ * The universal contract: EVERY primitive response carries `{state, evidence, nextAllowedActions}`.
+ * `ok` is a transport-level convenience; semantic blocking is expressed via state + nextAllowedActions.
+ */
+export interface PrimitiveResponse<E = Record<string, unknown>> {
+    ok: boolean;
+    state: SessionStateView;
+    evidence: E;
+    nextAllowedActions: NextAllowedAction[];
+}
+/** Re-grabbable session handle returned by `start` / `operate`. */
+export interface SessionHandle {
+    sessionId: string;
+    harness: Harness;
+    repo: string | null;
+    workspace: string;
+    branch: string | null;
+    base: string | null;
+    issueOrPr: string | null;
+    processHandle: {
+        kind: "runtime-owner";
+        ownerId: string | null;
+        pid: number | null;
+    };
+    rpcHandle: {
+        kind: "rpc-subprocess";
+        pid: number | null;
+        sessionDir: string;
+    };
+    ownerHandle: {
+        leasePath: string;
+        endpoint: string | null;
+        heartbeatAt: string | null;
+    };
+    routerHandle: {
+        kind: "default-in-owner";
+        policy: string;
+        eventsPath: string;
+    };
+    viewportHandle: {
+        kind: "event-monitor";
+        tmuxSessionName: string | null;
+        viewOnly: true;
+    };
+    startedAt: string;
+    updatedAt: string;
+}
+/** Persisted per-session record (state.json). */
+export interface SessionState {
+    schemaVersion: number;
+    sessionId: string;
+    lifecycle: HarnessLifecycle;
+    harness: Harness;
+    handle: SessionHandle;
+    /** Per-classification retry counters consumed by the recovery policy. */
+    retries: Record<string, number>;
+    blockers: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+/** Bounded observed-signal vocabulary surfaced by `observe` (the owner only ever emits these). */
+export type ObservedSignal = "SessionStart" | "prompt-accepted" | "tool-call" | "test-running" | "commit-created" | "completed" | "error" | "streaming" | "idle";
+export declare const OBSERVED_SIGNALS: readonly ObservedSignal[];
+/** Bounded observation surfaced by `observe` — never a raw pane/transcript dump. */
+export interface Observation {
+    lifecycle: HarnessLifecycle;
+    ownerLive: boolean;
+    cwd: string;
+    branch: string | null;
+    gitDelta: GitDelta;
+    lastActivityAt: string | null;
+    observedSignals: string[];
+    risk: RiskKind;
+    /** RPC subprocess liveness, distinct from owner-process/lease liveness. Optional for back-compat. */
+    rpcLive?: boolean;
+    /** ISO timestamp of the most recent RPC frame the owner observed, if any. */
+    rpcLastFrameAt?: string | null;
+}
+/** Input to the deterministic recovery classifier. */
+export interface ClassifyInput {
+    observation: Observation;
+    /** Remaining retry budget per classification family. */
+    retryBudget: RetryBudget;
+    /** Whether an accepted prompt was in flight when the owner/RPC was last seen. */
+    acceptedPromptActive?: boolean;
+}
+/** Default and supplied retry budgets. */
+export interface RetryBudget {
+    reinjectPrompt: number;
+    zeroDeltaVanish: number;
+    dirtyVanishPreserve: number;
+    validationRepair: number;
+}
+/** Result of the deterministic recovery classifier. */
+export interface RecoveryDecision {
+    classification: RecoveryClassification;
+    reason: string;
+    severity: Severity;
+    /** Whether executing the recommended action requires a live owner. */
+    ownerRequired: boolean;
+    /** Receipt family that MUST be valid before the action may proceed (e.g. `vanish`). */
+    requiredReceiptFamily: ReceiptFamily | null;
+}
+/** Severity-tagged event envelope written exclusively by the owner. */
+export interface EventEnvelope<E = Record<string, unknown>> {
+    eventId: string;
+    cursor: number;
+    createdAt: string;
+    severity: Severity;
+    kind: string;
+    state: SessionStateView;
+    evidence: E;
+    nextAllowedActions: NextAllowedAction[];
+    writer: {
+        ownerId: string;
+        leaseEpoch: number;
+    };
+}
+export declare const SESSION_SCHEMA_VERSION: 1;
+export declare const DEFAULT_RETRY_BUDGET: RetryBudget;

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

@@ -1,3 +1,4 @@
+import { type CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
 export interface SkillKeywordDefinition {
     keyword: string;
     skill: GjcWorkflowSkill;
@@ -5,7 +6,7 @@ export interface SkillKeywordDefinition {
     guidance: string;
 }
 export declare const GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
-export type GjcWorkflowSkill = (typeof GJC_WORKFLOW_SKILLS)[number];
+export type GjcWorkflowSkill = CanonicalGjcWorkflowSkill;
 export declare const GJC_SKILL_KEYWORD_DEFINITIONS: readonly SkillKeywordDefinition[];
 export declare function isGjcWorkflowSkill(value: string): value is GjcWorkflowSkill;
 export declare function compareSkillKeywordMatches(a: {

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

@@ -1,5 +1,5 @@
 import type { SkillDiscoverySettings } from "../config/skill-settings-defaults";
-import type { SkillActiveEntry as CanonicalSkillActiveEntry, WorkflowHudSummary } from "../skill-state/active-state";
+import { type SkillActiveState } from "../skill-state/active-state";
 import { type GjcWorkflowSkill } from "./skill-keywords";
 export declare const GJC_STATE_DIR = ".gjc/state";
 export declare const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
@@ -14,34 +14,7 @@ export interface SkillKeywordMatch {
     skill: GjcWorkflowSkill;
     priority: number;
 }
-export interface SkillActiveEntry extends Omit<CanonicalSkillActiveEntry, "skill"> {
-    skill: GjcWorkflowSkill;
-    phase?: string;
-    active?: boolean;
-    activated_at?: string;
-    updated_at?: string;
-    session_id?: string;
-    thread_id?: string;
-    turn_id?: string;
-    hud?: WorkflowHudSummary;
-    stale?: boolean;
-}
-export interface SkillActiveState {
-    version: number;
-    active: boolean;
-    skill: GjcWorkflowSkill;
-    keyword: string;
-    phase: string;
-    activated_at: string;
-    updated_at: string;
-    source: "gjc-skill-state-hook";
-    session_id?: string;
-    thread_id?: string;
-    turn_id?: string;
-    initialized_mode?: GjcWorkflowSkill;
-    initialized_state_path?: string;
-    active_skills: SkillActiveEntry[];
-}
+export type { SkillActiveEntry, SkillActiveState } from "../skill-state/active-state";
 export interface ModeState {
     active?: boolean;
     current_phase?: string;
@@ -86,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/hook-selector.d.ts

@@ -21,6 +21,7 @@ export interface HookSelectorOptions {
      * byte-identical to the previous implementation for all consumers.
      */
     wrapFocused?: boolean;
+    scrollTitleRows?: number;
 }
 export declare class HookSelectorComponent extends Container {
     #private;

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. */