@gajae-code/coding-agent 0.10.1 → 0.11.0

package/dist/types/modes/acp/permission-mode.d.ts

@@ -0,0 +1,4 @@
+import type { ClientCapabilities } from "@agentclientprotocol/sdk";
+export type AcpPermissionMode = "auto" | "prompt" | "always-allow";
+/** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
+export declare function resolveAcpPermissionMode(clientCapabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): AcpPermissionMode;

package/dist/types/modes/acp/startup-options.d.ts

@@ -0,0 +1,6 @@
+/** Startup settings that ACP can apply through the canonical SDK control surface. */
+export interface AcpStartupOptions {
+    modelId?: string;
+    modelPreset?: string;
+    thinkingLevel?: string;
+}

package/dist/types/modes/components/agent-dashboard.d.ts

@@ -1,11 +1,14 @@
 import { Container } from "@gajae-code/tui";
 import type { ModelRegistry } from "../../config/model-registry";
+import { type ModelSelectorValue } from "../../config/model-selector-value";
 import { Settings } from "../../config/settings";
 interface AgentDashboardModelContext {
     modelRegistry?: ModelRegistry;
     activeModelPattern?: string;
     defaultModelPattern?: string;
 }
+export declare function resolveAgentCreationModel(modelPatterns: string[], modelRegistry: ModelRegistry, settings: Settings | undefined): import("@gajae-code/ai").Model<import("@gajae-code/ai").Api>;
+export declare function updateAgentModelOverride(overrides: Record<string, ModelSelectorValue>, agentName: string, rawValue: string): Record<string, ModelSelectorValue>;
 export declare class AgentDashboard extends Container {
     #private;
     private readonly cwd;

package/dist/types/modes/components/gajae-pet-widget.d.ts

@@ -53,6 +53,7 @@ export declare class GajaePetWidget {
      *  eye-roll it fires the signature burst once (RedGajae flex, BlueGajae para-para
      *  then sob) so the selector demos the animation instead of waiting the random gap. */
     previewMode(mode: PetMode): void;
+    commitPreviewMode(mode: PetMode): void;
     dispose(): void;
     /** Re-mount the composer editor (framed when a skin is active) after an overlay. */
     remountComposer(): void;

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

@@ -47,6 +47,7 @@ export declare class ModelSelectorComponent extends Container {
         isCurrentModelFastModeActive?: () => boolean;
         currentThinkingLevel?: ThinkingLevel;
         activeModelProfile?: string;
+        configuredDefaultChain?: readonly string[];
     });
     refreshRoleAssignments(options?: {
         currentModel?: Model;

package/dist/types/modes/components/notifications-settings-editor.d.ts

@@ -0,0 +1,135 @@
+import { type Component, type Focusable, type SecretValue } from "@gajae-code/tui";
+import type { CasReceipt } from "../../config/atomic-yaml-patch";
+import type { BlockedTelegramRestoreResult, ProposedTelegramIdentity, TelegramDaemonReconnectOutcome } from "../../sdk/bus/notification-orchestration";
+import type { NotificationHealthReport, NotificationRecoveryReport, NotificationStatusReport, NotificationTestResult } from "../../sdk/bus/notification-service";
+import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../../sdk/bus/session-control";
+/** Safe scalar notification preferences. Credentials and destination IDs are deliberately absent. */
+export interface NotificationsEditorPreferences {
+    redact: boolean;
+    verbosity: "lean" | "verbose";
+    sessionScope: "all" | "primary";
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+}
+/** Secret-safe snapshot used to render the Notifications tab. */
+export interface NotificationsEditorState {
+    status: NotificationStatusReport;
+    session: NotificationSessionStatus;
+    preferences: NotificationsEditorPreferences;
+    health?: NotificationHealthReport;
+}
+/**
+ * A one-way setup value accepted from the masked input. The operation adapter
+ * consumes the secret and returns a safe-to-render prepared draft.
+ */
+export interface NotificationsEditorSetupInput {
+    token: SecretValue;
+    /** Optional: omit to use daemon-aware private-chat discovery when polling is safe. */
+    chatId?: string;
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+}
+/**
+ * Secret-safe setup draft. The adapter may retain its private credential while
+ * this object is live, but no raw token is exposed through this contract.
+ */
+export interface PreparedTelegramConfiguration {
+    chatId: string;
+    tokenMask: string;
+    tokenFingerprint?: string;
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+}
+export interface NotificationsPreflightResult {
+    status: "ready" | "aborted" | "cancelled" | "error";
+    identity: ProposedTelegramIdentity;
+    message: string;
+    pairingSource?: "discovered" | "provided" | "reused";
+    draft?: PreparedTelegramConfiguration;
+}
+/** A successful configuration save always carries an opaque CAS receipt. */
+export type NotificationsConfigureCommitResult = {
+    status: "saved";
+    receipt: CasReceipt;
+    message: string;
+} | {
+    status: "blocked_identity";
+    receipt: CasReceipt;
+    message: string;
+    restore(): Promise<BlockedTelegramRestoreResult>;
+    retainCommitted(): void;
+};
+export interface NotificationsMutationResult {
+    message: string;
+    receipt?: CasReceipt;
+}
+export type NotificationsSaveInactiveResult = {
+    status: "saved_inactive";
+    receipt: CasReceipt;
+    message: string;
+} | {
+    status: "unavailable";
+    guidance: string;
+};
+/**
+ * Controller-injected boundary for the direct Notifications editor.
+ *
+ * The component only renders this contract and sends user intent through it:
+ * it never reads Settings, starts a daemon, or calls notification services.
+ */
+export interface NotificationsEditorOperations {
+    /** Combines a buildNotificationStatusReport-shaped status snapshot with the current session-control query. */
+    loadState(): Promise<NotificationsEditorState>;
+    /** Performs offline health refreshes and a non-cancellable reachability probe when requested. */
+    refreshHealth(input: {
+        probe: boolean;
+        signal?: AbortSignal;
+    }): Promise<NotificationHealthReport>;
+    sendTest(): Promise<NotificationTestResult>;
+    recover(): Promise<NotificationRecoveryReport>;
+    reconnect(): Promise<TelegramDaemonReconnectOutcome>;
+    /** Validates/discovers a Telegram destination and returns a secret-safe prepared draft. */
+    preflightProposedIdentity(input: NotificationsEditorSetupInput, signal: AbortSignal): Promise<NotificationsPreflightResult>;
+    /** Atomically persists a prepared Telegram configuration and returns its CAS-backed receipt. */
+    commitConfigure(draft: PreparedTelegramConfiguration): Promise<NotificationsConfigureCommitResult>;
+    /** Stores a prepared Telegram configuration inactive when the mixed-adapter rule permits it. */
+    saveInactive(draft: PreparedTelegramConfiguration): Promise<NotificationsSaveInactiveResult>;
+    /** Clears adapter-local ephemeral credential material for a prepared setup draft. Idempotent. */
+    discardConfigureDraft(draft: PreparedTelegramConfiguration): void;
+    /** Enables globally without requesting or exposing a credential. */
+    enableGlobally(): Promise<NotificationsMutationResult>;
+    disableGlobally(): Promise<NotificationsMutationResult>;
+    /** Removes only Telegram configuration; the adapter preserves Discord/Slack when configured. */
+    removeTelegram(): Promise<NotificationsMutationResult & {
+        globallyDisabled?: boolean;
+    }>;
+    setSessionLocal(enabled: boolean): Promise<NotificationSessionReconcileResult>;
+    /** Atomically persists the scalar preference draft. */
+    commitPreferences(preferences: NotificationsEditorPreferences): Promise<NotificationsMutationResult>;
+    /** Reconciles the current session after durable global configuration changes. */
+    reconcileCurrentSession(): Promise<NotificationSessionReconcileResult>;
+}
+export interface NotificationsSettingsEditorCallbacks {
+    onCancel?: () => void;
+}
+type EditorMode = "home" | "provider-selection" | "chat-entry" | "token-entry" | "pairing" | "review" | "preferences" | "confirmation";
+/**
+ * Direct tab content for notification setup and operations. It is deliberately
+ * independent of Settings and notification services; WI7b injects the adapter.
+ */
+export declare class NotificationsSettingsEditorComponent implements Component, Focusable {
+    #private;
+    private readonly operations;
+    private readonly callbacks;
+    focused: boolean;
+    constructor(operations: NotificationsEditorOperations, callbacks?: NotificationsSettingsEditorCallbacks);
+    /** True while a guarded operation or blocked restore/retain decision owns the editor. */
+    get navigationLocked(): boolean;
+    /** Current state is exposed for selector lifecycle coordination and focused tests. */
+    get mode(): EditorMode;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+}
+export {};

package/dist/types/modes/components/pet-capability.d.ts

@@ -0,0 +1,37 @@
+import { type SelectItem } from "@gajae-code/tui";
+export type PetPixelProtocol = "sixel" | "kitty";
+export declare const PET_UNAVAILABLE_DESCRIPTION = "Unavailable: requires compatible Kitty or Sixel overlay rendering";
+export declare const PET_SAVED_UNAVAILABLE_DESCRIPTION = "Saved, unavailable \u2014 requires compatible Kitty or Sixel overlay rendering";
+export declare const PET_UNAVAILABLE_WARNING = "\u26A0 Pets aren\u2019t available in this terminal. Its image support isn\u2019t compatible with Gajae Pet\u2019s overlay rendering yet. Try Kitty, Ghostty, WezTerm, or a terminal with compatible Sixel support.";
+export declare function getPetUnavailableWarning(env?: NodeJS.ProcessEnv): string;
+export declare function getPetPixelProtocol(): PetPixelProtocol | null;
+export declare function isPetAvailable(): boolean;
+export declare function createPetSelectItems(options: ReadonlyArray<SelectItem>, currentValue: string, available: boolean): SelectItem[];
+/**
+ * Grace period before declaring the terminal pet-incapable at startup. The
+ * asynchronous Sixel capability probe starts inside `TUI.start()` and answers
+ * within its own 250 ms deadline; this margin covers probe scheduling so a
+ * supported terminal is never told it is incompatible while the probe is
+ * still in flight.
+ */
+export declare const PET_CAPABILITY_SETTLE_MS = 1000;
+/**
+ * Whether the asynchronous startup Sixel capability probe may still enable
+ * graphics for this session, meaning current unavailability is not final.
+ */
+export declare function isPetCapabilityProbePending(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
+/**
+ * Deliver the pet-unavailable startup warning only once the capability
+ * question is settled. With no probe pending, unavailability is final and
+ * `onUnavailable` fires immediately. While a probe may still enable
+ * graphics, the warning is deferred: a protocol-change event cancels it (the
+ * saved pet re-applies through the existing subscription), and only the
+ * settle deadline passing with the terminal still unavailable emits it.
+ * Returns a disposer that cancels the pending decision.
+ */
+export declare function warnWhenPetCapabilitySettled(options: {
+    probePending: boolean;
+    isAvailable?: () => boolean;
+    onUnavailable: () => void;
+    settleMs?: number;
+}): () => void;

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

@@ -6,6 +6,6 @@ import type { PetMode } from "./gajae-pet-widget";
  */
 export declare class PetSelectorComponent extends Container {
     #private;
-    constructor(current: PetMode, onSelect: (mode: PetMode) => void, onCancel: () => void, onPreview: (mode: PetMode) => void);
+    constructor(current: PetMode, onSelect: (mode: PetMode) => void, onCancel: () => void, onPreview: (mode: PetMode) => void, available: boolean);
     getSelectList(): SelectList;
 }

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

@@ -1,9 +1,9 @@
 import { type ThinkingLevel as ThinkingLevelValue } from "@gajae-code/agent-core";
 import type { Effort } from "@gajae-code/ai";
-import { Container, SettingsList } from "@gajae-code/tui";
+import { type Component, Container } from "@gajae-code/tui";
 import { type SettingPath } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
-import { PluginSettingsComponent } from "./plugin-settings";
+import { type NotificationsEditorOperations } from "./notifications-settings-editor";
 import type { StatusLineSegmentOptions } from "./status-line";
 /**
  * Dynamic context for settings that need runtime data.
@@ -20,6 +20,8 @@ export interface SettingsRuntimeContext {
     availableModelProfiles: string[];
     /** Working directory for plugins tab */
     cwd: string;
+    /** Whether this terminal can render the pet overlay. */
+    petAvailable?: boolean;
 }
 /** Status line settings subset for preview */
 export interface StatusLinePreviewSettings {
@@ -41,6 +43,13 @@ export interface SettingsCallbacks {
     onThemePreviewCancel?: (theme: string) => void | Promise<void>;
     /** Called to live-preview the gajae pet skin while browsing the pet setting. */
     onPetPreview?: (mode: string) => void;
+    /**
+     * Commit a pet mode through the shared result-returning policy. The policy
+     * rechecks capability immediately before mutation and owns persistence, so
+     * the settings surface never persists `pet.mode` ahead of acceptance.
+     * Returns whether the commit was accepted.
+     */
+    onPetCommit?: (mode: string) => boolean;
     /** Called for status line preview while configuring */
     onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
     /** Get current rendered status line for inline preview */
@@ -58,7 +67,9 @@ export declare class SettingsSelectorComponent extends Container {
     #private;
     private readonly context;
     private readonly callbacks;
-    constructor(context: SettingsRuntimeContext, callbacks: SettingsCallbacks);
-    getFocusComponent(): SettingsList | PluginSettingsComponent;
+    private readonly notificationsOperations?;
+    constructor(context: SettingsRuntimeContext, callbacks: SettingsCallbacks, notificationsOperations?: NotificationsEditorOperations | undefined);
+    getFocusComponent(): Component;
+    dispose(): void;
     handleInput(data: string): void;
 }

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

@@ -5,7 +5,7 @@ export interface RecentSession {
 }
 export interface LspServerInfo {
     name: string;
-    status: "ready" | "error" | "connecting";
+    status: "idle" | "ready" | "error" | "connecting";
     fileTypes: string[];
 }
 export type WelcomeLogoMode = "unicode" | "square" | "ascii";

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

@@ -2,6 +2,13 @@ import type { Component } from "@gajae-code/tui";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
 import { type Settings } from "../../config/settings";
 import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/types";
+import { getNotificationConfig, maskToken } from "../../sdk/bus/config";
+import { proposedTelegramIdentity, reconcileCommittedTelegramConfiguration, removeTelegramConfiguration, saveTelegramInactive } from "../../sdk/bus/notification-orchestration";
+import { buildNotificationStatusReport, checkNotificationHealth, recoverNotifications, sanitizeDiagnostic, sendNotificationTest } from "../../sdk/bus/notification-service";
+import { ensureTelegramDaemonRunningDetailed, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
+import { runTelegramSetup } from "../../sdk/bus/telegram-setup";
+import { type CredentialAutoImportStateStore } from "../../setup/credential-auto-import";
+import type { NotificationsEditorOperations } from "../components/notifications-settings-editor";
 import type { StatusLineSettings } from "../components/status-line";
 import type { JobsObserver } from "../jobs-observer";
 import type { SessionObserverRegistry } from "../session-observer-registry";
@@ -11,10 +18,37 @@ import type { SessionObserverRegistry } from "../session-observer-registry";
  * previewed row count (and every other field) can never drift out of sync.
  */
 export declare function buildStatusLineSettings(settingsInstance: Settings): StatusLineSettings;
+export interface NotificationsEditorAdapterContext {
+    settings: Settings;
+    session: Pick<InteractiveModeContext["session"], "notificationSessionController">;
+    sessionManager: Pick<InteractiveModeContext["sessionManager"], "getCwd" | "getSessionId">;
+    notifyConfigChanged?: () => Promise<void> | void;
+}
+export interface NotificationsEditorOperationDependencies {
+    getNotificationConfig: typeof getNotificationConfig;
+    maskToken: typeof maskToken;
+    buildNotificationStatusReport: typeof buildNotificationStatusReport;
+    checkNotificationHealth: typeof checkNotificationHealth;
+    sendNotificationTest: typeof sendNotificationTest;
+    recoverNotifications: typeof recoverNotifications;
+    sanitizeDiagnostic: typeof sanitizeDiagnostic;
+    ensureTelegramDaemonRunningDetailed: typeof ensureTelegramDaemonRunningDetailed;
+    runTelegramSetup: typeof runTelegramSetup;
+    proposedTelegramIdentity: typeof proposedTelegramIdentity;
+    reconcileCommittedTelegramConfiguration: typeof reconcileCommittedTelegramConfiguration;
+    saveTelegramInactive: typeof saveTelegramInactive;
+    removeTelegramConfiguration: typeof removeTelegramConfiguration;
+    unregisterNotificationRoot: typeof unregisterNotificationRoot;
+}
+/**
+ * Concrete service adapter for the direct Notifications settings tab. Secrets remain in this closure's
+ * WeakMap and are never exposed through the editor's safe draft contract.
+ */
+export declare function createNotificationsEditorOperations(ctx: NotificationsEditorAdapterContext, overrides?: Partial<NotificationsEditorOperationDependencies>): NotificationsEditorOperations;
 export declare class SelectorController {
     #private;
     private ctx;
-    constructor(ctx: InteractiveModeContext);
+    constructor(ctx: InteractiveModeContext, credentialAutoImportStateStore?: CredentialAutoImportStateStore);
     /**
      * Shows a selector component in place of the editor.
      * @param create Factory that receives a `done` callback and returns the component and focus target

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

@@ -2,9 +2,5 @@
  * 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";
-export { runRpcMode } from "./rpc/rpc-mode";
-export type { RpcCommand, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostToolDefinition, RpcHostToolResult, RpcHostToolUpdate, RpcResponse, RpcSessionState, } from "./rpc/rpc-types";

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

@@ -9,6 +9,7 @@ import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetConte
 import type { CompactOptions } from "../extensibility/extensions/types";
 import { type Skill } from "../extensibility/skills";
 import { type PlanApprovalDetails } from "../plan-mode/approved-plan";
+import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../sdk/bus/session-control";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
@@ -119,6 +120,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     readonly lspServers: LspStartupServerInfo[] | undefined;
     mcpManager?: import("../runtime-mcp").MCPManager;
     constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: import("../runtime-mcp").MCPManager, eventBus?: EventBus);
+    getCurrentSessionNotificationStatus(): NotificationSessionStatus | undefined;
+    setCurrentSessionNotificationsEnabled(enabled: boolean): Promise<NotificationSessionReconcileResult | undefined>;
     init(): Promise<void>;
     /** Reload slash commands and autocomplete for the provided working directory. */
     refreshSlashCommandState(cwd?: string): Promise<void>;
@@ -139,8 +142,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     updateEditorChrome(): void;
     updateEditorBorderColor(): void;
     updateEditorTopBorder(): void;
-    setPetMode(mode: PetMode): void;
+    setPetMode(mode: PetMode): boolean;
     previewPetMode(mode: PetMode): void;
+    commitPetPreviewMode(mode: PetMode): boolean;
     restoreComposer(): void;
     rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;
     /** Apply any deferred model switch after the current stream ends. */

package/dist/types/modes/runtime-init.d.ts

@@ -7,9 +7,9 @@ export interface InitializeExtensionsOptions {
     reportSendError: (action: ExtensionSendAction, error: Error) => void;
     /** Reports a runtime error surfaced through {@link ExtensionRunner.onError}. */
     reportRuntimeError: (error: ExtensionError) => void;
-    /** Optional shutdown hook (rpc mode signals its loop; print mode is a no-op). */
+    /** Optional shutdown hook for caller-specific lifecycle signaling. */
     onShutdown?: () => void;
-    /** Optional UI context (rpc supplies one; print runs headless). */
+    /** Optional interactive UI context; omitted for headless callers. */
     uiContext?: ExtensionUIContext;
 }
 /**

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

@@ -7,16 +7,13 @@
  *  - ultragoal execution sign-off -> `workflow_gate` { kind: "execution" } whose
  *    answer is approve / decline (+ optional reason).
  *
- * Gates remain mandatory; the external agent substitutes for the human at the
- * answer boundary only. Declining / requesting changes is honored and is NEVER
- * silently treated as approval.
+ * Gates remain mandatory; the remote SDK client answers at the gate boundary.
+ * Declining / requesting changes is honored and is NEVER silently treated as approval.
  *
- * This is the pure mapping primitive; routing ralplan/ultragoal through it when
- * an unattended controller + gate broker are attached is wired with the transport
- * in #321 and exercised end-to-end by #323.
+ * This is the pure mapping primitive used by SDK-native workflow gate emitters.
  */
-import type { RpcWorkflowGateContext } from "../../rpc/rpc-types";
 import type { OpenGateInput } from "./workflow-gate-broker";
+import type { WorkflowGateContext } from "./workflow-gate-types";
 export type ApprovalDecision = "approve" | "request-changes" | "reject";
 export type ExecutionDecision = "approve" | "decline";
 export interface ApprovalGateAnswer {
@@ -42,9 +39,9 @@ export declare class ApprovalGateError extends Error {
     constructor(code: "invalid_answer_shape" | "unknown_decision" | "missing_comments", message: string);
 }
 /** Build the ralplan `pending approval` -> `workflow_gate { kind: "approval" }` open-input. */
-export declare function approvalGate(context?: RpcWorkflowGateContext): OpenGateInput;
+export declare function approvalGate(context?: WorkflowGateContext): OpenGateInput;
 /** Build the ultragoal execution sign-off -> `workflow_gate { kind: "execution" }` open-input. */
-export declare function executionGate(context?: RpcWorkflowGateContext): OpenGateInput;
+export declare function executionGate(context?: WorkflowGateContext): OpenGateInput;
 /**
  * Decode a ralplan approval answer. `request-changes` requires comments and is
  * NEVER treated as approval; only an explicit `approve` advances.

package/dist/types/modes/shared/agent-wire/deep-interview-gate.d.ts

@@ -7,12 +7,10 @@
  * back into the exact QuestionResult shape the human path produces, so ambiguity
  * scoring/state updates proceed identically whether a human or an agent answers.
  *
- * This is the pure mapping primitive. Routing the ask tool through it (instead of
- * the interactive select/editor UI) when an unattended controller + gate broker
- * are attached is wired with the transport in #321 and exercised by #323.
+ * This is the pure mapping primitive used by SDK-native workflow gate emitters.
  */
-import type { RpcWorkflowGateKind, RpcWorkflowStage } from "../../rpc/rpc-types";
 import type { OpenGateInput } from "./workflow-gate-broker";
+import type { WorkflowGateKind, WorkflowStage } from "./workflow-gate-types";
 /** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
 export declare const GATE_OTHER_OPTION = "Other (type your own)";
 /** Optional structured deep-interview round metadata supplied by the agent. */
@@ -24,8 +22,8 @@ export interface AskGateDeepInterviewState {
     ambiguity: number;
 }
 export interface AskGateWorkflowGateMeta {
-    stage: RpcWorkflowStage;
-    kind: RpcWorkflowGateKind;
+    stage: WorkflowStage;
+    kind: WorkflowGateKind;
 }
 export interface AskGateQuestion {
     id: string;

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

@@ -3,8 +3,8 @@
  * for AgentSession events and bounded owner observations.
  *
  * Two distinct consumer-facing shapes, deliberately NOT collapsed into one:
- * - `AgentWireEventPayload`: rich, full `AgentSessionEvent` for renderers
- *   (ACP SDK notifications, RPC/Bridge event frames).
+ * - `AgentWireEventPayload`: rich, full `AgentSessionEvent` for event
+ *   consumers on any agent-wire transport.
  * - `AgentWireOwnerObservation`: bounded/redacted owner evidence for control
  *   planes (Harness). Never carries assistant text, message deltas, raw tool
  *   args, raw command output, raw tool results, answers, or oversize strings.
@@ -23,8 +23,8 @@ export type AgentWireEventType = AgentSessionEvent["type"];
 /** Every agent-session event type, derived from the exhaustive registry. */
 export declare const AGENT_WIRE_EVENT_TYPES: readonly AgentWireEventType[];
 /**
- * Rich event payload. Carries the full `AgentSessionEvent` so renderers (ACP,
- * RPC, Bridge) can present message content, tool args/results, todo state, etc.
+ * Rich event payload. Carries the full `AgentSessionEvent` so event consumers
+ * can present message content, tool args/results, todo state, and related data.
  */
 export interface AgentWireEventPayload {
     event_type: AgentWireEventType;
@@ -35,7 +35,7 @@ export type AgentWireCompactAssistantMessageEvent = AssistantMessageEvent extend
 } ? Omit<TEvent, "partial" | "message" | "error"> : never : never;
 export interface AgentWireCompactMessageUpdatePayload {
     event_type: "message_update";
-    /** Compact RPC opt-in payload: delta-only update plus minimal routing metadata. */
+    /** Compact opt-in payload: delta-only update plus minimal routing metadata. */
     compact: true;
     message_id: string | null;
     content_index: number | null;
@@ -66,7 +66,7 @@ export interface AgentWireOwnerObservation {
     eventType?: AgentWireEventType;
     /** Set when this observation derives from a non-event wire frame. */
     frameType?: string;
-    /** Owner event kind (e.g. `rpc_tool_started`). */
+    /** Owner event kind (for example, a tool-started observation). */
     kind: string;
     /** Bounded observed signal, or null when the frame carries no signal. */
     signal: AgentWireObservedSignal | null;

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

@@ -21,9 +21,6 @@ export declare class AgentWireFrameSequencer {
     /** Build the next envelope of the given type with a fresh seq + frame id. */
     next<TType extends AgentWireFrameType, TPayload>(type: TType, payload: TPayload, correlationId?: string): AgentWireFrameEnvelope<TType, TPayload>;
 }
-/** Back-compat alias for {@link AgentWireFrameSequencer}. */
-export declare const BridgeFrameSequencer: typeof AgentWireFrameSequencer;
-export type BridgeFrameSequencer = AgentWireFrameSequencer;
 /** Serialize a single `AgentSessionEvent` into a canonical `event` wire frame. */
 export declare function toAgentWireEventFrame(event: AgentSessionEvent, sequencer: AgentWireFrameSequencer): AgentWireEventFrame;
 /** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
@@ -35,13 +32,13 @@ export interface AgentWireCompactMessageUpdateOptions {
     checkpointInterval?: number;
 }
 /**
- * Stateful compact event serializer for opt-in RPC clients.
+ * Stateful compact event serializer for opt-in wire clients (e.g. the SDK).
  *
  * Only `message_update` changes shape: it carries the immutable provider delta
  * plus message/content identifiers, with periodic full-message checkpoints that
  * are cloned synchronously before the caller returns to the event loop. All other
- * event variants remain canonical full event frames so legacy bridge/RPC behavior
- * and terminal `message_end` reconstruction are unchanged.
+ * event variants remain canonical full event frames so downstream consumers and
+ * terminal `message_end` reconstruction are unchanged.
  */
 export declare class AgentWireCompactEventEncoder {
     #private;
@@ -49,12 +46,10 @@ export declare class AgentWireCompactEventEncoder {
     frame(event: AgentSessionEvent): AgentWireCompactEventFrame;
 }
 export declare function toAgentWireCompactEventFrame(event: AgentSessionEvent, encoder: AgentWireCompactEventEncoder): AgentWireCompactEventFrame;
-/** Back-compat alias for {@link toAgentWireEventFrame}. */
-export declare const toBridgeEventFrame: typeof toAgentWireEventFrame;
 /**
  * Serialize a `workflow_gate` event into a sequenced wire frame (#321). The
  * gate_id is stamped as the correlation id so the answer (posted to the
  * ui-responses endpoint) can be matched, and the monotonic `seq` gives replay
  * while `frame_id` + gate_id give idempotency.
  */
-export declare function toBridgeWorkflowGateFrame(gate: import("../../rpc/rpc-types").RpcWorkflowGate, sequencer: AgentWireFrameSequencer): import("./protocol").BridgeWorkflowGateFrame;
+export declare function toAgentWireWorkflowGateFrame(gate: import("./workflow-gate-types").WorkflowGate, sequencer: AgentWireFrameSequencer): AgentWireFrameEnvelope<"workflow_gate", import("./workflow-gate-types").WorkflowGate>;

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

@@ -34,4 +34,4 @@ export declare function observeAgentWireEventPayload(payload: AgentWireEventPayl
  * frames delegate to {@link observeAgentWireEventPayload}; non-event frames are
  * mapped here so owners never re-parse protocol semantics privately.
  */
-export declare function observeRpcOutboundFrame(frame: Record<string, unknown>): AgentWireOwnerObservation | null;
+export declare function observeAgentWireFrame(frame: Record<string, unknown>): AgentWireOwnerObservation | null;