@gajae-code/coding-agent 0.7.0 → 0.7.2

package/src/lsp/config.ts

@@ -88,6 +88,7 @@ function normalizeServerConfig(name: string, config: RawServerConfig): ServerCon
 		: isRecord(config.initializationOptions)
 			? config.initializationOptions
 			: undefined;
+	const supersedes = normalizeStringArray(config.supersedes);
 
 	return {
 		...config,
@@ -96,6 +97,7 @@ function normalizeServerConfig(name: string, config: RawServerConfig): ServerCon
 		fileTypes,
 		rootMarkers,
 		...(initOptions ? { initOptions } : {}),
+		...(supersedes ? { supersedes } : {}),
 	};
 }
 
@@ -144,6 +146,18 @@ function mergeServers(
 	return merged;
 }
 
+function applyServerPrecedence(servers: Record<string, ServerConfig>): Record<string, ServerConfig> {
+	const suppressed = new Set<string>();
+	for (const config of Object.values(servers)) {
+		for (const serverName of config.supersedes ?? []) {
+			suppressed.add(serverName);
+		}
+	}
+	if (suppressed.size === 0) return servers;
+
+	return Object.fromEntries(Object.entries(servers).filter(([name]) => !suppressed.has(name)));
+}
+
 function applyRuntimeDefaults(servers: Record<string, ServerConfig>): Record<string, ServerConfig> {
 	const updated: Record<string, ServerConfig> = { ...servers };
 
@@ -422,9 +436,8 @@ export function loadConfig(cwd: string): LspConfig {
 			detected[name] = { ...config, resolvedCommand: resolved };
 		}
 
-		return { servers: detected, idleTimeoutMs };
+		return { servers: applyServerPrecedence(detected), idleTimeoutMs };
 	}
-
 	// Merge overrides with defaults and filter to available servers
 	const mergedWithRuntime = applyRuntimeDefaults(mergedServers);
 	const available: Record<string, ServerConfig> = {};
@@ -437,7 +450,7 @@ export function loadConfig(cwd: string): LspConfig {
 		available[name] = { ...config, resolvedCommand: resolved };
 	}
 
-	return { servers: available, idleTimeoutMs };
+	return { servers: applyServerPrecedence(available), idleTimeoutMs };
 }
 
 // =============================================================================

package/src/lsp/defaults.json

@@ -342,6 +342,13 @@
 		"fileTypes": [".php"],
 		"rootMarkers": ["composer.json", ".phpactor.json", ".phpactor.yml"]
 	},
