@gajae-code/coding-agent 0.4.2 → 0.4.4

package/src/extensibility/extensions/types.ts

@@ -122,6 +122,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. */

package/src/gjc-runtime/goal-mode-request.ts

@@ -25,6 +25,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 =
@@ -77,9 +83,11 @@ export async function writePendingGoalModeRequest(input: {
 	cwd: string;
 	objective: string;
 	goalsPath?: string;
+	sessionId?: string | null;
 }): Promise<PendingGoalModeRequest> {
 	const objective = input.objective.trim();
 	if (!objective) throw new Error("goal objective is required");
+	const sessionId = input.sessionId?.trim();
 	const request: PendingGoalModeRequest = {
 		version: REQUEST_VERSION,
 		kind: "goal_mode_request",
@@ -87,6 +95,7 @@ export async function writePendingGoalModeRequest(input: {
 		objective,
 		createdAt: new Date().toISOString(),
 		goalsPath: input.goalsPath,
+		...(sessionId ? { sessionId } : {}),
 	};
 	const filePath = requestPath(input.cwd);
 	await writeJsonAtomic(filePath, request, {
@@ -162,7 +171,10 @@ export async function writeCurrentSessionGoalModeState(input: {
 	return { status: "updated", goal: state.goal, sessionFile };
 }
 
-export async function consumePendingGoalModeRequest(cwd: string): Promise<PendingGoalModeRequest | null> {
+export async function consumePendingGoalModeRequest(
+	cwd: string,
+	currentSessionId?: string | null,
+): Promise<PendingGoalModeRequest | null> {
 	const filePath = requestPath(cwd);
 	let raw: unknown;
 	try {
@@ -181,6 +193,14 @@ export async function consumePendingGoalModeRequest(cwd: string): Promise<Pendin
 	) {
 		return null;
 	}
+	// Session isolation: a request stamped with an owning session id may only be
+	// consumed by that same session. Leave another session's request untouched
+	// (do not delete it) so its rightful owner can still pick it up. Legacy/unscoped
+	// requests (no sessionId) remain consumable by any session in this cwd.
+	const ownerSessionId = typeof candidate.sessionId === "string" ? candidate.sessionId.trim() : "";
+	if (ownerSessionId && ownerSessionId !== (currentSessionId?.trim() ?? "")) {
+		return null;
+	}
 	await removeFileAudited(filePath, {
 		cwd,
 		audit: { category: "prune", verb: "remove", owner: "gjc-runtime" },

package/src/gjc-runtime/session-state-sidecar.ts

@@ -0,0 +1,79 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { AssistantMessage } from "@gajae-code/ai";
+import { logger } from "@gajae-code/utils";
+
+export const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_SESSION_STATE_FILE";
+export const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
+
+type RuntimeState = "ready_for_input" | "running" | "needs_user_input" | "completed" | "errored";
+
+interface RuntimeStateEvent {
+	type: string;
+	messages?: unknown[];
+}
+
+interface RuntimeStateContext {
+	sessionId: string;
+	cwd: string;
+	sessionFile?: string | null;
+}
+
+function lastAssistant(messages: unknown[] | undefined): AssistantMessage | undefined {
+	if (!messages) return undefined;
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index];
+		if (message && typeof message === "object" && (message as { role?: unknown }).role === "assistant") {
+			return message as AssistantMessage;
+		}
+	}
+	return undefined;
+}
+
+function stateForEvent(event: RuntimeStateEvent): RuntimeState | null {
+	if (event.type === "agent_start" || event.type === "turn_start") return "running";
+	if (event.type === "agent_end") {
+		const assistant = lastAssistant(event.messages);
+		return assistant?.stopReason === "error" ? "errored" : "completed";
+	}
+	if (event.type === "notice") return null;
+	return null;
+}
+
+export async function persistCoordinatorRuntimeStateFromEvent(
+	event: RuntimeStateEvent,
+	context: RuntimeStateContext,
+): Promise<void> {
+	const stateFile = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim();
+	if (!stateFile) return;
+	const state = stateForEvent(event);
+	if (!state) return;
+	const now = new Date().toISOString();
+	let previous: Record<string, unknown> = {};
+	try {
+		previous = JSON.parse(await Bun.file(stateFile).text()) as Record<string, unknown>;
+	} catch {
+		previous = {};
+	}
+	const payload = {
+		schema_version: 1,
+		session_id: process.env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || context.sessionId,
+		state,
+		ready_for_input: state === "completed" || state === "ready_for_input",
+		updated_at: now,
+		current_turn_id: typeof previous.current_turn_id === "string" ? previous.current_turn_id : null,
+		last_turn_id: typeof previous.last_turn_id === "string" ? previous.last_turn_id : null,
+		live: typeof previous.live === "boolean" ? previous.live : null,
+		reason: null,
+		source: "agent_session_event",
+		event: event.type,
+		cwd: context.cwd,
+		session_file: context.sessionFile ?? null,
+	};
+	try {
+		await fs.mkdir(path.dirname(stateFile), { recursive: true });
+		await Bun.write(stateFile, `${JSON.stringify(payload, null, 2)}\n`);
+	} catch (error) {
+		logger.warn("Failed to persist coordinator runtime state", { error: String(error), stateFile });
+	}
+}

package/src/harness-control-plane/owner.ts

@@ -14,10 +14,10 @@
 import { execFileSync } from "node:child_process";
 import { randomBytes, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { observeRpcOutboundFrame } from "../modes/shared/agent-wire/event-observation";
 import { classifyRecovery } from "./classifier";
 import { ControlServer, type EndpointRequest } from "./control-endpoint";
 import { defaultFinalizeChecks, type FinalizeChecks, runFinalize, type ValidationCommandSpec } from "./finalize";
-import { mapRpcFrame } from "./frame-mapper";
 import { type OperateResult, operate } from "./operate";
 import { preserveDirtyWorktree } from "./preserve";
 import {
@@ -174,7 +174,7 @@ export class RuntimeOwner {
 
 	/** Map an RPC frame and route it: semantic/signal-bearing -> serial emit; high-frequency progress -> coalesce. */
 	#handleFrame(frame: Record<string, unknown>): void {
-		const mapped = mapRpcFrame(frame);
+		const mapped = observeRpcOutboundFrame(frame);
 		if (!mapped) return;
 		if (mapped.semantic || (mapped.signal && !mapped.coalesceKey)) {
 			this.#framePump = this.#framePump
@@ -199,7 +199,7 @@ export class RuntimeOwner {
 		await this.#emit("info", "rpc_activity", { coalescedFrames });
 	}
 
-	async #emitMapped(mapped: NonNullable<ReturnType<typeof mapRpcFrame>>): Promise<void> {
+	async #emitMapped(mapped: NonNullable<ReturnType<typeof observeRpcOutboundFrame>>): Promise<void> {
 		await this.#emit(
 			mapped.severity,
 			mapped.kind,

package/src/harness-control-plane/rpc-adapter.ts

@@ -174,7 +174,13 @@ export class GajaeCodeRpc implements HarnessRpc {
 		// Any other frame is a session/agent event: advance the cursor.
 		this.#cursor += 1;
 		this.#lastFrameAt = new Date().toISOString();
-		if (type === "agent_start") {
+		// Session events arrive as canonical `event` frames: the agent event type
+		// lives in `payload.event_type`. Non-event frames keep their flat `type`.
+		const effectiveType =
+			type === "event" && frame.payload && typeof frame.payload === "object"
+				? (frame.payload as { event_type?: unknown }).event_type
+				: type;
+		if (effectiveType === "agent_start") {
 			const cursor = this.#cursor;
 			this.#agentStartCursors.push(cursor);
 			this.#waiters = this.#waiters.filter(w => {

package/src/harness-control-plane/types.ts

@@ -8,6 +8,8 @@
  * 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";
 
@@ -147,17 +149,12 @@ export interface SessionState {
 	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 const OBSERVED_SIGNALS: readonly ObservedSignal[] = [
 	"SessionStart",