@gajae-code/coding-agent 0.4.1 → 0.4.3

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [0.4.3] - 2026-06-10
+
+### Added
+
+- Added a `busyPromptMode` setting (`steer` | `queue`, default `steer`) so a prompt submitted while the agent is busy can either steer the active turn or be queued to run after it completes, keeping steering and queued-next-turn semantics distinct. Ctrl+Enter still always queues as a follow-up (#434).
+### Fixed
+
+- Fixed a persistent `monitor` notification flood where a cancelled or evicted monitor kept delivering queued `task-notification` follow-ups (surviving process death, log deletion, and `job cancel` returning not-found). Monitors now purge their queued notifications on cancel/terminal/eviction, retain a short tombstone so post-eviction `job cancel` still purges, coalesce rapid duplicate output to the latest state, and close a cancel/trailing-flush race.
+- Fixed `ultragoal` execution leaking across concurrent independent GJC sessions. The runtime `goal-mode-request.json` is now stamped with the producing session's `GJC_SESSION_ID`, and the consumer only activates a request that belongs to the current session (another session's request is left intact instead of being consumed/deleted). Legacy unscoped requests remain consumable for single-session compatibility ([#457](https://github.com/Yeachan-Heo/gajae-code/issues/457)).
+
+## [0.4.2] - 2026-06-09
+
+### Changed
+
+- Added conservative `timeout-minutes` values to all CI workflow jobs to prevent indefinite hangs.
+
+### Fixed
+
+- Improved the grep limit-reached message to show the current limit value and suggest using `--limit` for more results.
+- Passed the active model's `maxTokens` (reserved completion budget) into the auto-compaction threshold and context-usage reserve so prompt packing reserves output for large-window models, keeping the safe input budget below the total context window (e.g. ~272K for a 400K/128K model) instead of filling the whole window ([#442](https://github.com/Yeachan-Heo/gajae-code/issues/442)).
+- Fixed a `gjc harness` recovery deadlock where a session created by `start` without `--detach` (persisted as `started` with no owner lease/endpoint) could never get a live owner: `recover` refused to spawn one because no prior endpoint existed, while `start` reported `session-already-exists`. `recover` now bootstraps a fresh owner for a never-started session (no lease, no endpoint, no owner-run evidence) without writing a misleading `vanish` receipt, reported via `bootstrappedOwner: true`. Bootstrap is independent of the vanish classifier's `ownerRequired` verdict (nothing has vanished), so a session started in a non-git workspace (git delta `unknown`) is recovered too, while a deleted worktree is still refused (#421).
+
 ## [0.4.1] - 2026-06-07
 
 ### Changed

package/dist/types/async/job-manager.d.ts

@@ -95,6 +95,25 @@ export interface AsyncJobDeliveryState {
     nextRetryAt?: number;
     pendingJobIds: string[];
 }
+export interface AsyncJobLifecycleCleanup {
+    onCancel?: (job: AsyncJob) => void;
+    onTerminal?: (job: AsyncJob) => void;
+    onEvict?: (job: AsyncJob) => void;
+    /**
+     * Idempotent residual cleanup invoked by a post-eviction tombstone purge
+     * (e.g. a late `job cancel` after the job left the registry). Kept distinct
+     * from the at-most-once lifecycle phases so a tombstone purge never has to
+     * re-invoke a phase hook. Must be safe to call repeatedly.
+     */
+    onTombstonePurge?: (job: AsyncJob) => void;
+}
+export interface MonitorTombstone {
+    jobId: string;
+    ownerId?: string;
+    status: AsyncJob["status"];
+    expiresAt: number;
+    purge: () => unknown;
+}
 export interface AsyncJobRegisterOptions {
     id?: string;
     /** Registry id of the agent that owns this job; used to scope cancelAll. */
@@ -102,6 +121,7 @@ export interface AsyncJobRegisterOptions {
     /** Structured metadata for tool-specific control surfaces. */
     metadata?: AsyncJobMetadata;
     onProgress?: (text: string, details?: Record<string, unknown>) => void | Promise<void>;
+    lifecycle?: AsyncJobLifecycleCleanup;
 }
 /**
  * Filter applied to job query/cancel APIs. With `ownerId`, results are
@@ -157,6 +177,11 @@ export declare class AsyncJobManager {
      * so cross-agent cancellation is rejected at the manager level.
      */
     cancel(id: string, filter?: AsyncJobFilter): boolean;
+    getMonitorTombstone(jobId: string, filter?: AsyncJobFilter): MonitorTombstone | undefined;
+    purgeMonitorTombstone(jobId: string, filter?: AsyncJobFilter): {
+        found: boolean;
+        status?: AsyncJob["status"];
+    };
     /** Register or replace the canonical record for a subagent. */
     registerSubagentRecord(record: SubagentRecord): void;
     getSubagentRecord(subagentId: string, filter?: AsyncJobFilter): SubagentRecord | undefined;

package/dist/types/commands/ultragoal.d.ts

@@ -3,5 +3,6 @@ export default class Ultragoal extends Command {
     static description: string;
     static strict: boolean;
     static examples: string[];
+    static delegateHelp: boolean;
     run(): Promise<void>;
 }

package/dist/types/commit/model-selection.d.ts

@@ -11,5 +11,5 @@ type CommitModelRegistry = ModelLookupRegistry & {
     getApiKey: (model: Model<Api>) => Promise<string | undefined>;
 };
 export declare function resolvePrimaryModel(override: string | undefined, settings: Settings, modelRegistry: CommitModelRegistry): Promise<ResolvedCommitModel>;
-export declare function resolveSmolModel(settings: Settings, modelRegistry: CommitModelRegistry, fallbackModel: Model<Api>, fallbackApiKey: string): Promise<ResolvedCommitModel>;
+export declare function resolveSecondaryCommitModel(settings: Settings, modelRegistry: CommitModelRegistry, fallbackModel: Model<Api>, fallbackApiKey: string): Promise<ResolvedCommitModel>;
 export {};

package/dist/types/config/model-registry.d.ts

@@ -9,7 +9,7 @@ import { type Settings } from "./settings";
 export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
 export declare const kNoAuth = "N/A";
 export declare function isAuthenticated(apiKey: string | undefined | null): apiKey is string;
-export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "designer" | "commit" | "task";
+export type ModelRole = "default";
 export interface ModelRoleInfo {
     tag?: string;
     name: string;
@@ -110,6 +110,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                 levels?: ("high" | "low" | "max" | "medium" | "minimal" | "xhigh")[] | undefined;
             } | undefined;
             input?: ("image" | "text")[] | undefined;
+            output?: ("image" | "text")[] | undefined;
             cost?: {
                 input: number;
                 output: number;
@@ -180,6 +181,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                 levels?: ("high" | "low" | "max" | "medium" | "minimal" | "xhigh")[] | undefined;
             } | undefined;
             input?: ("image" | "text")[] | undefined;
+            output?: ("image" | "text")[] | undefined;
             cost?: {
                 input?: number | undefined;
                 output?: number | undefined;

package/dist/types/config/model-resolver.d.ts

@@ -58,7 +58,7 @@ export declare function parseModelPattern(pattern: string, availableModels: Mode
     modelRegistry?: CanonicalModelRegistry;
 }): ParsedModelResult;
 /**
- * Expand a role alias like "pi/smol" to the configured model string.
+ * Expand a role alias like "pi/default" to the configured model string.
  */
 export declare function expandRoleAlias(value: string, settings?: Settings): string;
 export declare function resolveConfiguredModelPatterns(value: string | string[] | undefined, settings?: Settings): string[];
@@ -212,22 +212,4 @@ export declare function restoreModelFromSession(savedProvider: string, savedMode
     model: Model<Api> | undefined;
     fallbackMessage: string | undefined;
 }>;
-/**
- * Find a smol/fast model using the priority chain.
- * Tries exact matches first, then fuzzy matches.
- *
- * @param modelRegistry The model registry to search
- * @param savedModel Optional saved model string from settings (provider/modelId)
- * @returns The best available smol model, or undefined if none found
- */
-export declare function findSmolModel(modelRegistry: ModelLookupRegistry, savedModel?: string): Promise<Model<Api> | undefined>;
-/**
- * Find a slow/comprehensive model using the priority chain.
- * Prioritizes reasoning and OpenAI code backend models for thorough analysis.
- *
- * @param modelRegistry The model registry to search
- * @param savedModel Optional saved model string from settings (provider/modelId)
- * @returns The best available slow model, or undefined if none found
- */
-export declare function findSlowModel(modelRegistry: ModelLookupRegistry, savedModel?: string): Promise<Model<Api> | undefined>;
 export {};

package/dist/types/config/models-config-schema.d.ts

@@ -137,6 +137,10 @@ export declare const ModelOverrideSchema: z.ZodObject<{
         image: "image";
         text: "text";
     }>>>;
+    output: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        image: "image";
+        text: "text";
+    }>>>;
     cost: z.ZodOptional<z.ZodObject<{
         input: z.ZodOptional<z.ZodNumber>;
         output: z.ZodOptional<z.ZodNumber>;
@@ -393,6 +397,10 @@ export declare const ModelsConfigSchema: z.ZodObject<{
                 image: "image";
                 text: "text";
             }>>>;
+            output: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                image: "image";
+                text: "text";
+            }>>>;
             cost: z.ZodOptional<z.ZodObject<{
                 input: z.ZodNumber;
                 output: z.ZodNumber;
@@ -522,6 +530,10 @@ export declare const ModelsConfigSchema: z.ZodObject<{
                 image: "image";
                 text: "text";
             }>>>;
+            output: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                image: "image";
+                text: "text";
+            }>>>;
             cost: z.ZodOptional<z.ZodObject<{
                 input: z.ZodOptional<z.ZodNumber>;
                 output: z.ZodOptional<z.ZodNumber>;

package/dist/types/config/settings-schema.d.ts

@@ -1,6 +1,5 @@
 import { type SkillDiscoverySettings } from "./skill-settings-defaults";
 /** Unified settings schema - single source of truth for all settings.
- * Unified settings schema - single source of truth for all settings.
  *
  * Each setting is defined once here with:
  * - Type and default value
@@ -1069,6 +1068,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "When steering messages interrupt tool execution";
         };
     };
+    readonly busyPromptMode: {
+        readonly type: "enum";
+        readonly values: readonly ["steer", "queue"];
+        readonly default: "steer";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Busy Prompt Mode";
+            readonly description: "What a submitted prompt does while the agent is busy: steer (interrupt the active turn) or queue (run after the active turn completes)";
+        };
+    };
     readonly doubleEscapeAction: {
         readonly type: "enum";
         readonly values: readonly ["branch", "tree", "none"];
@@ -1144,6 +1153,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "If false, skip update check";
         };
     };
+    readonly "starReminder.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "GitHub Star Reminder";
+            readonly description: "Show the interactive GitHub star reminder when gh is authenticated";
+        };
+    };
     readonly collapseChangelog: {
         readonly type: "boolean";
         readonly default: false;
@@ -1260,11 +1278,11 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "contextPromotion.enabled": {
         readonly type: "boolean";
-        readonly default: true;
+        readonly default: false;
         readonly ui: {
             readonly tab: "context";
             readonly label: "Auto-Promote Context";
-            readonly description: "Promote to a larger-context model on context overflow instead of compacting";
+            readonly description: "Promote to a larger-context model on context overflow instead of compacting (off by default; opt in to enable)";
         };
     };
     readonly "compaction.enabled": {
@@ -3008,7 +3026,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "providers.image": {
         readonly type: "enum";
-        readonly values: readonly ["auto", "openai", "gemini", "openrouter"];
+        readonly values: readonly ["auto", "openai", "gemini", "openrouter", "antigravity"];
         readonly default: "auto";
         readonly ui: {
             readonly tab: "providers";
@@ -3030,6 +3048,10 @@ export declare const SETTINGS_SCHEMA: {
                 readonly value: "openrouter";
                 readonly label: "OpenRouter";
                 readonly description: "Requires OPENROUTER_API_KEY";
+            }, {
+                readonly value: "antigravity";
+                readonly label: "Antigravity";
+                readonly description: "Requires login with google-antigravity";
             }];
         };
     };

package/dist/types/gjc-runtime/goal-mode-request.d.ts

@@ -11,6 +11,12 @@ export interface PendingGoalModeRequest {
     objective: string;
     createdAt: string;
     goalsPath?: string;
+    /**
+     * Session id that produced this request (from GJC_SESSION_ID). When present,
+     * only the originating session may consume it, so concurrent sessions sharing
+     * the same `.gjc` project state never auto-run each other's ultragoal.
+     */
+    sessionId?: string;
 }
 export type CurrentSessionGoalModeWriteResult = {
     status: "unavailable";
@@ -32,12 +38,13 @@ export declare function writePendingGoalModeRequest(input: {
     cwd: string;
     objective: string;
     goalsPath?: string;
+    sessionId?: string | null;
 }): Promise<PendingGoalModeRequest>;
 export declare function writeCurrentSessionGoalModeState(input: {
     sessionFile?: string | null;
     objective: string;
 }): Promise<CurrentSessionGoalModeWriteResult>;
-export declare function consumePendingGoalModeRequest(cwd: string): Promise<PendingGoalModeRequest | null>;
+export declare function consumePendingGoalModeRequest(cwd: string, currentSessionId?: string | null): Promise<PendingGoalModeRequest | null>;
 export declare function buildGjcRuntimeSessionEnv(input: {
     sessionFile?: string | null;
     sessionId?: string | null;

package/dist/types/gjc-runtime/launch-tmux.d.ts

@@ -22,6 +22,7 @@ export interface TmuxLaunchContext {
     currentBranch?: string | null;
     existingBranchSessionName?: string | null;
     project?: string | null;
+    diagnosticWriter?: (message: string) => void;
 }
 export interface TmuxSpawnResult {
     exitCode: number | null;

package/dist/types/gjc-runtime/ultragoal-runtime.d.ts

@@ -99,6 +99,17 @@ export declare function createUltragoalPlan(input: {
     brief: string;
     gjcGoalMode?: UltragoalGjcGoalMode;
 }): Promise<UltragoalPlan>;
+export interface UltragoalRunCompletionState {
+    requiredGoals: UltragoalGoal[];
+    incompleteGoals: UltragoalGoal[];
+    nextGoal?: UltragoalGoal;
+    allComplete: boolean;
+    hasBlockers: boolean;
+    needsFinalAggregateReceipt: boolean;
+}
+export declare function getUltragoalRunCompletionState(plan: UltragoalPlan, options?: {
+    retryFailed?: boolean;
+}): UltragoalRunCompletionState;
 export declare function startNextUltragoalGoal(input: {
     cwd: string;
     retryFailed?: boolean;
@@ -115,6 +126,24 @@ export declare function checkpointUltragoalGoal(input: {
     gjcGoalJson?: string;
     qualityGateJson?: string;
 }): Promise<UltragoalPlan>;
+export interface UltragoalCheckpointContinuation {
+    plan: UltragoalPlan;
+    checkpointedGoal: UltragoalGoal;
+    nextGoal?: UltragoalGoal;
+    startedNext: boolean;
+    allComplete: boolean;
+    incompleteGoals: UltragoalGoal[];
+}
+export declare function checkpointAndContinueUltragoalGoal(input: {
+    cwd: string;
+    goalId: string;
+    status: UltragoalGoalStatus;
+    evidence: string;
+    gjcGoalJson?: string;
+    qualityGateJson?: string;
+    advanceNext?: boolean;
+    retryFailed?: boolean;
+}): Promise<UltragoalCheckpointContinuation>;
 export declare function addUltragoalSubgoal(input: {
     cwd: string;
     title: string;

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

@@ -1,3 +1,4 @@
+import { type ReviewVerdict } from "./types";
 export interface ValidationCommandSpec {
     name: string;
     command: string;
@@ -25,6 +26,12 @@ export interface FinalizeOptions {
     requireTests?: boolean;
     requireCommit?: boolean;
     requirePr?: boolean;
+    /** Review-only sessions produce a terminal verdict instead of implementation validation. */
+    reviewOnly?: boolean;
+    /** Operator/loop-supplied terminal review verdict (closed vocabulary). */
+    verdict?: string | null;
+    /** Bounded PR/issue reference for the review target (e.g. "PR-414"). Never resolved from the live repo. */
+    prTarget?: string | null;
     validationCommands?: ValidationCommandSpec[];
     checks: FinalizeChecks;
     clock?: () => number;
@@ -39,6 +46,7 @@ export interface FinalizeResult {
     }[];
     commitHash: string | null;
     prUrl: string | null;
+    verdict?: ReviewVerdict | null;
     issueArtifact: string | null;
     blockers: string[];
 }

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

@@ -1,4 +1,4 @@
-import type { GitDelta, ReceiptFamily, RecoveryClassification } from "./types";
+import { type GitDelta, type ReceiptFamily, type RecoveryClassification, type ReviewVerdict } from "./types";
 export interface ReceiptSubject {
     workspace: string;
     branch: string | null;
@@ -84,5 +84,20 @@ export interface CompletionEvidence {
     finalizedAt: string;
     blockers: string[];
 }
+export interface ReviewVerdictEvidence {
+    verdict: ReviewVerdict;
+    prTarget: string | null;
+    finalizedAt: string;
+    /** Bounded summary code/reference for the verdict; never raw assistant text. */
+    summaryRef: string | null;
+}
+export interface ReviewFailureEvidence {
+    /** Machine-actionable reason the review produced no terminal verdict. */
+    reason: string;
+    prTarget: string | null;
+    failedAt: string;
+    /** Routing hint for the operator/fallback path. */
+    fallback: string;
+}
 /** Classifications that MUST have a valid `vanish` receipt before the action proceeds. */
 export declare function requiresVanishBeforeAction(classification: RecoveryClassification): boolean;

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

@@ -7,8 +7,15 @@
  *
  * v1 implements the gajae-code adapter only. omx/codex/remote/auth are deferred seams.
  */
+import type { AgentWireObservedSignal } from "../modes/shared/agent-wire/event-contract";
 /** Harnesses the control plane can operate. v1 implements `gajae-code` only. */
 export type Harness = "gajae-code" | "codex" | "omx";
+/** Operating mode of a session. `implement` builds/changes code; `review` produces a read-only verdict. */
+export type SessionMode = "implement" | "review";
+/** Closed vocabulary of terminal review verdicts a review-only session may emit. */
+export type ReviewVerdict = "APPROVE_MERGE_READY" | "REQUEST_CHANGES" | "OWNER_CONFIRMATION_REQUIRED";
+export declare const REVIEW_VERDICTS: readonly ReviewVerdict[];
+export declare function isReviewVerdict(value: unknown): value is ReviewVerdict;
 /** 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. */
@@ -20,7 +27,7 @@ export type RiskKind = "normal" | "prompt-not-accepted" | "deleted-worktree" | "
 /** 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";
+export type ReceiptFamily = "vanish" | "prompt-acceptance" | "validation" | "completion" | "review-verdict" | "review-failure";
 /** 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. */
@@ -54,6 +61,8 @@ export interface PrimitiveResponse<E = Record<string, unknown>> {
 export interface SessionHandle {
     sessionId: string;
     harness: Harness;
+    /** Operating mode; absent on legacy records means `implement`. */
+    mode?: SessionMode;
     repo: string | null;
     workspace: string;
     branch: string | null;
@@ -100,8 +109,12 @@ export interface SessionState {
     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";
+/**
+ * Bounded observed-signal vocabulary surfaced by `observe` (the owner only ever
+ * emits these). Aliased to the canonical agent-wire signal vocabulary so there
+ * is a single source of truth shared with the observation core.
+ */
+export type ObservedSignal = AgentWireObservedSignal;
 export declare const OBSERVED_SIGNALS: readonly ObservedSignal[];
 /** Bounded observation surfaced by `observe` — never a raw pane/transcript dump. */
 export interface Observation {

package/dist/types/modes/acp/acp-event-mapper.d.ts

@@ -1,5 +1,6 @@
 import type { SessionNotification, SessionUpdate, ToolKind } from "@agentclientprotocol/sdk";
 import type { AgentSessionEvent } from "../../session/agent-session";
+import type { AgentWireEventPayload } from "../shared/agent-wire/event-contract";
 interface MessageProgress {
     textEmitted: boolean;
     thoughtEmitted: boolean;
@@ -17,6 +18,7 @@ interface AcpEventMapperOptions {
     cwd?: string;
 }
 export declare function mapToolKind(toolName: string): ToolKind;
+export declare function mapAgentWireEventPayloadToAcpSessionUpdates(payload: AgentWireEventPayload, sessionId: string, options?: AcpEventMapperOptions): SessionNotification[];
 export declare function mapAgentSessionEventToAcpSessionUpdates(event: AgentSessionEvent, sessionId: string, options?: AcpEventMapperOptions): SessionNotification[];
 export declare function buildToolCallStartUpdate(input: {
     toolCallId: string;

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

@@ -8,6 +8,13 @@ type PastePendingClearReason = "timeout" | "queue-limit";
 export declare class CustomEditor extends Editor {
     #private;
     onEscape?: () => void;
+    /**
+     * Optional high-priority interrupt consumer. Invoked when the interrupt key
+     * is pressed, before `onEscape`. Returning `true` consumes the keystroke.
+     * Used so a transient UI (e.g. the btw panel) stays dismissable even while
+     * another controller has temporarily installed its own `onEscape` handler.
+     */
+    onInterruptPriority?: () => boolean;
     shouldBypassAutocompleteOnEscape?: () => boolean;
     onClear?: () => void;
     onExit?: () => void;

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

@@ -0,0 +1,18 @@
+/**
+ * Canonical command-surface boundary for the agent-wire adapters.
+ *
+ * RPC and Bridge SHARE the JSONL `RpcCommand` grammar and dispatch it through
+ * the single `dispatchRpcCommand` entry in `command-dispatch.ts`. This module
+ * re-exports that command surface so the shared contract has one documented home.
+ *
+ * ACP does NOT use `RpcCommand`. It keeps its richer `@agentclientprotocol/sdk`
+ * command surface (fork/resume/elicitation/session-mode/session-model) and only
+ * shares the lower session/event layer (`AgentWireEventPayload`). ACP must never
+ * import `dispatchRpcCommand`.
+ *
+ * Event semantics are intentionally elsewhere: `event-contract.ts` owns the event
+ * types + registry and `event-observation.ts` owns the single semantic mapping.
+ */
+export type { RpcCommand, RpcResponse } from "../../rpc/rpc-types";
+export { dispatchRpcCommand, type RpcCommandDispatchContext } from "./command-dispatch";
+export { isRpcCommandType, RPC_COMMAND_TYPES, type RpcCommandType } from "./scopes";

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

@@ -0,0 +1,84 @@
+/**
+ * Canonical agent-wire contract: the single transport-neutral source of truth
+ * 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).
+ * - `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.
+ *
+ * The exhaustive `AGENT_SESSION_EVENT_TYPE_REGISTRY` lives here so that adding
+ * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
+ * conformance tests can assert fixture coverage equals the registry exactly.
+ */
+import type { AgentSessionEvent } from "../../../session/agent-session";
+/** Wire protocol version. Bump on breaking envelope/semantic changes. */
+export declare const AGENT_WIRE_PROTOCOL_VERSION: 2;
+export type AgentWireProtocolVersion = typeof AGENT_WIRE_PROTOCOL_VERSION;
+/** The discriminant of every `AgentSessionEvent` the agent can emit. */
+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.
+ */
+export interface AgentWireEventPayload {
+    event_type: AgentWireEventType;
+    event: AgentSessionEvent;
+}
+/**
+ * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
+ * the Harness `ObservedSignal` set; the Harness type aliases this in a later
+ * step so there is a single source of truth.
+ */
+export type AgentWireObservedSignal = "SessionStart" | "prompt-accepted" | "tool-call" | "test-running" | "commit-created" | "completed" | "error" | "streaming" | "idle";
+export type AgentWireSeverity = "info" | "warn" | "critical";
+/**
+ * Bounded, redacted owner observation. Evidence may include ids, names,
+ * categories, statuses, cursors, timestamps, short codes, and bounded short
+ * messages ONLY. It must never carry assistant text, message deltas, raw tool
+ * args, raw command output, raw tool result content, answers, or oversize
+ * strings.
+ */
+export interface AgentWireOwnerObservation {
+    /** Set when this observation derives from an `AgentSessionEvent`. */
+    eventType?: AgentWireEventType;
+    /** Set when this observation derives from a non-event wire frame. */
+    frameType?: string;
+    /** Owner event kind (e.g. `rpc_tool_started`). */
+    kind: string;
+    /** Bounded observed signal, or null when the frame carries no signal. */
+    signal: AgentWireObservedSignal | null;
+    /** Bounded evidence — ids/names/statuses/cursors/timestamps/short codes only. */
+    evidence: Record<string, unknown>;
+    /** Severity for the emitted event. */
+    severity: AgentWireSeverity;
+    /** Never-drop observations: must be enqueued in order, never coalesced away. */
+    semantic: boolean;
+    /** Coalescing key for high-frequency non-semantic frames; null otherwise. */
+    coalesceKey: string | null;
+}
+/** Top-level frame categories carried over any agent-wire transport. */
+export type AgentWireFrameType = "ready" | "event" | "response" | "ui_request" | "permission_request" | "host_tool_call" | "host_uri_request" | "reset" | "workflow_gate" | "error";
+/**
+ * Universal frame envelope. Every frame on every transport carries these
+ * fields so clients can order (`seq`), resume (`seq` cursor), and correlate
+ * request/response pairs (`correlation_id`).
+ */
+export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = AgentWireFrameType, TPayload = unknown> {
+    protocol_version: AgentWireProtocolVersion;
+    session_id: string;
+    /** Monotonic per-session sequence number, starting at 1. */
+    seq: number;
+    /** Unique id for this frame. */
+    frame_id: string;
+    /** Ties a request frame to its response frame, when applicable. */
+    correlation_id?: string;
+    type: TType;
+    payload: TPayload;
+}
+/** An `AgentSessionEvent` serialized into a versioned wire frame. */
+export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;

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

@@ -1,16 +1,16 @@
 import type { AgentSessionEvent } from "../../../session/agent-session";
-import { type AgentSessionEventType, type BridgeEventFrame, type BridgeFrameEnvelope, type BridgeFrameType } from "./protocol";
+import { type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
 /**
  * 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;
+export declare function agentSessionEventType(event: AgentSessionEvent): AgentWireEventType;
 /**
  * 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 {
+export declare class AgentWireFrameSequencer {
     #private;
     constructor(sessionId: string);
     /** The session id stamped onto every frame this sequencer produces. */
@@ -18,14 +18,21 @@ export declare class BridgeFrameSequencer {
     /** 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>;
+    next<TType extends AgentWireFrameType, TPayload>(type: TType, payload: TPayload, correlationId?: string): AgentWireFrameEnvelope<TType, TPayload>;
 }
-/** Serialize a single `AgentSessionEvent` into an `event` wire frame. */
-export declare function toBridgeEventFrame(event: AgentSessionEvent, sequencer: BridgeFrameSequencer): BridgeEventFrame;
+/** 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`. */
+export declare function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload;
+/** 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: BridgeFrameSequencer): import("./protocol").BridgeWorkflowGateFrame;
+export declare function toBridgeWorkflowGateFrame(gate: import("../../rpc/rpc-types").RpcWorkflowGate, sequencer: AgentWireFrameSequencer): import("./protocol").BridgeWorkflowGateFrame;