@gajae-code/coding-agent 0.5.1 → 0.5.3

package/src/modes/rpc/rpc-mode.ts

@@ -13,7 +13,7 @@
 
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { $pickenv, readLines, Snowflake } from "@gajae-code/utils";
+import { $pickenv, logger, readLines, Snowflake } from "@gajae-code/utils";
 import type {
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
@@ -27,7 +27,7 @@ import { AgentWireFrameSequencer, toAgentWireEventFrame } from "../shared/agent-
 import { rpcError as error } from "../shared/agent-wire/responses";
 import { registerRpcSession, unregisterRpcSession } from "../shared/agent-wire/session-registry";
 import { defaultAuditPath, UnattendedAuditLog } from "../shared/agent-wire/unattended-audit";
-import { UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
+import { modelSupportsTokenCostMetrics, UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
 import { FileGateStore } from "../shared/agent-wire/workflow-gate-broker";
 import { isRpcHostToolResult, isRpcHostToolUpdate, RpcHostToolBridge } from "./host-tools";
 import { isRpcHostUriResult, RpcHostUriBridge } from "./host-uris";
@@ -82,6 +82,82 @@ export function shouldEmitRpcTitlesForTest(): boolean {
 
 const shouldEmitRpcTitles = shouldEmitRpcTitlesForTest;
 
+/**
+ * Cancellation commands bypass the ordered serial chain because they must
+ * interrupt in-flight work — they cannot wait behind the very command they are
+ * meant to abort.
+ */
+export const RPC_CANCELLATION_COMMANDS: ReadonlySet<RpcCommand["type"]> = new Set<RpcCommand["type"]>([
+	"abort",
+	"abort_bash",
+	"abort_retry",
+]);
+
+/**
+ * Safe read-only commands that bypass the ordered serial chain so they never
+ * head-of-line-block behind a long-running ordered command like
+ * `bash`/`compact`/`handoff`/`login` (#606, issue 13 — the partial fix only
+ * fast-laned cancellation).
+ *
+ * Every command listed here has a dispatch handler that is **fully synchronous
+ * and side-effect-free**: on the single-threaded event loop it runs to
+ * completion between the await points of any in-flight ordered command, reading
+ * live state without mutating it. Because such a read performs no causal write,
+ * jumping ahead of an earlier *queued* ordered command is observably harmless —
+ * there is no state change to reorder. Read payloads are additionally
+ * snapshotted inside the handler (e.g. `get_messages` returns a shallow copy of
+ * `session.messages`) so a fast-lane read can never serialize a half-mutated
+ * array that an ordered turn/compaction is rewriting in place.
+ *
+ * Deliberately excluded (kept ordered): every async/long command and every
+ * mutating command. In particular the control-flag setters (`set_thinking_level`,
+ * `cycle_thinking_level`, `set_steering_mode`, `set_follow_up_mode`,
+ * `set_interrupt_mode`, `set_auto_compaction`, `set_auto_retry`) stay ordered.
+ * Their handlers are synchronous, so fast-laning one ahead of an already-queued
+ * `prompt`/`bash` would apply the new mode *before* that earlier command runs —
+ * the earlier command would then observe the later setter's value, a
+ * causal-order (arrival-order) regression. Mutations therefore stay on the
+ * chain, and new command types default to ordered (fail-safe).
+ */
+export const RPC_SAFE_READ_CONTROL_COMMANDS: ReadonlySet<RpcCommand["type"]> = new Set<RpcCommand["type"]>([
+	// Pure synchronous reads — snapshot live state at processing time, never mutate.
+	"get_state",
+	"get_session_stats",
+	"get_available_models",
+	"get_branch_messages",
+	"get_last_assistant_text",
+	"get_messages",
+	"get_login_providers",
+]);
+
+/** True when a command may bypass the ordered serial chain and run immediately. */
+export function isFastLaneRpcCommand(type: RpcCommand["type"]): boolean {
+	return RPC_CANCELLATION_COMMANDS.has(type) || RPC_SAFE_READ_CONTROL_COMMANDS.has(type);
+}
+
+/**
+ * Schedules inbound RPC commands: fast-lane commands run immediately while
+ * everything else runs through a serial chain so causal order is preserved. The
+ * read loop never blocks, which is what lets a fast-lane command reach a
+ * long-running ordered command instead of being head-of-line-blocked behind it.
+ */
+export function createRpcCommandScheduler(
+	run: (command: RpcCommand) => Promise<void>,
+	track: (task: Promise<void>) => void,
+): { dispatch: (command: RpcCommand) => void } {
+	let orderedChain: Promise<void> = Promise.resolve();
+	return {
+		dispatch(command: RpcCommand): void {
+			if (isFastLaneRpcCommand(command.type)) {
+				track(run(command));
+				return;
+			}
+			orderedChain = orderedChain.then(() => run(command));
+			track(orderedChain);
+		},
+	};
+}
+
 function auditOutcomeFor(event: string): "accepted" | "rejected" | "denied" | "exceeded" | "aborted" | "info" {
 	if (event.includes("denied")) return "denied";
 	if (event.includes("exceeded")) return "exceeded";
@@ -91,6 +167,43 @@ function auditOutcomeFor(event: string): "accepted" | "rejected" | "denied" | "e
 	return "info";
 }
 
+export class RpcListenRefusedError extends Error {
+	constructor(socketPath: string) {
+		super(
+			`RPC --listen refused: a live server is already listening on ${socketPath}. ` +
+				"Stop it first or choose a different --listen path.",
+		);
+		this.name = "RpcListenRefusedError";
+	}
+}
+
+/**
+ * Probe whether a unix-domain socket path has a live server accepting
+ * connections. Returns `true` when a connection succeeds (a previous owner is
+ * still alive), and returns `false` only for known missing/stale endpoints
+ * (ENOENT / ECONNREFUSED). Unexpected probe failures fail closed as "alive" so
+ * `--listen` startup refuses to unlink a path it could not safely classify.
+ */
+export async function isUnixSocketAlive(socketPath: string): Promise<boolean> {
+	try {
+		const socket = await Bun.connect({
+			unix: socketPath,
+			socket: { data() {}, open() {}, error() {}, close() {} },
+		});
+		socket.end();
+		return true;
+	} catch (err) {
+		const code = err && typeof err === "object" ? (err as { code?: unknown }).code : undefined;
+		if (code === "ENOENT" || code === "ECONNREFUSED") return false;
+		logger.warn("RPC --listen socket probe failed closed", {
+			socketPath,
+			code: typeof code === "string" ? code : undefined,
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return true;
+	}
+}
+
 export function requestRpcEditor(
 	pendingRequests: Map<string, PendingExtensionRequest>,
 	output: RpcOutput,
@@ -230,6 +343,7 @@ export async function runRpcMode(
 		emitFrame: gate => output(gate),
 		store: gateStore,
 		audit: recordAudit,
+		providerSupportsTokenCostMetrics: modelSupportsTokenCostMetrics(session.model),
 		getUsageSnapshot: () => {
 			const stats = session.getSessionStats();
 			return { tokens: stats.tokens.total, costUsd: stats.cost };
@@ -537,14 +651,13 @@ export async function runRpcMode(
 			unattendedControlPlane,
 		});
 
-	// Cancellation commands must interrupt in-flight work, so they bypass the ordered
-	// queue and run immediately. Everything else runs through a serial chain so causal
-	// order is preserved (e.g. `get_state` after `bash` still observes the bash result)
-	// while the read loop itself never blocks — that is what lets a cancellation command
-	// reach a long-running `bash`/`compact`/`handoff`/`login` instead of being
-	// head-of-line-blocked behind it (issue 13).
-	const CANCELLATION_COMMANDS = new Set<RpcCommand["type"]>(["abort", "abort_bash", "abort_retry"]);
-	let orderedChain: Promise<void> = Promise.resolve();
+	// Fast-lane commands (cancellation + safe read/control, see
+	// isFastLaneRpcCommand) bypass the ordered serial chain and run immediately;
+	// everything else runs through a serial chain so causal order is preserved
+	// (e.g. an ordered `set_model` after `bash` still applies after the bash
+	// result) while the read loop itself never blocks — that is what lets a
+	// fast-lane command reach a long-running `bash`/`compact`/`handoff`/`login`
+	// instead of being head-of-line-blocked behind it (issue 13).
 	const runCommand = async (command: RpcCommand): Promise<void> => {
 		try {
 			output(await handleCommand(command));
@@ -556,14 +669,7 @@ export async function runRpcMode(
 		inFlightCommands.add(task);
 		void task.finally(() => inFlightCommands.delete(task));
 	};
-	const dispatchCommand = (command: RpcCommand): void => {
-		if (CANCELLATION_COMMANDS.has(command.type)) {
-			trackCommand(runCommand(command));
-			return;
-		}
-		orderedChain = orderedChain.then(() => runCommand(command));
-		trackCommand(orderedChain);
-	};
+	const { dispatch: dispatchCommand } = createRpcCommandScheduler(runCommand, trackCommand);
 
 	/**
 	 * Check if shutdown was requested and perform shutdown if so.
@@ -620,6 +726,14 @@ export async function runRpcMode(
 	if (options?.listen) {
 		const socketPath = options.listen;
 		await fs.mkdir(path.dirname(socketPath), { recursive: true }).catch(() => {});
+		// Refuse to clobber a live previous owner: probe the path first and only
+		// unlink a stale endpoint. A second `--listen` on the same path must not
+		// remove the socket another running server is still serving (#606).
+		// Unexpected probe failures are treated as alive, so this also refuses
+		// rather than unlinking a socket path we could not safely classify.
+		if (await isUnixSocketAlive(socketPath)) {
+			throw new RpcListenRefusedError(socketPath);
+		}
 		await fs.rm(socketPath, { force: true }).catch(() => {});
 		await registerRpcSession({
 			sessionId: session.sessionId,

package/src/modes/shared/agent-wire/command-dispatch.ts

@@ -363,7 +363,10 @@ export async function dispatchRpcCommand(
 			}
 
 			case "get_messages": {
-				return rpcSuccess(id, "get_messages", { messages: session.messages });
+				// Fast-lane read: snapshot the live array so a concurrent ordered
+				// turn/compaction mutating session.messages in place cannot make this
+				// response serialize a half-rewritten array (#606, issue 13).
+				return rpcSuccess(id, "get_messages", { messages: [...session.messages] });
 			}
 
 			case "get_login_providers": {
@@ -447,7 +450,7 @@ export async function dispatchRpcCommand(
 
 			default: {
 				const unknownCommand = command as { type: string };
-				return rpcError(undefined, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
+				return rpcError(id, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
 			}
 		}
 	} catch (err) {

package/src/modes/shared/agent-wire/host-tool-bridge.ts

@@ -93,6 +93,9 @@ export class RpcHostToolBridge {
 	}
 
 	setTools(tools: RpcHostToolDefinition[]): AgentTool[] {
+		if (tools.some(tool => tool.name === "ask")) {
+			throw new Error('RPC host tool "ask" is reserved and cannot be supplied by the host');
+		}
 		this.#definitions = new Map(tools.map(tool => [tool.name, tool]));
 		return tools.map(tool => new RpcHostToolAdapter(tool, this));
 	}

package/src/modes/shared/agent-wire/unattended-session.ts

@@ -14,6 +14,7 @@
  * Also implements the dispatch-facing {@link RpcUnattendedControlPlane} so the
  * RPC server can route `negotiate_unattended` + `workflow_gate_response` here.
  */
+import type { Model } from "@gajae-code/ai";
 import type {
 	RpcCommand,
 	RpcUnattendedAccepted,
@@ -38,6 +39,20 @@ import { type GateStore, MemoryGateStore, type OpenGateInput, WorkflowGateBroker
  */
 const CHARGED_COMMAND_TYPES = new Set<RpcCommand["type"]>(["bash", "prompt", "steer", "follow_up", "abort_and_prompt"]);
 
+/**
+ * Derive an explicit `providerSupportsTokenCostMetrics` capability from the
+ * active model so unattended negotiation fails closed when token/cost usage
+ * cannot be accounted for (#606). Callers that omit a model — or whose model is
+ * configured to suppress streaming usage (`compat.supportsUsageInStreaming:
+ * false`) — get `false`, which the controller refuses with
+ * `unsupported_budget_metric`.
+ */
+export function modelSupportsTokenCostMetrics(model: Model | undefined): boolean {
+	if (!model) return false;
+	const compat = model.compat as { supportsUsageInStreaming?: boolean } | undefined;
+	return compat?.supportsUsageInStreaming !== false;
+}
+
 /** Minimal surface a skill runtime / ask tool uses to emit a gate and await its answer. */
 export interface WorkflowGateEmitter {
 	/** True only when unattended mode has been negotiated. */
@@ -92,7 +107,7 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 					this.#rejectAllPending(new Error(`unattended run aborted: ${reason}`));
 				},
 			},
-			providerSupportsTokenCostMetrics: this.opts.providerSupportsTokenCostMetrics ?? true,
+			providerSupportsTokenCostMetrics: this.opts.providerSupportsTokenCostMetrics,
 		});
 		this.#controller = controller;
 		this.#broker = new WorkflowGateBroker(this.opts.runId, this.opts.store ?? new MemoryGateStore(), {

package/src/modes/theme/defaults/claude-code.json

@@ -0,0 +1,100 @@
+{
+	"$schema": "https://raw.githubusercontent.com/can1357/gajae-code/main/packages/coding-agent/theme-schema.json",
+	"name": "claude-code",
+	"vars": {
+		"bg": "#1a1a1a",
+		"surface": "#373737",
+		"surfaceSubtle": "#2a2a2a",
+		"separator": "#505050",
+		"fg": "#ffffff",
+		"muted": "#888888",
+		"dim": "#666666",
+		"brandTerracotta": "#d77757",
+		"shimmerTerracotta": "#eb9f7f",
+		"toolPink": "#fd5db1",
+		"lavender": "#b1b9f9",
+		"autoAcceptPurple": "#af87ff",
+		"successGreen": "#4eba65",
+		"warningAmber": "#ffc107",
+		"errorSoftRed": "#ff6b80",
+		"diffAddedBg": "#225c2b",
+		"diffRemovedBg": "#7a2936",
+		"diffRemovedFg": "#ff8fa0"
+	},
+	"colors": {
+		"accent": "brandTerracotta",
+		"border": "separator",
+		"borderAccent": "toolPink",
+		"borderMuted": "dim",
+		"success": "successGreen",
+		"error": "errorSoftRed",
+		"warning": "warningAmber",
+		"muted": "muted",
+		"dim": "dim",
+		"text": "fg",
+		"thinkingText": "muted",
+		"selectedBg": "surface",
+		"userMessageBg": "surface",
+		"userMessageText": "fg",
+		"customMessageBg": "surfaceSubtle",
+		"customMessageText": "fg",
+		"customMessageLabel": "brandTerracotta",
+		"toolPendingBg": "surfaceSubtle",
+		"toolSuccessBg": "diffAddedBg",
+		"toolErrorBg": "diffRemovedBg",
+		"toolTitle": "fg",
+		"toolOutput": "muted",
+		"mdHeading": "brandTerracotta",
+		"mdLink": "lavender",
+		"mdLinkUrl": "muted",
+		"mdCode": "shimmerTerracotta",
+		"mdCodeBlock": "fg",
+		"mdCodeBlockBorder": "toolPink",
+		"mdQuote": "muted",
+		"mdQuoteBorder": "separator",
+		"mdHr": "dim",
+		"mdListBullet": "brandTerracotta",
+		"toolDiffAdded": "successGreen",
+		"toolDiffRemoved": "diffRemovedFg",
+		"toolDiffContext": "muted",
+		"syntaxComment": "muted",
+		"syntaxKeyword": "lavender",
+		"syntaxFunction": "shimmerTerracotta",
+		"syntaxVariable": "fg",
+		"syntaxString": "successGreen",
+		"syntaxNumber": "warningAmber",
+		"syntaxType": "autoAcceptPurple",
+		"syntaxOperator": "toolPink",
+		"syntaxPunctuation": "muted",
+		"thinkingOff": "dim",
+		"thinkingMinimal": "muted",
+		"thinkingLow": "shimmerTerracotta",
+		"thinkingMedium": "brandTerracotta",
+		"thinkingHigh": "toolPink",
+		"thinkingXhigh": "errorSoftRed",
+		"bashMode": "toolPink",
+		"pythonMode": "lavender",
+		"statusLineBg": "bg",
+		"statusLineSep": "separator",
+		"statusLineModel": "brandTerracotta",
+		"statusLinePath": "lavender",
+		"statusLineGitClean": "successGreen",
+		"statusLineGitDirty": "warningAmber",
+		"statusLineContext": "lavender",
+		"statusLineSpend": "warningAmber",
+		"statusLineStaged": "successGreen",
+		"statusLineDirty": "warningAmber",
+		"statusLineUntracked": "errorSoftRed",
+		"statusLineOutput": "fg",
+		"statusLineCost": "shimmerTerracotta",
+		"statusLineSubagents": "autoAcceptPurple"
+	},
+	"export": {
+		"pageBg": "#1a1a1a",
+		"cardBg": "#2a2a2a",
+		"infoBg": "#373737"
+	},
+	"symbols": {
+		"preset": "unicode"
+	}
+}

package/src/modes/theme/defaults/codex.json

@@ -0,0 +1,100 @@
+{
+	"$schema": "https://raw.githubusercontent.com/can1357/gajae-code/main/packages/coding-agent/theme-schema.json",
+	"name": "codex",
+	"vars": {
+		"bg": "#0f1115",
+		"surface": "#151922",
+		"surfaceBright": "#1c2230",
+		"selection": "#24313a",
+		"fg": "#d7d7d7",
+		"muted": "#8a8f98",
+		"dim": "#5f6670",
+		"borderNeutral": "#343a46",
+		"ansiCyan": "#00bcd4",
+		"cyanSoft": "#58d5e8",
+		"brandMagenta": "#c678dd",
+		"magentaSoft": "#d7a4e8",
+		"successGreen": "#4caf50",
+		"errorRed": "#ef5350",
+		"warningOrange": "#f59e0b",
+		"diffRemovalRed": "#d84a4a",
+		"toolSuccessBg": "#14241a",
+		"toolErrorBg": "#2a1718"
+	},
+	"colors": {
+		"accent": "ansiCyan",
+		"border": "borderNeutral",
+		"borderAccent": "ansiCyan",
+		"borderMuted": "dim",
+		"success": "successGreen",
+		"error": "errorRed",
+		"warning": "warningOrange",
+		"muted": "muted",
+		"dim": "dim",
+		"text": "fg",
+		"thinkingText": "muted",
+		"selectedBg": "selection",
+		"userMessageBg": "surface",
+		"userMessageText": "fg",
+		"customMessageBg": "surface",
+		"customMessageText": "fg",
+		"customMessageLabel": "brandMagenta",
+		"toolPendingBg": "surface",
+		"toolSuccessBg": "toolSuccessBg",
+		"toolErrorBg": "toolErrorBg",
+		"toolTitle": "fg",
+		"toolOutput": "muted",
+		"mdHeading": "brandMagenta",
+		"mdLink": "ansiCyan",
+		"mdLinkUrl": "muted",
+		"mdCode": "cyanSoft",
+		"mdCodeBlock": "fg",
+		"mdCodeBlockBorder": "borderNeutral",
+		"mdQuote": "muted",
+		"mdQuoteBorder": "borderNeutral",
+		"mdHr": "dim",
+		"mdListBullet": "ansiCyan",
+		"toolDiffAdded": "successGreen",
+		"toolDiffRemoved": "diffRemovalRed",
+		"toolDiffContext": "muted",
+		"syntaxComment": "dim",
+		"syntaxKeyword": "brandMagenta",
+		"syntaxFunction": "cyanSoft",
+		"syntaxVariable": "fg",
+		"syntaxString": "successGreen",
+		"syntaxNumber": "magentaSoft",
+		"syntaxType": "ansiCyan",
+		"syntaxOperator": "muted",
+		"syntaxPunctuation": "dim",
+		"thinkingOff": "dim",
+		"thinkingMinimal": "muted",
+		"thinkingLow": "cyanSoft",
+		"thinkingMedium": "ansiCyan",
+		"thinkingHigh": "brandMagenta",
+		"thinkingXhigh": "errorRed",
+		"bashMode": "ansiCyan",
+		"pythonMode": "brandMagenta",
+		"statusLineBg": "bg",
+		"statusLineSep": "dim",
+		"statusLineModel": "brandMagenta",
+		"statusLinePath": "cyanSoft",
+		"statusLineGitClean": "successGreen",
+		"statusLineGitDirty": "warningOrange",
+		"statusLineContext": "ansiCyan",
+		"statusLineSpend": "cyanSoft",
+		"statusLineStaged": "successGreen",
+		"statusLineDirty": "warningOrange",
+		"statusLineUntracked": "diffRemovalRed",
+		"statusLineOutput": "fg",
+		"statusLineCost": "muted",
+		"statusLineSubagents": "brandMagenta"
+	},
+	"export": {
+		"pageBg": "#0f1115",
+		"cardBg": "#151922",
+		"infoBg": "#1c2230"
+	},
+	"symbols": {
+		"preset": "unicode"
+	}
+}

package/src/modes/theme/defaults/index.ts

@@ -1,7 +1,13 @@
 import blue_crab from "./blue-crab.json" with { type: "json" };
+import claude_code from "./claude-code.json" with { type: "json" };
+import codex from "./codex.json" with { type: "json" };
+import opencode from "./opencode.json" with { type: "json" };
 import red_claw from "./red-claw.json" with { type: "json" };
 
 export const defaultThemes = {
 	"blue-crab": blue_crab,
+	"claude-code": claude_code,
+	codex,
+	opencode,
 	"red-claw": red_claw,
 };

package/src/modes/theme/defaults/opencode.json

@@ -0,0 +1,102 @@
+{
+	"$schema": "https://raw.githubusercontent.com/can1357/gajae-code/main/packages/coding-agent/theme-schema.json",
+	"name": "opencode",
+	"vars": {
+		"background": "#212121",
+		"currentLine": "#252525",
+		"selection": "#303030",
+		"backgroundDarker": "#121212",
+		"foreground": "#e0e0e0",
+		"comment": "#6a6a6a",
+		"primary": "#fab283",
+		"secondary": "#5c9cf5",
+		"accentPurple": "#9d7cd8",
+		"errorRed": "#e06c75",
+		"warningOrange": "#f5a742",
+		"successGreen": "#7fd88f",
+		"infoCyan": "#56b6c2",
+		"emphasizedYellow": "#e5c07b",
+		"border": "#4b4c5c",
+		"diffAdded": "#478247",
+		"diffRemoved": "#7c4444",
+		"diffContext": "#a0a0a0",
+		"addedBg": "#303a30",
+		"removedBg": "#3a3030"
+	},
+	"colors": {
+		"accent": "primary",
+		"border": "border",
+		"borderAccent": "accentPurple",
+		"borderMuted": "comment",
+		"success": "successGreen",
+		"error": "errorRed",
+		"warning": "warningOrange",
+		"muted": "comment",
+		"dim": "comment",
+		"text": "foreground",
+		"thinkingText": "diffContext",
+		"selectedBg": "selection",
+		"userMessageBg": "currentLine",
+		"userMessageText": "foreground",
+		"customMessageBg": "currentLine",
+		"customMessageText": "foreground",
+		"customMessageLabel": "primary",
+		"toolPendingBg": "currentLine",
+		"toolSuccessBg": "addedBg",
+		"toolErrorBg": "removedBg",
+		"toolTitle": "foreground",
+		"toolOutput": "comment",
+		"mdHeading": "secondary",
+		"mdLink": "primary",
+		"mdLinkUrl": "infoCyan",
+		"mdCode": "successGreen",
+		"mdCodeBlock": "foreground",
+		"mdCodeBlockBorder": "border",
+		"mdQuote": "emphasizedYellow",
+		"mdQuoteBorder": "emphasizedYellow",
+		"mdHr": "comment",
+		"mdListBullet": "primary",
+		"toolDiffAdded": "diffAdded",
+		"toolDiffRemoved": "diffRemoved",
+		"toolDiffContext": "diffContext",
+		"syntaxComment": "comment",
+		"syntaxKeyword": "secondary",
+		"syntaxFunction": "primary",
+		"syntaxVariable": "errorRed",
+		"syntaxString": "successGreen",
+		"syntaxNumber": "accentPurple",
+		"syntaxType": "emphasizedYellow",
+		"syntaxOperator": "infoCyan",
+		"syntaxPunctuation": "foreground",
+		"thinkingOff": "comment",
+		"thinkingMinimal": "diffContext",
+		"thinkingLow": "infoCyan",
+		"thinkingMedium": "secondary",
+		"thinkingHigh": "accentPurple",
+		"thinkingXhigh": "errorRed",
+		"bashMode": "infoCyan",
+		"pythonMode": "accentPurple",
+		"statusLineBg": "backgroundDarker",
+		"statusLineSep": "border",
+		"statusLineModel": "primary",
+		"statusLinePath": "secondary",
+		"statusLineGitClean": "successGreen",
+		"statusLineGitDirty": "warningOrange",
+		"statusLineContext": "infoCyan",
+		"statusLineSpend": "emphasizedYellow",
+		"statusLineStaged": "diffAdded",
+		"statusLineDirty": "warningOrange",
+		"statusLineUntracked": "errorRed",
+		"statusLineOutput": "foreground",
+		"statusLineCost": "primary",
+		"statusLineSubagents": "accentPurple"
+	},
+	"export": {
+		"pageBg": "#121212",
+		"cardBg": "#212121",
+		"infoBg": "#252525"
+	},
+	"symbols": {
+		"preset": "unicode"
+	}
+}

package/src/modes/theme/theme.ts

@@ -810,7 +810,7 @@ const colorValueSchema = z.union([
 
 type ColorValue = z.infer<typeof colorValueSchema>;
 
-const THEME_COLOR_KEYS = [
+export const THEME_COLOR_KEYS = [
 	"accent",
 	"border",
 	"borderAccent",
@@ -1648,7 +1648,7 @@ async function loadThemeJson(name: string): Promise<ThemeJson> {
 			errorMessage += `\nMissing required color tokens:\n`;
 			errorMessage += missingColors.map(c => `  - ${c}`).join("\n");
 			errorMessage += `\n\nPlease add these colors to your theme's "colors" object.`;
-			errorMessage += `\nSee the built-in themes (red-claw.json, blue-crab.json) for reference values.`;
+			errorMessage += `\nSee the built-in themes under src/modes/theme/defaults/ for reference values.`;
 		}
 		if (otherErrors.length > 0) {
 			errorMessage += `\n\nOther errors:\n${otherErrors.join("\n")}`;

package/src/modes/types.ts

@@ -109,7 +109,7 @@ export interface InteractiveModeContext {
 	retryLoader: Loader | undefined;
 	autoCompactionEscapeHandler?: () => void;
 	retryEscapeHandler?: () => void;
-	retryCountdownTimer?: ReturnType<typeof setInterval>;
+	retryCountdownTimer?: NodeJS.Timeout;
 	unsubscribe?: () => void;
 	onInputCallback?: (input: SubmittedUserInput) => void;
 	optimisticUserMessageSignature: string | undefined;

package/src/modes/utils/ui-helpers.ts

@@ -706,13 +706,16 @@ export class UiHelpers {
 
 	/** Move pending bash components from pending area to chat */
 	flushPendingBashComponents(): void {
+		// Move (detach, not dispose) the live execution components from the pending
+		// area into the chat transcript — they are reused instances, so a disposing
+		// removeChild() would tear them down before re-adding.
 		for (const component of this.ctx.pendingBashComponents) {
-			this.ctx.pendingMessagesContainer.removeChild(component);
+			this.ctx.pendingMessagesContainer.detachChild(component);
 			this.ctx.chatContainer.addChild(component);
 		}
 		this.ctx.pendingBashComponents = [];
 		for (const component of this.ctx.pendingPythonComponents) {
-			this.ctx.pendingMessagesContainer.removeChild(component);
+			this.ctx.pendingMessagesContainer.detachChild(component);
 			this.ctx.chatContainer.addChild(component);
 		}
 		this.ctx.pendingPythonComponents = [];

package/src/prompts/agents/executor.md

@@ -36,10 +36,13 @@ This mode activates only when the assignment explicitly labels Executor as Ultra
 
 When active:
 - Start from the approved plan/spec/acceptance criteria, then user-facing contracts, then implementation code only as supporting evidence. Treat plan/code mismatches as blockers.
-- Exercise the real user-facing invocation rather than inspecting internals alone: GUI/web uses browser automation plus screenshot or image verdict; CLI uses logs or terminal transcripts; API/package uses external consumer or black-box tests through the public interface; algorithm/math uses boundary, property, adversarial, and failure-mode cases.
+- Exercise the real user-facing invocation rather than inspecting internals alone. Live artifacts must be runtime-valid: GUI/web needs a real automation transcript plus non-uniform screenshot; CLI needs executed argv-only replay; native/desktop/TUI needs a real screenshot, PTY capture with control codes, or app-automation transcript. `inlineEvidence` is supplemental only and is never sole proof for live surfaces.
+- For CLI evidence, emit argv-only replay JSON with `schemaVersion: 1`, `kind: "cli-replay"`, `replaySafe: true`, and `command` as a string array. Use only allowlisted deterministic executables/arguments, or mark unsafe/non-deterministic commands with audited `replayExempt` metadata plus a valid structural fallback artifact.
+- Native/TUI evidence must be structural, not prose-only: screenshot, app transcript, or PTY artifact with terminal control codes.
+- Do not call the `ask` tool while an Ultragoal run is active; record unresolved decisions with `gjc ultragoal record-review-blockers`.
 - Try to break the work with adversarial cases, not just happy-path confirmations.
 - Report the QA matrix with the final field names `executorQa.contractCoverage`, `executorQa.surfaceEvidence`, `executorQa.adversarialCases`, and `executorQa.artifactRefs`.
-- Include artifact refs for every executed surface and adversarial case: transcript ids, log paths, screenshots, image verdicts, test outputs, or other durable evidence.
+- Include artifact refs for every executed surface and adversarial case: transcript ids, log paths, screenshots, image verdicts, CLI replay records, PTY captures, test outputs, or other durable evidence.
 - Use `status: "not_applicable"` only for rows in `executorQa.contractCoverage` and `executorQa.surfaceEvidence`; each not-applicable row requires `contractRef` plus `reason`. `executorQa.adversarialCases` rows cannot be not-applicable.
 - Report blockers for any missing plan/spec/acceptance source, contract ambiguity, plan/code mismatch, untestable surface, failed adversarial case, shallow evidence, or missing artifact ref.
 </ultragoal_red_team_mode>