@gajae-code/coding-agent 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -2,15 +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.
+- Made coordinator MCP turn waiting state-backed by durable turn/session files, with runtime session sidecar updates for running/completed/error states and Meeseeks guidance that avoids fixed sleep/capture-pane loops.
 
 ### Fixed
 
+- Failed stale coordinator turns quickly when their recorded tmux session is gone, clearing active-turn state instead of burning await timeouts.
 - 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

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

@@ -1,4 +1,4 @@
-import type { AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource } from "../task/types";
 export interface AsyncJob {
     id: string;
     type: "bash" | "task";
@@ -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;
@@ -164,6 +189,24 @@ export declare class AsyncJobManager {
     registerLiveHandle(subagentId: string, handle: SubagentLiveHandle): void;
     getLiveHandle(subagentId: string): SubagentLiveHandle | undefined;
     removeLiveHandle(subagentId: string): void;
+    /**
+     * Retain the latest live `AgentProgress` for a subagent (deep-cloned so later
+     * mutation of the live object cannot corrupt retained state). Read by the
+     * `subagent` await panel; cleared on terminal/cancel/purge/dispose.
+     *
+     * Ignored for ids without a canonical `SubagentRecord` (e.g. foreground/inline
+     * task runs that share the executor path) so the map only holds detached
+     * subagent progress and never accumulates untracked foreground task state.
+     */
+    recordSubagentProgress(subagentId: string, progress: AgentProgress): void;
+    getSubagentProgress(subagentId: string): AgentProgress | undefined;
+    /**
+     * True only when a live, in-session progress producer exists for this id: a
+     * canonical registered record with a live handle or an in-memory running job.
+     * False for `SubagentTool` backward-compat job synthesis and resumed-from-disk
+     * records, which have no live producer to stream from.
+     */
+    hasLiveSubagent(subagentId: string, filter?: AsyncJobFilter): boolean;
     /** Install the TaskTool-owned resume runner. Returns the new job id, or undefined on failure. */
     setResumeRunner(runner: (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined): void;
     registerResumeDescriptor(descriptor: ResumeDescriptor): void;

package/dist/types/cli/setup-cli.d.ts

@@ -1,4 +1,4 @@
-export type SetupComponent = "defaults" | "hooks" | "provider" | "python" | "stt";
+export type SetupComponent = "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
 export interface SetupCommandArgs {
     component: SetupComponent;
     flags: {
@@ -12,6 +12,19 @@ export interface SetupCommandArgs {
         apiKeyEnv?: string;
         model?: string[];
         modelsPath?: string;
+        smoke?: boolean;
+        install?: boolean;
+        root?: string[];
+        repo?: string;
+        profile?: string;
+        sessionCommand?: string;
+        stateRoot?: string;
+        mutation?: string[];
+        artifactByteCap?: string;
+        serverKey?: string;
+        gjcCommand?: string;
+        target?: string;
+        profileDir?: string;
     };
 }
 /**

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

@@ -0,0 +1,19 @@
+import { Command } from "@gajae-code/utils/cli";
+export default class Coordinator extends Command {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        action: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+    };
+    static flags: {
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+    };
+    run(): Promise<void>;
+}

package/dist/types/commands/mcp-serve.d.ts

@@ -0,0 +1,24 @@
+import { Command } from "@gajae-code/utils/cli";
+export declare function validateMcpServeSubcommandForTest(server: string | undefined): void;
+export default class McpServe extends Command {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        server: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+    };
+    static flags: {
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+        check: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+            default: boolean;
+        };
+    };
+    run(): Promise<void>;
+}

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

@@ -24,6 +24,47 @@ export default class Setup extends Command {
         json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        smoke: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        install: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        root: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
+        repo: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        profile: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "session-command": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "state-root": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        mutation: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
+        "artifact-byte-cap": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "server-key": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "gjc-command": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        target: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "profile-dir": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         preset: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

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

@@ -1068,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"];
@@ -3016,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";
@@ -3038,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/coordinator/contract.d.ts

@@ -0,0 +1,4 @@
+export declare const COORDINATOR_MCP_PROTOCOL_VERSION = "2024-11-05";
+export declare const COORDINATOR_MCP_SERVER_NAME = "gjc-coordinator-mcp";
+export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["gjc_coordinator_list_sessions", "gjc_coordinator_read_status", "gjc_coordinator_read_tail", "gjc_coordinator_list_questions", "gjc_coordinator_list_artifacts", "gjc_coordinator_read_artifact", "gjc_coordinator_read_coordination_status", "gjc_coordinator_start_session", "gjc_coordinator_send_prompt", "gjc_coordinator_submit_question_answer", "gjc_coordinator_read_turn", "gjc_coordinator_await_turn", "gjc_coordinator_report_status"];
+export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/dist/types/coordinator-mcp/policy.d.ts

@@ -0,0 +1,24 @@
+export type CoordinatorMutationClass = "sessions" | "questions" | "reports";
+export interface CoordinatorNamespace {
+    profile: string | null;
+    repo: string | null;
+}
+export interface CoordinatorMcpConfig {
+    allowedRoots: string[];
+    mutationClasses: Set<CoordinatorMutationClass>;
+    artifactByteCap: number;
+    namespace: CoordinatorNamespace;
+    stateRoot: string;
+    sessionCommand: string | null;
+}
+export interface CoordinatorMutationRequest {
+    allow_mutation?: boolean;
+}
+export declare function buildCoordinatorMcpConfig(env?: NodeJS.ProcessEnv): CoordinatorMcpConfig;
+export declare function assertCoordinatorWorkdir(config: CoordinatorMcpConfig, cwd: unknown): Promise<string>;
+export declare function assertCoordinatorArtifactPath(config: CoordinatorMcpConfig, artifactPath: unknown): Promise<{
+    path: string;
+    byteCap: number;
+}>;
+export declare function requireCoordinatorMutation(config: CoordinatorMcpConfig, mutationClass: CoordinatorMutationClass, request: CoordinatorMutationRequest): void;
+export declare function coordinatorNamespacePath(config: CoordinatorMcpConfig): string;

package/dist/types/coordinator-mcp/safety.d.ts

@@ -0,0 +1,26 @@
+import { type CoordinatorMutationClass } from "./policy";
+export declare const COORDINATOR_MUTATION_CLASSES: readonly ["sessions", "questions", "reports"];
+export type { CoordinatorMutationClass };
+export interface CoordinatorSafetyConfig {
+    allowedRoots: string[];
+    artifactMaxBytes: number;
+    enabledMutationClasses: Set<CoordinatorMutationClass>;
+    repo?: string;
+    profile?: string;
+}
+export interface CoordinatorSafetyPolicy {
+    config: CoordinatorSafetyConfig;
+    resolveWorkdir(input: unknown): Promise<string>;
+    resolveArtifactPath(input: unknown): Promise<string>;
+    assertMutationAllowed(mutationClass: CoordinatorMutationClass, args: Record<string, unknown>): {
+        ok: true;
+    } | CoordinatorFailure;
+}
+export interface CoordinatorFailure {
+    ok: false;
+    reason: string;
+    [key: string]: unknown;
+}
+export declare function createCoordinatorSafetyPolicy(options?: {
+    env?: NodeJS.ProcessEnv;
+}): Promise<CoordinatorSafetyPolicy>;

package/dist/types/coordinator-mcp/server.d.ts

@@ -0,0 +1,52 @@
+import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES, type CoordinatorToolName } from "../coordinator/contract";
+import { type CoordinatorMcpConfig } from "./policy";
+export type { CoordinatorToolName };
+export { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES };
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface SessionStartInput {
+    cwd: string;
+    prompt?: string;
+    namespace: {
+        profile: string | null;
+        repo: string | null;
+    };
+    worktree: true;
+}
+interface CoordinatorServices {
+    listSessions?: () => unknown[] | Promise<unknown[]>;
+    startSession?: (input: SessionStartInput) => unknown | Promise<unknown>;
+}
+interface CoordinatorMcpServerOptions {
+    env?: NodeJS.ProcessEnv;
+    services?: CoordinatorServices;
+}
+interface LegacyHandlerOptions {
+    env?: NodeJS.ProcessEnv;
+    createSession?: () => unknown;
+}
+export declare function readCoordinatorArtifact(config: CoordinatorMcpConfig, args: {
+    path: unknown;
+}): Promise<Record<string, unknown>>;
+export declare function createCoordinatorMcpServer(options?: CoordinatorMcpServerOptions): {
+    config: CoordinatorMcpConfig;
+    callTool: (name: string, args?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+    handle: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+};
+export declare function handleCoordinatorMcpRequest(request: JsonRpcRequest, options?: LegacyHandlerOptions): Promise<any>;
+export declare function runCoordinatorMcpStdio(options?: CoordinatorMcpServerOptions): Promise<void>;

package/dist/types/extensibility/extensions/types.d.ts

@@ -62,6 +62,19 @@ export interface ExtensionUIDialogOptions {
      * select-only rendering hint; non-TUI bridges drop it and do not serialize it.
      */
     scrollTitleRows?: number;
+    /**
+     * For interactive TUI select dialogs, handle the option with `optionLabel`
+     * inline: selecting it keeps the title and option list on screen and opens
+     * a free-text input below the list. Submitting calls `onSubmit` with the
+     * typed text and resolves the select with `optionLabel`; Escape returns to
+     * option selection. Non-TUI bridges (RPC, ACP) drop it; callers must keep
+     * a fallback path for selects that resolve `optionLabel` without invoking
+     * `onSubmit`.
+     */
+    customInput?: {
+        optionLabel: string;
+        onSubmit: (text: string) => void;
+    };
 }
 /** Raw terminal input listener for extensions. */
 export type TerminalInputHandler = (data: string) => {

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/session-state-sidecar.d.ts

@@ -0,0 +1,13 @@
+export declare const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_SESSION_STATE_FILE";
+export declare const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
+interface RuntimeStateEvent {
+    type: string;
+    messages?: unknown[];
+}
+interface RuntimeStateContext {
+    sessionId: string;
+    cwd: string;
+    sessionFile?: string | null;
+}
+export declare function persistCoordinatorRuntimeStateFromEvent(event: RuntimeStateEvent, context: RuntimeStateContext): Promise<void>;
+export {};

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

@@ -7,6 +7,7 @@
  *
  * 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. */
@@ -108,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/components/hook-selector.d.ts

@@ -22,6 +22,17 @@ export interface HookSelectorOptions {
      */
     wrapFocused?: boolean;
     scrollTitleRows?: number;
+    /**
+     * Inline free-text entry for the option with this label (e.g. the ask
+     * tool's "Other (type your own)"). Selecting it keeps the title and option
+     * list on screen and opens a prompt-style editor below the list instead of
+     * replacing the whole selector. Enter submits via `onSubmit`; Escape
+     * returns to option selection.
+     */
+    customInput?: {
+        optionLabel: string;
+        onSubmit: (text: string) => void;
+    };
 }
 export declare class HookSelectorComponent extends Container {
     #private;

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