+	"csharp-ls": {
+		"command": "csharp-ls",
+		"args": [],
+		"fileTypes": [".cs", ".csx"],
+		"rootMarkers": ["*.sln", "*.slnx", "*.csproj", "global.json"],
+		"supersedes": ["omnisharp"]
+	},
 	"omnisharp": {
 		"command": "omnisharp",
 		"args": ["-z", "--hostPID", "$PID", "--encoding", "utf-8", "--languageserver"],

package/src/lsp/types.ts

@@ -358,6 +358,8 @@ export interface ServerConfig {
 	/** Per-server warmup timeout in milliseconds. Overrides the global WARMUP_TIMEOUT_MS for this server during startup. */
 	warmupTimeoutMs?: number;
 	capabilities?: ServerCapabilities;
+	/** Names of lower-precedence servers to drop when this server is available. */
+	supersedes?: string[];
 	/** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
 	isLinter?: boolean;
 	/** Resolved absolute path to the command binary (set during config loading) */

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

@@ -201,6 +201,7 @@ export class EventController {
 			this.ctx.statusContainer.clear();
 		}
 		this.#cancelIdleCompaction();
+		this.ctx.updateEditorBorderColor();
 		this.ctx.ensureLoadingAnimation();
 		this.ctx.ui.requestRender();
 	}
@@ -633,6 +634,7 @@ export class EventController {
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
 		this.#lastAssistantComponent = undefined;
+		this.ctx.updateEditorBorderColor();
 		this.ctx.ui.requestRender();
 		this.#scheduleIdleCompaction();
 		this.sendCompletionNotification();
@@ -642,6 +644,7 @@ export class EventController {
 		event: Extract<AgentSessionEvent, { type: "auto_compaction_start" }>,
 	): Promise<void> {
 		this.#cancelIdleCompaction();
+		this.ctx.updateEditorBorderColor();
 		this.ctx.autoCompactionEscapeHandler = this.ctx.editor.onEscape;
 		this.ctx.editor.onEscape = () => {
 			this.ctx.session.abortCompaction();
@@ -672,13 +675,20 @@ export class EventController {
 			this.ctx.autoCompactionLoader = undefined;
 			this.ctx.statusContainer.clear();
 		}
+		this.ctx.updateEditorBorderColor();
 		const isHandoffAction = event.action === "handoff";
+		const continuationDisabled = event.continuationSkipReason === "auto_continue_disabled_non_resumable_tail";
 		if (event.aborted) {
 			this.ctx.showStatus(isHandoffAction ? "Auto-handoff cancelled" : "Auto context-full maintenance cancelled");
 		} else if (event.result) {
 			this.ctx.rebuildChatFromMessages();
 			this.ctx.statusLine.invalidate();
 			this.ctx.updateEditorTopBorder();
+			if (continuationDisabled && !isHandoffAction) {
+				this.ctx.showStatus("Context overflow recovery skipped: auto_continue_disabled_non_resumable_tail");
+			} else if (event.willRetry && !isHandoffAction) {
+				this.ctx.showStatus("Context overflow maintenance completed");
+			}
 		} else if (event.errorMessage) {
 			this.ctx.showWarning(event.errorMessage);
 		} else if (isHandoffAction) {
@@ -691,6 +701,11 @@ export class EventController {
 		} else if (event.skipped) {
 			// Benign skip: no model selected, no candidate models available, or nothing
 			// to compact yet. Not a failure — suppress the warning.
+			if (continuationDisabled) {
+				this.ctx.showStatus("Context overflow recovery skipped: auto_continue_disabled_non_resumable_tail");
+			} else if (event.willRetry && !isHandoffAction) {
+				this.ctx.showStatus("Context overflow maintenance skipped");
+			}
 		} else {
 			this.ctx.showWarning("Auto context-full maintenance failed; continuing without maintenance");
 		}

package/src/modes/interactive-mode.ts

@@ -29,7 +29,7 @@ import {
 import { APP_NAME, adjustHsv, getProjectDir, hsvToRgb, isEnoent, logger, postmortem, prompt } from "@gajae-code/utils";
 import chalk from "chalk";
 import { AsyncJobManager } from "../async";
-import { KeybindingsManager } from "../config/keybindings";
+import { type AppKeybinding, KeybindingsManager } from "../config/keybindings";
 import { isSettingsInitialized, type Settings, settings } from "../config/settings";
 import { DEFAULT_GJC_DEFINITION_NAMES } from "../defaults/gjc-defaults";
 import type {
@@ -117,6 +117,24 @@ import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInpu
 import { UiHelpers } from "./utils/ui-helpers";
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
+const DEFAULT_COMPOSER_PLACEHOLDER = "Type your message...";
+const FRIENDLY_KEY_PARTS: Record<string, string> = {
+	alt: "Alt",
+	cmd: "Command",
+	command: "Command",
+	ctrl: "Control",
+	enter: "Enter",
+	meta: process.platform === "darwin" ? "Command" : "Meta",
+	option: "Option",
+	shift: "Shift",
+};
+
+function formatShortcutForPlaceholder(key: string): string {
+	return key
+		.split("+")
+		.map(part => FRIENDLY_KEY_PARTS[part.toLowerCase()] ?? part)
+		.join("+");
+}
 
 const HINT_SHIMMER_PALETTE: ShimmerPalette = {
 	low: "dim",
@@ -141,7 +159,7 @@ function configureDefaultComposerChrome(editor: CustomEditor): void {
 	editor.setClosedBorderBox(true);
 	editor.setPromptGutter(undefined);
 	editor.setInputPrefix(getDefaultInputPrefix());
-	editor.setPlaceholder("Type your message...");
+	editor.setPlaceholder(DEFAULT_COMPOSER_PLACEHOLDER);
 	editor.setPaddingX(1);
 	editor.setTopBorder(undefined);
 }
@@ -903,6 +921,31 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.editor.setMaxHeight(this.#computeEditorMaxHeight());
 	}
 
+	#isPromptDeliveryBusy(): boolean {
+		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 {
+		if (!this.#isPromptDeliveryBusy()) return DEFAULT_COMPOSER_PLACEHOLDER;
+		const enterAction = this.settings.get("busyPromptMode") === "steer" ? "Steering" : "Message Queueing";
+		const parts = [`Enter: ${enterAction}`];
+		const queueKey = this.#getMessageQueueShortcut();
+		if (queueKey) parts.push(`${formatShortcutForPlaceholder(queueKey)}: Message Queueing`);
+		return `${DEFAULT_COMPOSER_PLACEHOLDER} ${parts.join(" · ")}`;
+	}
+
 	updateEditorChrome(): void {
 		if (this.isBashMode) {
 			this.editor.borderColor = this.isBashNoContext
@@ -926,6 +969,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (!this.isBashMode) {
 			this.editor.setInputPrefix(getDefaultInputPrefix());
 		}
+		this.editor.setPlaceholder(this.#getComposerPlaceholder());
 		this.#setComposerTopBorder();
 		this.ui.requestRender();
 	}

package/src/modes/utils/context-usage.ts

@@ -204,14 +204,14 @@ export function computeContextBreakdown(
 	if (contextWindow > 0) {
 		const compactionSettings = session.settings.getGroup("compaction") as CompactionSettings;
 		if (compactionSettings.enabled && compactionSettings.strategy !== "off") {
-			const threshold = resolveThresholdTokens(contextWindow, compactionSettings, model?.maxTokens ?? 0);
+			const threshold = resolveThresholdTokens(contextWindow, compactionSettings);
 			autoCompactBufferTokens = Math.max(0, contextWindow - threshold);
 		} else {
 			autoCompactBufferTokens = 0;
 		}
 		// Even when fully disabled, fall back to a sensible reserve floor for display.
 		if (autoCompactBufferTokens === 0 && compactionSettings.enabled) {
-			autoCompactBufferTokens = effectiveReserveTokens(contextWindow, compactionSettings, model?.maxTokens ?? 0);
+			autoCompactBufferTokens = effectiveReserveTokens(contextWindow, compactionSettings);
 		}
 	}
 	autoCompactBufferTokens = Math.min(autoCompactBufferTokens, Math.max(0, contextWindow - usedTokens));

package/src/notifications/attachment-registry.ts

@@ -0,0 +1,23 @@
+/**
+ * Process-wide registry mapping a session id to a sink that delivers a local
+ * file to the session's connected Telegram chat as a document. Registered by
+ * the notifications extension; consumed by the telegram_send tool.
+ */
+
+/** Delivers a local file to the session's Telegram chat. */
+export type TelegramFileSink = (file: { path: string; caption?: string }) => Promise<{ ok: boolean; error?: string }>;
+
+const sinks = new Map<string, TelegramFileSink>();
+
+/** Register `sink` for `sessionId`. Returns a disposer that clears it. */
+export function registerTelegramFileSink(sessionId: string, sink: TelegramFileSink): () => void {
+	sinks.set(sessionId, sink);
+	return () => {
+		if (sinks.get(sessionId) === sink) sinks.delete(sessionId);
+	};
+}
+
+/** The Telegram file sink for `sessionId`, if one is registered. */
+export function getTelegramFileSink(sessionId: string): TelegramFileSink | undefined {
+	return sinks.get(sessionId);
+}

package/src/notifications/chat-adapters.ts

@@ -0,0 +1,147 @@
+import type {
+	NotificationAdapterPayload,
+	NotificationEvent,
+	NotificationPresentationAdapter,
+	NotificationReplyRoute,
+} from "./engine";
+import { truncate } from "./helpers";
+
+type AdapterKind = "discord" | "slack";
+
+interface ChatAdapterOptions {
+	kind: AdapterKind;
+	channelId?: string;
+}
+
+interface InboundShape {
+	sessionId?: unknown;
+	actionId?: unknown;
+	answer?: unknown;
+	text?: unknown;
+	value?: unknown;
+}
+
+function text(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function publicLine(label: string, value: unknown): string | undefined {
+	const v = text(value);
+	return v ? `${label}: ${truncate(v, 280)}` : undefined;
+}
+
+function actionText(event: Extract<NotificationEvent, { type: "action_needed" }>, format: "discord" | "slack"): string {
+	if (event.kind === "idle") {
+		const summary = text(event.summary);
+		return summary ? `Agent idle\n${truncate(summary, 1200)}` : "Agent idle";
+	}
+	const question = truncate(text(event.question) ?? "Question", 1200);
+	const options = Array.isArray(event.options) ? event.options.map(option => String(option)) : [];
+	const lines = [`Question: ${question}`];
+	if (options.length > 0) {
+		lines.push(
+			...options.map((option, index) => {
+				const label = truncate(option, 180);
+				return format === "slack" ? `${index + 1}. ${label}` : `**${index + 1}.** ${label}`;
+			}),
+		);
+	} else {
+		lines.push("Reply with text.");
+	}
+	return lines.join("\n");
+}
+
+function frameText(event: Extract<NotificationEvent, { type: "frame" }>): string | undefined {
+	const frame = event.frame;
+	const kind = text(frame.type);
+	if (!kind) return undefined;
+	const lines = [`GJC ${kind.replace(/_/g, " ")}`];
+	for (const line of [
+		publicLine("title", frame.title),
+		publicLine("repo", frame.repo),
+		publicLine("branch", frame.branch),
+		publicLine("task", frame.task),
+		publicLine("goal", frame.goal),
+		publicLine("model", frame.model),
+	]) {
+		if (line) lines.push(line);
+	}
+	const body = text(frame.text) ?? text(frame.lastMessage) ?? text(frame.caption);
+	if (body) lines.push(truncate(body, 1800));
+	return lines.join("\n");
+}
+
+function routeFromInbound(input: unknown): NotificationReplyRoute | undefined {
+	const raw = input as InboundShape;
+	if (!raw || typeof raw !== "object") return undefined;
+	const sessionId = text(raw.sessionId);
+	const actionId = text(raw.actionId);
+	if (!sessionId || !actionId) return undefined;
+	const answer = raw.answer ?? raw.value ?? raw.text;
+	if (typeof answer !== "string" && typeof answer !== "number" && typeof answer !== "object") return undefined;
+	return { sessionId, actionId, answer: answer as NotificationReplyRoute["answer"] };
+}
+
+class DiscordNotificationAdapter implements NotificationPresentationAdapter {
+	readonly kind = "discord" as const;
+	constructor(private readonly opts: ChatAdapterOptions) {}
+
+	render(event: NotificationEvent): NotificationAdapterPayload[] {
+		if (event.type === "action_resolved") return [];
+		const content = event.type === "action_needed" ? actionText(event, "discord") : frameText(event);
+		if (!content) return [];
+		const payload: Record<string, unknown> = {
+			content,
+			allowed_mentions: { parse: [] },
+		};
+		if (this.opts.channelId) payload.channel_id = this.opts.channelId;
+		return [
+			{
+				adapter: this.kind,
+				channelKey: this.opts.channelId,
+				body: payload,
+				route: event.type === "action_needed" ? { sessionId: event.sessionId, actionId: event.id } : undefined,
+			},
+		];
+	}
+
+	mapInbound(input: unknown): NotificationReplyRoute | undefined {
+		return routeFromInbound(input);
+	}
+}
+
+class SlackNotificationAdapter implements NotificationPresentationAdapter {
+	readonly kind = "slack" as const;
+	constructor(private readonly opts: ChatAdapterOptions) {}
+
+	render(event: NotificationEvent): NotificationAdapterPayload[] {
+		if (event.type === "action_resolved") return [];
+		const textValue = event.type === "action_needed" ? actionText(event, "slack") : frameText(event);
+		if (!textValue) return [];
+		const payload: Record<string, unknown> = {
+			text: textValue,
+			mrkdwn: true,
+		};
+		if (this.opts.channelId) payload.channel = this.opts.channelId;
+		return [
+			{
+				adapter: this.kind,
+				channelKey: this.opts.channelId,
+				body: payload,
+				route: event.type === "action_needed" ? { sessionId: event.sessionId, actionId: event.id } : undefined,
+			},
+		];
+	}
+
+	mapInbound(input: unknown): NotificationReplyRoute | undefined {
+		return routeFromInbound(input);
+	}
+}
+
+export function createDiscordAdapter(opts: Omit<ChatAdapterOptions, "kind"> = {}): NotificationPresentationAdapter {
+	return new DiscordNotificationAdapter({ ...opts, kind: "discord" });
+}
+
+export function createSlackAdapter(opts: Omit<ChatAdapterOptions, "kind"> = {}): NotificationPresentationAdapter {
+	return new SlackNotificationAdapter({ ...opts, kind: "slack" });
+}

package/src/notifications/config.ts

@@ -5,6 +5,14 @@ export interface NotificationConfig {
 	enabled: boolean;
 	botToken?: string;
 	chatId?: string;
+	discord: {
+		botToken?: string;
+		channelId?: string;
+	};
+	slack: {
+		botToken?: string;
+		channelId?: string;
+	};
 	redact: boolean;
 	verbosity: "lean" | "verbose";
 	idleTimeoutMs: number;
@@ -16,15 +24,28 @@ export function getNotificationConfig(settings: Settings): NotificationConfig {
 		enabled: settings.get("notifications.enabled"),
 		botToken: settings.get("notifications.telegram.botToken"),
 		chatId: settings.get("notifications.telegram.chatId"),
+		discord: {
+			botToken: settings.get("notifications.discord.botToken"),
+			channelId: settings.get("notifications.discord.channelId"),
+		},
+		slack: {
+			botToken: settings.get("notifications.slack.botToken"),
+			channelId: settings.get("notifications.slack.channelId"),
+		},
 		redact: settings.get("notifications.redact"),
 		verbosity: settings.get("notifications.verbosity") === "verbose" ? "verbose" : "lean",
 		idleTimeoutMs: settings.get("notifications.daemon.idleTimeoutMs"),
 	};
 }
 
-/** Is global config sufficient for auto-on (enabled + botToken + chatId all present)? */
+/** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
 export function isGloballyConfigured(cfg: NotificationConfig): boolean {
-	return cfg.enabled && Boolean(cfg.botToken) && Boolean(cfg.chatId);
+	return (
+		cfg.enabled &&
+		((Boolean(cfg.botToken) && Boolean(cfg.chatId)) ||
+			(Boolean(cfg.discord.botToken) && Boolean(cfg.discord.channelId)) ||
+			(Boolean(cfg.slack.botToken) && Boolean(cfg.slack.channelId)))
+	);
 }
 
 /** Resolve whether the notifications extension should be registered at SDK startup. */

package/src/notifications/engine.ts

@@ -0,0 +1,100 @@
+import { buildRedactedAction, type RedactableAction } from "./config";
+
+export type NotificationEvent =
+	| ({ type: "action_needed" } & RedactableAction)
+	| { type: "action_resolved"; id: string; sessionId: string; resolvedBy?: string }
+	| { type: "frame"; sessionId: string; frame: Record<string, unknown> };
+
+export interface NotificationReplyRoute {
+	sessionId: string;
+	actionId: string;
+	answer: number | string | { selected?: Array<number | string>; custom?: string };
+}
+
+export interface NotificationAdapterPayload {
+	adapter: string;
+	channelKey?: string;
+	body: unknown;
+	route?: Omit<NotificationReplyRoute, "answer">;
+}
+
+export interface NotificationPresentationAdapter {
+	readonly kind: "telegram" | "discord" | "slack";
+	render(event: NotificationEvent): NotificationAdapterPayload[];
+	mapInbound(input: unknown): NotificationReplyRoute | undefined;
+}
+
+export interface EngineSessionSink {
+	sendReply(route: NotificationReplyRoute): void;
+}
+
+export interface NotificationEngineOptions {
+	redact: boolean;
+	sessionTag: (sessionId: string) => string;
+}
+
+/**
+ * Shared presentation engine for managed notification clients.
+ *
+ * It owns fanout, redaction boundaries, pending-action routing, and reply
+ * delivery into session sinks. Transport adapters stay pure: render an internal
+ * event into a public-safe payload and map an inbound transport interaction
+ * back into a session/action answer.
+ */
+export class NotificationPresentationEngine {
+	readonly adapters: readonly NotificationPresentationAdapter[];
+	private readonly sessions = new Map<string, EngineSessionSink>();
+	private readonly pending = new Map<string, { sessionId: string; actionId: string }>();
+
+	constructor(
+		adapters: readonly NotificationPresentationAdapter[],
+		private readonly opts: NotificationEngineOptions,
+	) {
+		this.adapters = adapters;
+	}
+
+	connectSession(sessionId: string, sink: EngineSessionSink): void {
+		this.sessions.set(sessionId, sink);
+	}
+
+	dropSession(sessionId: string): void {
+		this.sessions.delete(sessionId);
+		for (const [key, route] of this.pending) {
+			if (route.sessionId === sessionId) this.pending.delete(key);
+		}
+	}
+
+	fanout(event: NotificationEvent): NotificationAdapterPayload[] {
+		const safeEvent = this.redactEvent(event);
+		if (safeEvent.type === "action_needed" && safeEvent.kind === "ask") {
+			this.pending.set(safeEvent.id, { sessionId: safeEvent.sessionId, actionId: safeEvent.id });
+		}
+		if (safeEvent.type === "action_resolved") {
+			this.pending.delete(safeEvent.id);
+		}
+		return this.adapters.flatMap(adapter => adapter.render(safeEvent));
+	}
+
+	routeInbound(adapterKind: NotificationPresentationAdapter["kind"], input: unknown): boolean {
+		const adapter = this.adapters.find(candidate => candidate.kind === adapterKind);
+		const route = adapter?.mapInbound(input);
+		if (!route) return false;
+		const pending = this.pending.get(route.actionId);
+		if (!pending || pending.sessionId !== route.sessionId) return false;
+		const sink = this.sessions.get(route.sessionId);
+		if (!sink) return false;
+		sink.sendReply(route);
+		return true;
+	}
+
+	private redactEvent(event: NotificationEvent): NotificationEvent {
+		if (event.type !== "action_needed") return event;
+		return {
+			...buildRedactedAction(event, {
+				redact: this.opts.redact,
+				sessionTag: this.opts.sessionTag(event.sessionId),
+			}),
+			type: "action_needed",
+		};
+	}
+}