@gajae-code/coding-agent 0.7.2 → 0.7.4

package/src/modes/interactive-mode.ts

@@ -155,7 +155,7 @@ function getShellInputPrefix(isNoContext: boolean): string {
 
 function configureDefaultComposerChrome(editor: CustomEditor): void {
 	editor.setBorderVisible(true);
-	editor.setBorderStyle("sharp");
+	editor.setBorderStyle("round");
 	editor.setClosedBorderBox(true);
 	editor.setPromptGutter(undefined);
 	editor.setInputPrefix(getDefaultInputPrefix());
@@ -431,6 +431,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#resizeHandler = () => {
 			this.#syncEditorMaxHeight();
 			this.updateEditorChrome();
+			this.editor.invalidate();
+			this.ui.requestRender(true, "resize");
 		};
 		process.stdout.on("resize", this.#resizeHandler);
 		try {
@@ -568,6 +570,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.addChild(this.hookWidgetContainerAbove);
 		this.ui.addChild(this.editorContainer);
 		this.ui.addChild(this.hookWidgetContainerBelow);
+		this.ui.setBottomPinnedComponent(this.statusLine);
 		this.ui.setFocus(this.editor);
 
 		this.#inputController.setupKeyHandlers();

package/src/modes/shared/agent-wire/scopes.ts

@@ -73,7 +73,7 @@ const RPC_COMMAND_SCOPE_REGISTRY: Record<RpcCommandType, BridgeCommandScope> = {
 	get_login_providers: "admin",
 	login: "admin",
 	negotiate_unattended: "control",
-	workflow_gate_response: "prompt",
+	workflow_gate_response: "control",
 };
 
 export const RPC_COMMAND_TYPES: readonly RpcCommandType[] = Object.keys(RPC_COMMAND_SCOPE_REGISTRY) as RpcCommandType[];

package/src/modes/theme/defaults/gruvbox-dark.json

@@ -0,0 +1,99 @@
+{
+	"$schema": "https://raw.githubusercontent.com/can1357/gajae-code/main/packages/coding-agent/theme-schema.json",
+	"name": "gruvbox-dark",
+	"vars": {
+		"bgHard": "#1d2021",
+		"surface": "#32302f",
+		"surfaceBright": "#504945",
+		"borderNeutral": "#504945",
+		"borderSubtle": "#3c3836",
+		"fg": "#ebdbb2",
+		"muted": "#a89984",
+		"dim": "#7c6f64",
+		"gray": "#928374",
+		"red": "#fb4934",
+		"green": "#b8bb26",
+		"yellow": "#fabd2f",
+		"blue": "#83a598",
+		"purple": "#d3869b",
+		"aqua": "#8ec07c",
+		"orange": "#fe8019",
+		"diffRemovalRed": "#cc241d"
+	},
+	"colors": {
+		"accent": "orange",
+		"border": "borderNeutral",
+		"borderAccent": "orange",
+		"borderMuted": "borderSubtle",
+		"success": "green",
+		"error": "red",
+		"warning": "yellow",
+		"muted": "muted",
+		"dim": "dim",
+		"text": "fg",
+		"thinkingText": "muted",
+		"selectedBg": "surfaceBright",
+		"userMessageBg": "surface",
+		"userMessageText": "fg",
+		"customMessageBg": "surface",
+		"customMessageText": "fg",
+		"customMessageLabel": "orange",
+		"toolPendingBg": "surface",
+		"toolSuccessBg": "#283626",
+		"toolErrorBg": "#3c2323",
+		"toolTitle": "fg",
+		"toolOutput": "muted",
+		"mdHeading": "yellow",
+		"mdLink": "blue",
+		"mdLinkUrl": "muted",
+		"mdCode": "aqua",
+		"mdCodeBlock": "fg",
+		"mdCodeBlockBorder": "borderNeutral",
+		"mdQuote": "muted",
+		"mdQuoteBorder": "borderNeutral",
+		"mdHr": "dim",
+		"mdListBullet": "orange",
+		"toolDiffAdded": "green",
+		"toolDiffRemoved": "diffRemovalRed",
+		"toolDiffContext": "muted",
+		"syntaxComment": "gray",
+		"syntaxKeyword": "red",
+		"syntaxFunction": "green",
+		"syntaxVariable": "blue",
+		"syntaxString": "green",
+		"syntaxNumber": "purple",
+		"syntaxType": "yellow",
+		"syntaxOperator": "aqua",
+		"syntaxPunctuation": "muted",
+		"thinkingOff": "dim",
+		"thinkingMinimal": "muted",
+		"thinkingLow": "aqua",
+		"thinkingMedium": "yellow",
+		"thinkingHigh": "orange",
+		"thinkingXhigh": "red",
+		"bashMode": "green",
+		"pythonMode": "yellow",
+		"statusLineBg": "bgHard",
+		"statusLineSep": "dim",
+		"statusLineModel": "orange",
+		"statusLinePath": "blue",
+		"statusLineGitClean": "green",
+		"statusLineGitDirty": "yellow",
+		"statusLineContext": "aqua",
+		"statusLineSpend": "yellow",
+		"statusLineStaged": "green",
+		"statusLineDirty": "yellow",
+		"statusLineUntracked": "diffRemovalRed",
+		"statusLineOutput": "fg",
+		"statusLineCost": "orange",
+		"statusLineSubagents": "purple"
+	},
+	"export": {
+		"pageBg": "#1d2021",
+		"cardBg": "#282828",
+		"infoBg": "#32302f"
+	},
+	"symbols": {
+		"preset": "unicode"
+	}
+}

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

@@ -1,6 +1,7 @@
 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 gruvbox_dark from "./gruvbox-dark.json" with { type: "json" };
 import opencode from "./opencode.json" with { type: "json" };
 import red_claw from "./red-claw.json" with { type: "json" };
 
@@ -8,6 +9,7 @@ export const defaultThemes = {
 	"blue-crab": blue_crab,
 	"claude-code": claude_code,
 	codex,
+	"gruvbox-dark": gruvbox_dark,
 	opencode,
 	"red-claw": red_claw,
 };

package/src/modes/utils/hotkeys-markdown.ts

@@ -23,7 +23,7 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		"|-----|--------|",
 		"| `Enter` | Send / queue while busy |",
 		`| \`${appKey(bindings, "app.message.queue")}\` | Queue message for next turn |`,
-		"| `Shift+Enter` | New line |",
+		"| `Shift+Enter` / `Ctrl+J` | New line |",
 		"| `Ctrl+W` / `Option+Backspace` | Delete word backwards |",
 		"| `Ctrl+U` | Delete to start of line |",
 		"| `Ctrl+K` | Delete to end of line |",

package/src/notifications/html-format.ts

@@ -349,16 +349,54 @@ export function buttonLabel(label: string, index: number): string {
 	return `${index + 1}. ${stripped}`;
 }
 
+/** Numbered, escaped option list for the Telegram message body. */
+export function numberedOptionList(labels: string[]): string {
+	return labels.map((label, i) => `${i + 1}. ${escapeHtml(label.replace(/^\s*\d+[.)]\s+/, ""))}`).join("\n");
+}
+
+/** Compact numeric button label; full option text belongs in the message body. */
+export function choiceButtonLabel(index: number): string {
+	return String(index + 1);
+}
+
 export interface InlineButton {
 	text: string;
 	callback_data: string;
 }
 
+const COMPACT_BUTTONS_PER_ROW = 5;
+
 /** A prefixed button label is "long" when it is wide or contains a newline. */
 function isLongLabel(label: string): boolean {
 	return label.length > 18 || /[\r\n]/.test(label);
 }
 
+/**
+ * Lay out option callbacks as compact numeric buttons. Telegram mobile clients
+ * ellipsize long inline-keyboard labels and tall keyboards can be obscured by
+ * the composer, so the full choice text is rendered in the message body while
+ * the keyboard keeps only stable one-based tap targets.
+ */
+export function buildCompactChoiceGrid(
+	labels: string[],
+	callbackForIndex: (index: number) => string,
+): InlineButton[][] {
+	const rows: InlineButton[][] = [];
+	let run: InlineButton[] = [];
+	const flush = () => {
+		if (run.length) {
+			rows.push(run);
+			run = [];
+		}
+	};
+	labels.forEach((_label, i) => {
+		run.push({ text: choiceButtonLabel(i), callback_data: callbackForIndex(i) });
+		if (run.length === COMPACT_BUTTONS_PER_ROW) flush();
+	});
+	flush();
+	return rows;
+}
+
 /**
  * Lay out option labels as a numbered button grid. Long buttons take a
  * full-width row; runs of short buttons are packed into rows of up to 3. The

package/src/notifications/index.ts

@@ -12,7 +12,7 @@
  * - `ask` (unattended/RPC): observes emitted workflow gates and resolves the real
  *   gate on a remote reply via `ctx.workflowGate`.
  * - `turn_end` -> `action_needed` (kind `idle`, deduped per turn).
- * - `session_shutdown` -> stop the server + deregister the answer source.
+ * - `session_shutdown` -> `session_closed` frame, stop server, deregister answer source.
  *
  * Enable with Settings notifications config, `GJC_NOTIFICATIONS=1` (a token is
  * generated), or `GJC_NOTIFICATIONS_TOKEN`.
@@ -41,6 +41,193 @@ import {
 import { imageAttachmentsFromMessage, notificationActionPayload, summaryFromMessage } from "./helpers";
 import { ensureTelegramDaemonRunning } from "./telegram-daemon";
 
+// ===========================================================================
+// Session lifecycle control protocol (TypeScript mirror of the Rust wire
+// contract in `crates/gjc-notifications/src/lifecycle.rs`).
+//
+// These describe the frames exchanged over the daemon-owned, session-independent
+// control endpoint for remote session create / close / resume. Field names are
+// camelCase on the wire; `type`/`kind` discriminators are snake_case. The Rust
+// ingress authenticates and forwards; the daemon (TypeScript) owns all policy,
+// spawn orchestration, idempotency, rate limiting, audit, and UX.
+// ===========================================================================
+
+/** Where a `session_create` should run. Discriminated by `kind`. */
+export type SessionCreateTarget =
+	| { kind: "existing_path"; path: string }
+	| { kind: "worktree"; repo: string; branch: string }
+	| { kind: "plain_dir"; path: string };
+
+/** Identifies the session a `session_close` targets. */
+export interface SessionCloseTarget {
+	sessionId: string;
+	/** Expected GJC-managed tmux session name (defense-in-depth match). */
+	tmuxSession?: string;
+	/** Expected `@gjc-session-state-file` tag (defense-in-depth match). */
+	sessionStateFile?: string;
+}
+
+/** Identifies the session a `session_resume` targets. */
+export interface SessionResumeTarget {
+	sessionIdOrPrefix: string;
+	/** Optional repo/working-dir hint to disambiguate matches. */
+	path?: string;
+}
+
+/** Create a new session. */
+export interface SessionCreateFrame {
+	type: "session_create";
+	requestId: string;
+	/** Deterministic lifecycle marker preallocated by the daemon before spawn. */
+	lifecycleRequestId: string;
+	/** Session id the daemon preallocated and propagates to the child. */
+	intendedSessionId: string;
+	/** Telegram update id (idempotency key on the daemon side). */
+	updateId: number;
+	chatId: string;
+	/** Control-endpoint token authorizing this frame. */
+	token: string;
+	target: SessionCreateTarget;
+	/** Reference to the daemon-written, once-consumed startup-prompt file. */
+	startupPromptRef?: string;
+}
+
+/** Close (hard-kill, history preserved) a session. */
+export interface SessionCloseFrame {
+	type: "session_close";
+	requestId: string;
+	updateId: number;
+	chatId: string;
+	token: string;
+	target: SessionCloseTarget;
+	/** Hard-kill even if a live pane is attached (GJC-managed only). */
+	force?: boolean;
+}
+
+/** Resume a session (reattach if alive, else cold-restart from history). */
+export interface SessionResumeFrame {
+	type: "session_resume";
+	requestId: string;
+	updateId: number;
+	chatId: string;
+	token: string;
+	target: SessionResumeTarget;
+	startupPromptRef?: string;
+}
+
+/** Any client -> ingress lifecycle request frame. */
+export type SessionLifecycleRequest = SessionCreateFrame | SessionCloseFrame | SessionResumeFrame;
+
+/** Terminal status of a lifecycle request. */
+export type LifecycleStatus = "ok" | "error";
+
+/** A connected session's per-session endpoint, returned to the control client. */
+export interface LifecycleEndpoint {
+	url: string;
+	token: string;
+}
+
+/** The Telegram topic/thread a session is surfaced in. */
+export interface LifecycleTopic {
+	chatId: string;
+	threadId: string;
+}
+
+/** How a create request was correlated to its spawned session. */
+export type MatchedBy = "spawn_marker" | "session_ready";
+
+/** Response to a successful `session_create`. */
+export interface SessionCreateResponseFrame {
+	type: "session_create_response";
+	requestId: string;
+	status: LifecycleStatus;
+	lifecycleRequestId: string;
+	sessionId: string;
+	matchedBy: MatchedBy;
+	endpoint: LifecycleEndpoint;
+	topic: LifecycleTopic;
+	target: SessionCreateTarget;
+}
+
+/** Response to a successful `session_close`. */
+export interface SessionCloseResponseFrame {
+	type: "session_close_response";
+	requestId: string;
+	status: LifecycleStatus;
+	sessionId: string;
+	processGone: boolean;
+	historyPreserved: boolean;
+	endpointStale: boolean;
+}
+
+/** Whether a resume reattached to a live session or cold-restarted a dead one. */
+export type ResumeMode = "reattached" | "cold_restarted";
+
+/** Response to a successful `session_resume`. */
+export interface SessionResumeResponseFrame {
+	type: "session_resume_response";
+	requestId: string;
+	status: LifecycleStatus;
+	sessionId: string;
+	mode: ResumeMode;
+	endpoint: LifecycleEndpoint;
+	topic: LifecycleTopic;
+}
+
+/** Machine-readable reason a lifecycle request failed. */
+export type LifecycleErrorReason =
+	| "unauthorized"
+	| "rate_limited"
+	| "duplicate_conflict"
+	| "invalid_target"
+	| "ambiguous_target"
+	| "spawn_failed"
+	| "discovery_timeout"
+	| "readiness_timeout"
+	| "close_refused"
+	| "not_found"
+	| "terminal_uncertain";
+
+/** A candidate returned with an `ambiguous_target` resume error. */
+export interface ResumeCandidate {
+	sessionId: string;
+	path?: string;
+	/** Last-activity epoch-millis (session history file mtime), if known. */
+	mtimeMs?: number;
+}
+
+/** A structured lifecycle error frame. */
+export interface SessionLifecycleErrorFrame {
+	type: "session_lifecycle_error";
+	requestId: string;
+	status: LifecycleStatus;
+	reason: LifecycleErrorReason;
+	message: string;
+	candidates?: ResumeCandidate[];
+}
+
+/** Any ingress -> client lifecycle response frame. */
+export type SessionLifecycleResponse =
+	| SessionCreateResponseFrame
+	| SessionCloseResponseFrame
+	| SessionResumeResponseFrame
+	| SessionLifecycleErrorFrame;
+
+/**
+ * Replayable per-session readiness signal (mirror of the Rust `session_ready`
+ * frame). Buffered and replayed to late clients so WS-open alone never implies
+ * the session is live and surfaced.
+ */
+export interface SessionReadyFrame {
+	type: "session_ready";
+	sessionId: string;
+	lifecycleRequestId?: string;
+	startupPromptRef?: string;
+	repo?: string;
+	branch?: string;
+	title?: string;
+}
+
 /** Resolve the git dir for `cwd`, handling worktrees where `.git` is a file. */
 function gitDir(cwd: string): string | undefined {
 	const dot = path.join(cwd, ".git");
@@ -141,6 +328,7 @@ interface SessionRuntime {
 	/** Deregisters this session's Telegram file sink. */
 	disposeFileSink: () => void;
 	redact: boolean;
+	verbosity: "lean" | "verbose";
 	sessionTag: string;
 	/** Whether the agent loop is currently running (drives the typing indicator). */
 	busy: boolean;
@@ -248,7 +436,7 @@ function registerInteractiveAnswerSource(
 	id: string,
 	server: NotificationServer,
 	pendingInteractive: Map<string, PendingInteractiveAsk>,
-	redact: boolean,
+	getRedact: () => boolean,
 	tag: string,
 ): () => void {
 	return registerAskAnswerSource(id, {
@@ -260,7 +448,7 @@ function registerInteractiveAnswerSource(
 					JSON.stringify(
 						notificationActionPayload(
 							{ id: askId, kind: "ask", sessionId: id, question, options },
-							{ redact, sessionTag: tag },
+							{ redact: getRedact(), sessionTag: tag },
 						),
 					),
 					true,
@@ -296,8 +484,9 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 	const runtimes = new Map<string, SessionRuntime>();
 	const disabledSessions = new Set<string>();
 	const sessionId = (ctx: ExtensionContext): string => ctx.sessionManager.getSessionId();
+	const sleep = (ms: number): Promise<void> => new Promise(resolve => setTimeout(resolve, ms));
 
-	function stopSession(id: string): boolean {
+	async function stopSession(id: string): Promise<boolean> {
 		const rt = runtimes.get(id);
 		if (!rt) return false;
 		runtimes.delete(id);
@@ -308,6 +497,14 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		// Resolve any still-pending interactive asks so the ask tool is not left hanging.
 		for (const pending of rt.pendingInteractive.values()) pending.resolve(undefined);
 		rt.pendingInteractive.clear();
+		let closeFrameSent = false;
+		try {
+			rt.server.pushFrame(JSON.stringify({ type: "session_closed", sessionId: id }));
+			closeFrameSent = true;
+		} catch (e) {
+			logger.warn(`notifications: session_closed failed: ${String(e)}`);
+		}
+		if (closeFrameSent) await sleep(100);
 		try {
 			rt.server.stop();
 		} catch (e) {
@@ -336,6 +533,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		const pendingInteractive = new Map<string, PendingInteractiveAsk>();
 		const tag = sessionTag(id);
 		const redact = cfg.redact;
+		const verbosity = cfg.verbosity;
 		let runtime: SessionRuntime | undefined;
 
 		// The SDK can always answer now (interactive via the answer source, or the
@@ -410,7 +608,31 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 				return;
 			}
 			if (inbound.kind === "config_command") {
-				if (runtime && typeof inbound.redact === "boolean") runtime.redact = inbound.redact;
+				if (!runtime) return;
+				const update: {
+					type: "config_update";
+					sessionId: string;
+					verbosity?: "lean" | "verbose";
+					redact?: boolean;
+				} = {
+					type: "config_update",
+					sessionId: id,
+				};
+				if (inbound.verbosity === "lean" || inbound.verbosity === "verbose") {
+					runtime.verbosity = inbound.verbosity;
+					update.verbosity = inbound.verbosity;
+				}
+				if (typeof inbound.redact === "boolean") {
+					runtime.redact = inbound.redact;
+					update.redact = inbound.redact;
+				}
+				if (update.verbosity !== undefined || update.redact !== undefined) {
+					try {
+						runtime.server.pushFrame(JSON.stringify(update));
+					} catch (e) {
+						logger.warn(`notifications: config_update failed: ${String(e)}`);
+					}
+				}
 			}
 		});
 
@@ -418,7 +640,13 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 			const endpoint = await server.start();
 
 			// Interactive answer source: the ask tool races the local UI against this.
-			const disposeAnswerSource = registerInteractiveAnswerSource(id, server, pendingInteractive, redact, tag);
+			const disposeAnswerSource = registerInteractiveAnswerSource(
+				id,
+				server,
+				pendingInteractive,
+				() => runtime?.redact ?? redact,
+				tag,
+			);
 			const disposeFileSink = registerTelegramFileSink(id, async file => {
 				try {
 					const data = await fs.promises.readFile(file.path);
@@ -444,6 +672,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 				disposeAnswerSource,
 				disposeFileSink,
 				redact,
+				verbosity,
 				sessionTag: tag,
 				busy: false,
 				pendingInbound: new Set<number>(),
@@ -519,7 +748,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 
 			if (command === "off") {
 				disabledSessions.add(id);
-				const stopped = stopSession(id);
+				const stopped = await stopSession(id);
 				ctx.ui.notify(
 					stopped
 						? "Notifications disabled for this session."
@@ -567,8 +796,9 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 			const running = runtimes.has(id);
 			const locallyDisabled = disabledSessions.has(id);
 			const enabled = isEnabledForSession(id, resolved.cfg);
+			const runtime = runtimes.get(id);
 			ctx.ui.notify(
-				`Notifications ${running ? "running" : enabled ? "enabled" : "disabled"} for this session; redaction ${resolved.cfg.redact ? "on" : "off"}${locallyDisabled ? "; locally off" : ""}.`,
+				`Notifications ${running ? "running" : enabled ? "enabled" : "disabled"} for this session; redaction ${(runtime?.redact ?? resolved.cfg.redact) ? "on" : "off"}; verbosity ${runtime?.verbosity ?? resolved.cfg.verbosity}${locallyDisabled ? "; locally off" : ""}.`,
 				"info",
 			);
 		},
@@ -616,7 +846,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 			newId,
 			rt.server,
 			rt.pendingInteractive,
-			rt.redact,
+			() => rt.redact,
 			rt.sessionTag,
 		);
 		rt.disposeFileSink = registerTelegramFileSink(newId, async file => {
@@ -735,7 +965,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		// On idle, stream a context update with metadata (token/model usage +
 		// working-tree diff) unless redaction is on. The agent's last message is
 		// NOT repeated here — it is already streamed once via `turn_stream`.
-		if (!rt.redact) {
+		if (!rt.redact && rt.verbosity === "verbose") {
 			const usage = (
 				ctx as { getContextUsage?: () => { tokens: number | null; contextWindow: number } | undefined }
 			).getContextUsage?.();
@@ -836,7 +1066,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		}
 	});
 
-	api.on("session_shutdown", (_event, ctx) => {
-		stopSession(sessionId(ctx));
+	api.on("session_shutdown", async (_event, ctx) => {
+		await stopSession(sessionId(ctx));
 	});
 };