@gajae-code/coding-agent 0.11.9 → 0.11.11

package/src/modes/controllers/selector-controller.ts

@@ -64,8 +64,10 @@ import {
 import type { NotificationSessionStatus } from "../../sdk/bus/session-control";
 import {
 	ensureTelegramDaemonRunningDetailed,
+	readNotificationRootRegistration,
 	resolveTelegramSetupPreflight,
 	unregisterNotificationRoot,
+	withNotificationRootRegistryFence,
 } from "../../sdk/bus/telegram-daemon";
 import { TelegramDaemonController } from "../../sdk/bus/telegram-daemon-control";
 import { runTelegramSetup, type TelegramSetupPreflight } from "../../sdk/bus/telegram-setup";
@@ -216,6 +218,12 @@ export interface NotificationsEditorAdapterContext {
 	notifyConfigChanged?: () => Promise<void> | void;
 }
 
+type TelegramDaemonStopResult = {
+	ok: boolean;
+	message: string;
+	before?: { health?: string };
+};
+
 export interface NotificationsEditorOperationDependencies {
 	getNotificationConfig: typeof getNotificationConfig;
 	maskToken: typeof maskToken;
@@ -231,14 +239,17 @@ export interface NotificationsEditorOperationDependencies {
 	reconcileCommittedTelegramConfiguration: typeof reconcileCommittedTelegramConfiguration;
 	saveTelegramInactive: typeof saveTelegramInactive;
 	removeTelegramConfiguration: typeof removeTelegramConfiguration;
+	readNotificationRootRegistration: typeof readNotificationRootRegistration;
 	unregisterNotificationRoot: typeof unregisterNotificationRoot;
+	stopTelegramDaemonIfRootRegistryFenceMatches(input: {
+		settings: Settings;
+		registryFingerprint: string;
+		stop: () => Promise<TelegramDaemonStopResult>;
+	}): Promise<boolean>;
+
 	reloadTelegramDaemon(settings: Settings): Promise<{ ok: boolean; message: string }>;
 	restartTelegramDaemon(settings: Settings): Promise<{ ok: boolean; message: string }>;
-	stopTelegramDaemon(settings: Settings): Promise<{
-		ok: boolean;
-		message: string;
-		before?: { health?: string };
-	}>;
+	stopTelegramDaemon(settings: Settings): Promise<TelegramDaemonStopResult>;
 }
 
 const notificationEditorOperationDependencies: NotificationsEditorOperationDependencies = {
@@ -256,7 +267,18 @@ const notificationEditorOperationDependencies: NotificationsEditorOperationDepen
 	reconcileCommittedTelegramConfiguration,
 	saveTelegramInactive,
 	removeTelegramConfiguration,
+	readNotificationRootRegistration,
 	unregisterNotificationRoot,
+	stopTelegramDaemonIfRootRegistryFenceMatches: async input =>
+		await withNotificationRootRegistryFence({
+			settings: input.settings,
+			registryFingerprint: input.registryFingerprint,
+			action: async () => {
+				const stopped = await input.stop();
+				if (!stopped.ok) throw new Error(stopped.message);
+			},
+		}),
+
 	reloadTelegramDaemon: async settings =>
 		await new TelegramDaemonController(settings).reload({ spawnIfStopped: false }),
 	restartTelegramDaemon: async settings =>
@@ -625,14 +647,22 @@ export function createNotificationsEditorOperations(
 						stopAndUnregister: async () => {
 							if (controller) await controller.enterBlockedRuntime(sessionContext());
 							runtimePrepared = true;
+							const registration = await services.readNotificationRootRegistration({
+								settings: ctx.settings,
+								sessionId: ctx.sessionManager.getSessionId(),
+							});
 							const unregistered = await services.unregisterNotificationRoot({
 								settings: ctx.settings,
 								cwd: ctx.sessionManager.getCwd(),
 								sessionId: ctx.sessionManager.getSessionId(),
+								registrationToken: registration.token,
 							});
-							if (unregistered.remainingRoots === 0) {
-								const stopped = await new TelegramDaemonController(ctx.settings).stop();
-								if (!stopped.ok) throw new Error(stopped.message);
+							if (unregistered.registryFingerprint !== undefined) {
+								await services.stopTelegramDaemonIfRootRegistryFenceMatches({
+									settings: ctx.settings,
+									registryFingerprint: unregistered.registryFingerprint,
+									stop: () => services.stopTelegramDaemon(ctx.settings),
+								});
 							}
 						},
 					},

package/src/modes/interactive-mode.ts

@@ -18,6 +18,7 @@ import chalk from "chalk";
 import { AsyncJobManager } from "../async";
 import {
 	type AppKeybinding,
+	defaultMessageQueueKeysForPlatform,
 	formatKeyHint,
 	formatKeyHints,
 	KeybindingsManager,
@@ -47,6 +48,7 @@ import type { SessionContext, SessionManager } from "../session/session-manager"
 import { getRecentSessions, getSessionMessageEntryId } from "../session/session-manager";
 import type { LspStartupServerInfo } from "../tools";
 import { formatPhaseDisplayName } from "../tools/todo-write";
+import { copyToClipboard } from "../utils/clipboard";
 import type { EventBus } from "../utils/event-bus";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../utils/session-color";
 import { popTerminalTitle, pushTerminalTitle, setSessionTerminalTitle } from "../utils/title-generator";
@@ -113,16 +115,60 @@ import {
 import type { ParsedIrcMessage } from "./utils/irc-message";
 import { addChatChild, prepareTranscriptRebuild, UiHelpers } from "./utils/ui-helpers";
 
-export function getDefaultComposerPlaceholder(context: KeyDisplayContext = { platform: process.platform }): string {
+function buildComposerPlaceholder(
+	keybindings: Pick<KeybindingsManager, "getDisplayString">,
+	context: KeyDisplayContext,
+	options: { readonly busy: boolean; readonly busyPromptMode: "steer" | "queue" },
+): string {
+	const parts: string[] = [];
+	const submitKey = options.busy ? keybindings.getDisplayString("tui.input.submit", context) : "";
+	if (submitKey) {
+		const submitAction = options.busyPromptMode === "steer" ? "Steer" : "Queue";
+		parts.push(`${submitKey}: ${submitAction}`);
+	}
+
+	const queueKey = keybindings.getDisplayString("app.message.queue", context);
+	const submitQueues = options.busy && options.busyPromptMode === "queue" && submitKey;
+	if (queueKey && !submitQueues) parts.push(`${queueKey}: ${options.busy ? "Queue" : "Queue (busy)"}`);
+
+	const actionHints = [
+		["app.thinking.cycle", "Thinking"],
+		["app.model.select", "Model"],
+		["app.history.search", "History"],
+	] as const;
+	for (const [id, label] of actionHints) {
+		const key = keybindings.getDisplayString(id, context);
+		if (key) parts.push(`${key}: ${label}`);
+	}
+
 	const newlineKeys = context.platform === "win32" ? ["alt+enter", "ctrl+j"] : ["shift+enter", "ctrl+j"];
-	return `Type your message... ${formatKeyHints(newlineKeys, context)}: New line · ${formatKeyHint(
-		"ctrl+c",
-		context,
-	)}: Clear · ${formatKeyHint("ctrl+r", context)}: Search history · ${formatKeyHint("shift+tab", context)}: Reasoning`;
+	parts.push(`${formatKeyHints(newlineKeys, context)}: New line`, `${formatKeyHint("ctrl+c", context)}: Clear`);
+	return `Type your message... ${parts.join(" · ")}`;
+}
+
+export function getDefaultComposerPlaceholder(
+	context: KeyDisplayContext = { platform: process.platform },
+	keybindings?: Pick<KeybindingsManager, "getDisplayString">,
+): string {
+	const effectiveKeybindings =
+		keybindings ??
+		KeybindingsManager.inMemory({
+			"app.message.queue": defaultMessageQueueKeysForPlatform(context.platform),
+		});
+	return buildComposerPlaceholder(effectiveKeybindings, context, { busy: false, busyPromptMode: "steer" });
 }
 
 export const DEFAULT_COMPOSER_PLACEHOLDER = getDefaultComposerPlaceholder();
+
+export function getComposerPlaceholder(
+	keybindings: Pick<KeybindingsManager, "getDisplayString">,
+	context: KeyDisplayContext,
+	options: { readonly busy: boolean; readonly busyPromptMode: "steer" | "queue" },
+): string {
+	return buildComposerPlaceholder(keybindings, context, options);
+}
 const WELCOME_RESERVED_CONTAINER_CHILD_LIMIT = 8;
+const COMPOSER_RIGHT_GUTTER_WIDTH = 1;
 
 const IRC_SIDEBAR_TOGGLE_SHADOWING_ACTIONS: readonly AppKeybinding[] = [
 	"app.plan.toggle",
@@ -169,7 +215,7 @@ function configureDefaultComposerChrome(editor: CustomEditor): void {
 	editor.setInputPrefix(getDefaultInputPrefix());
 	editor.setPlaceholder(getDefaultComposerPlaceholder());
 	editor.setPaddingX(1);
-	editor.setRightGutterWidth(1);
+	editor.setRightGutterWidth(COMPOSER_RIGHT_GUTTER_WIDTH);
 	editor.setTopBorder(undefined);
 }
 
@@ -510,6 +556,14 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		this.ui = new TUI(new ProcessTerminal(), settings.get("showHardwareCursor"), {
 			enableMouse: settings.get("mouse.enabled"),
+			copySelection: async text => {
+				try {
+					await copyToClipboard(text);
+					this.showStatus("Selection copied to clipboard");
+				} catch (error) {
+					this.showError(`Failed to copy selection: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			},
 		});
 		this.ui.setClearOnShrink(settings.get("clearOnShrink"));
 		this.chatContainer = new Container();
@@ -660,6 +714,7 @@ export class InteractiveMode implements InteractiveModeContext {
 					getViewportRows: () => this.ui.terminal.rows,
 					getReservedBottomRows: getWelcomeReservedBottomRows,
 					changelogMarkdown: this.#changelogMarkdown,
+					rightGutterWidth: COMPOSER_RIGHT_GUTTER_WIDTH,
 					collapseChangelog: settings.get("collapseChangelog"),
 					keyDisplayContext: this.#keyDisplayContext,
 				},
@@ -1056,27 +1111,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.session.isStreaming || this.session.isCompacting;
 	}
 
-	#getFirstKeyForAction(action: AppKeybinding): string | undefined {
-		return this.keybindings.getKeys(action)[0];
-	}
-
-	#getMessageQueueShortcut(): string | undefined {
-		const preferredAction: AppKeybinding =
-			process.platform === "darwin" ? "app.message.followUp" : "app.message.queue";
-		const fallbackAction: AppKeybinding =
-			process.platform === "darwin" ? "app.message.queue" : "app.message.followUp";
-		return this.#getFirstKeyForAction(preferredAction) ?? this.#getFirstKeyForAction(fallbackAction);
-	}
-
 	#getComposerPlaceholder(): string {
-		const defaultPlaceholder = getDefaultComposerPlaceholder(this.#keyDisplayContext);
-		if (!this.#isPromptDeliveryBusy()) return defaultPlaceholder;
-		const submitAction = this.settings.get("busyPromptMode") === "steer" ? "Steer" : "Queue";
-		const submitKey = this.keybindings.getDisplayString("tui.input.submit", this.#keyDisplayContext);
-		const parts = submitKey ? [`${submitKey}: ${submitAction}`] : [];
-		const queueKey = this.#getMessageQueueShortcut();
-		if (queueKey) parts.push(`${formatKeyHint(queueKey, this.#keyDisplayContext)}: Queue`);
-		return parts.length > 0 ? `${defaultPlaceholder} · ${parts.join(" · ")}` : defaultPlaceholder;
+		return getComposerPlaceholder(this.keybindings, this.#keyDisplayContext, {
+			busy: this.#isPromptDeliveryBusy(),
+			busyPromptMode: this.settings.get("busyPromptMode"),
+		});
 	}
 
 	#getWelcomeReservedRows(width: number): number {

package/src/modes/runtime-init.ts

@@ -115,6 +115,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
 			clearContext: () => session.clearContext(),
 			cycleModel: () => session.cycleModel(),
+			setModelProfile: name => session.activateModelProfileForControl(name),
 			cycleThinkingLevel: () => session.cycleThinkingLevel(),
 			setQueueMode: (kind, mode) => {
 				if (kind === "steering" && (mode === "all" || mode === "one-at-a-time")) {

package/src/prompts/agent-fragments/restricted-bash.md

@@ -1 +1 @@
-- Exception: restricted `bash` is only for sanctioned GJC workflow persistence (`gjc ralplan --write ...`) and GJC workflow state commands (`gjc state ...`). Pass artifacts through `GJC_RALPLAN_ARTIFACT` with `--artifact-env GJC_RALPLAN_ARTIFACT`; never use bash for product-source writes or general shell work.
+- Exception: restricted `bash` is only for sanctioned GJC workflow persistence (`gjc ralplan --write ...`), GJC workflow state commands (`gjc state ...`), and read-only git inspection (`git status`, `git log`, `git show`, `git diff`, `git blame`, `git rev-parse`, `git ls-files`). Pass artifacts through `GJC_RALPLAN_ARTIFACT` with `--artifact-env GJC_RALPLAN_ARTIFACT`; never use bash for product-source writes, commits, pushes, or other mutating/general shell work.

package/src/prompts/agents/architect.md

@@ -1,13 +1,20 @@
 ---
 name: architect
 description: Read-only architecture and code-review agent with severity-rated findings and status verdicts
-tools: read, search, find, lsp, ast_grep, web_search, bash, report_finding
+tools: read, search, find, lsp, ast_grep, web_search, bash, report_finding, irc
 thinking-level: high
 blocking: true
 forkContext: allowed
 bashAllowedPrefixes:
   - gjc ralplan --write
   - gjc state
+  - git status
+  - git log
+  - git show
+  - git diff
+  - git blame
+  - git rev-parse
+  - git ls-files
 ---
 <identity>
 You are Architect. You combine system architecture review with code-review discipline. Diagnose, analyze, and recommend with file-backed evidence. You are read-only.

package/src/prompts/agents/critic.md

@@ -1,11 +1,18 @@
 ---
 name: critic
 description: Read-only plan critic that approves only actionable, verifiable execution plans
-tools: read, search, find, lsp, ast_grep, web_search, bash
+tools: read, search, find, lsp, ast_grep, web_search, bash, irc
 thinking-level: high
 bashAllowedPrefixes:
   - gjc ralplan --write
   - gjc state
+  - git status
+  - git log
+  - git show
+  - git diff
+  - git blame
+  - git rev-parse
+  - git ls-files
 ---
 <identity>
 You are Critic. Decide whether a work plan is actionable before execution begins.

package/src/prompts/agents/executor.md

@@ -34,7 +34,7 @@ Explore just enough context, implement the smallest correct change, and leave co
 {{#if ultragoalRedTeam}}
 
 <ultragoal_red_team_mode>
-This mode activates only when the assignment explicitly labels Executor as Ultragoal completion QA/red-team or asks for `executorQa` red-team evidence. Otherwise, preserve ordinary Executor behavior.
+This mode activates only when the task sets typed `executionMode: "ultragoal-red-team"`, or — as a compatibility fallback — when the assignment text explicitly labels Executor as Ultragoal completion QA/red-team or asks for `executorQa` red-team evidence (not a bare `executorQa` field-name mention). Prefer the typed flag. Otherwise, preserve ordinary Executor behavior.
 
 When active:
 - Follow the exact `executorQa` contract provided in the assignment (matrix shape, row fields, artifact/replay rules); the runtime validates it strictly. If the assignment omits the contract, read the ultragoal SKILL's executor QA section before producing evidence.

package/src/prompts/agents/planner.md

@@ -1,11 +1,18 @@
 ---
 name: planner
 description: Read-only planning agent for sequencing, acceptance criteria, risks, and handoff shape
-tools: read, search, find, lsp, ast_grep, web_search, bash
+tools: read, search, find, lsp, ast_grep, web_search, bash, irc
 thinking-level: medium
 bashAllowedPrefixes:
   - gjc ralplan --write
   - gjc state
+  - git status
+  - git log
+  - git show
+  - git diff
+  - git blame
+  - git rev-parse
+  - git ls-files
 ---
 <identity>
 You are Planner. Turn requests into actionable work plans. You plan; you do not implement.

package/src/runtime/memory-domain.ts

@@ -0,0 +1,66 @@
+import type {
+	MemoryGuardDomainSnapshot,
+	MemoryGuardWorkerAccounting,
+	MemoryGuardWorkerSample,
+} from "./memory-guard-contract";
+
+export interface MemoryGuardDomainInput {
+	effectiveLimitBytes: number;
+	totalUsageBytes: number;
+	parentBytes: number;
+	parentReserveBytes: number;
+	workers: readonly MemoryGuardWorkerSample[];
+}
+
+function assertNonNegativeSafeInteger(name: string, value: number): number {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`invalid_${name}`);
+	return value;
+}
+
+function sumWorkerBytes(workers: readonly MemoryGuardWorkerSample[]): number {
+	let total = 0;
+	for (const worker of workers) {
+		total += assertNonNegativeSafeInteger(`worker_bytes:${worker.workerId}`, worker.bytes);
+		if (!Number.isSafeInteger(total)) throw new Error("invalid_worker_total_bytes");
+	}
+	return total;
+}
+
+export function computeMemoryGuardDomain(input: MemoryGuardDomainInput): MemoryGuardDomainSnapshot {
+	const effectiveLimitBytes = assertNonNegativeSafeInteger("effective_limit_bytes", input.effectiveLimitBytes);
+	const totalUsageBytes = assertNonNegativeSafeInteger("total_usage_bytes", input.totalUsageBytes);
+	const parentBytes = assertNonNegativeSafeInteger("parent_bytes", input.parentBytes);
+	const parentReserveBytes = assertNonNegativeSafeInteger("parent_reserve_bytes", input.parentReserveBytes);
+	const totalWorkerBytes = sumWorkerBytes(input.workers);
+	const acceptedWorkers = input.workers.filter(worker => worker.accepted !== false);
+	const acceptedWorkerBytes = sumWorkerBytes(acceptedWorkers);
+	const acceptedWorkerCount = acceptedWorkers.length;
+	const unmanagedBytes = Math.max(0, totalUsageBytes - parentBytes - acceptedWorkerBytes);
+	const headroomBytes = Math.max(0, effectiveLimitBytes - totalUsageBytes);
+	const workerBudgetBytes = Math.max(0, effectiveLimitBytes - unmanagedBytes - parentReserveBytes);
+	const perWorkerAllowanceBytes = acceptedWorkerCount === 0 ? 0 : workerBudgetBytes / acceptedWorkerCount;
+	const workers: MemoryGuardWorkerAccounting[] = input.workers.map(worker => {
+		const accepted = worker.accepted !== false;
+		return {
+			workerId: worker.workerId,
+			bytes: worker.bytes,
+			accepted,
+			allowanceBytes: accepted ? perWorkerAllowanceBytes : 0,
+			excessBytes: accepted ? Math.max(0, worker.bytes - perWorkerAllowanceBytes) : 0,
+		};
+	});
+	return {
+		effectiveLimitBytes,
+		totalUsageBytes,
+		parentBytes,
+		parentReserveBytes,
+		totalWorkerBytes,
+		acceptedWorkerCount,
+		unmanagedBytes,
+		headroomBytes,
+		workerBudgetBytes,
+		perWorkerAllowanceBytes,
+		hostExcessBytes: Math.max(0, parentBytes - parentReserveBytes),
+		workers,
+	};
+}

package/src/runtime/memory-guard-contract.ts

@@ -0,0 +1,73 @@
+export interface MemoryGuardPolicy {
+	enabled: boolean;
+	checkIntervalMs: number;
+	gcThresholdRatio: number;
+	restartThresholdRatio: number;
+	restartThresholdWindowMs: number;
+	cooldownMs: number;
+	parentReserveBytes: number;
+	policyLimitBytes: number | null;
+}
+
+export interface MemoryGuardWorkerSample {
+	workerId: string;
+	bytes: number;
+	accepted?: boolean;
+}
+
+export interface MemoryGuardWorkerAccounting {
+	workerId: string;
+	bytes: number;
+	accepted: boolean;
+	allowanceBytes: number;
+	excessBytes: number;
+}
+
+export interface MemoryGuardDomainSnapshot {
+	effectiveLimitBytes: number;
+	totalUsageBytes: number;
+	parentBytes: number;
+	parentReserveBytes: number;
+	totalWorkerBytes: number;
+	acceptedWorkerCount: number;
+	unmanagedBytes: number;
+	headroomBytes: number;
+	workerBudgetBytes: number;
+	perWorkerAllowanceBytes: number;
+	hostExcessBytes: number;
+	workers: MemoryGuardWorkerAccounting[];
+}
+
+export interface MemoryGuardHostTarget {
+	kind: "host";
+	excessBytes: number;
+}
+
+export interface MemoryGuardWorkerTarget {
+	kind: "worker";
+	workerId: string;
+	excessBytes: number;
+}
+
+export type MemoryGuardActionTarget = MemoryGuardHostTarget | MemoryGuardWorkerTarget;
+
+export type MemoryGuardNoopReason =
+	| "memory_guard_action_noop_unmanaged_or_within_allowance"
+	| "memory_guard_action_noop_unsupported";
+
+export type MemoryGuardDecision =
+	| { kind: "execute"; target: MemoryGuardActionTarget }
+	| { kind: "noop"; reason: MemoryGuardNoopReason }
+	| { kind: "revalidated_out"; reason: "memory_guard_action_revalidated_out" };
+
+export interface MemoryGuardSchedulerState {
+	timerActive: boolean;
+	registrationCount: number;
+	inProgress: boolean;
+	generation: number;
+	pendingDeadline: number | null;
+	pendingOwner: { generation: number; token: number } | null;
+	deferredDeadline: number | null;
+	deferredGeneration: number | null;
+	activeGeneration: number | null;
+}