@gajae-code/coding-agent 0.8.1 → 0.8.2

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

@@ -8,11 +8,12 @@ import {
 	activateModelProfile,
 	type MaterializeModelProfileForDeletionResult,
 	materializeActiveModelProfileAssignment,
+	materializeActiveModelProfileAssignments,
 	materializeModelProfileForDeletion,
 	restoreMaterializedModelProfileForDeletion,
 } from "../../config/model-profile-activation";
 import { formatModelProfileDisplayLabel, recommendModelProfileForProvider } from "../../config/model-profiles";
-import { GJC_MODEL_ASSIGNMENT_TARGETS } from "../../config/model-registry";
+import { GJC_MODEL_ASSIGNMENT_TARGETS, type GjcModelAssignmentTargetId } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
 import { type Settings, settings } from "../../config/settings";
@@ -438,6 +439,7 @@ export class SelectorController {
 						availableThinkingLevels: [...this.ctx.session.getAvailableThinkingLevels()],
 						thinkingLevel: this.ctx.session.thinkingLevel,
 						availableThemes,
+						availableModelProfiles: [...this.ctx.session.modelRegistry.getModelProfiles().keys()],
 						cwd: getProjectDir(),
 					},
 					{
@@ -634,6 +636,18 @@ export class SelectorController {
 				this.ctx.updateEditorBorderColor();
 				break;
 
+			case "modelProfile.default": {
+				// Applying the default profile live mirrors the /model preset flow so the
+				// running session switches immediately, not only on next startup.
+				const profileName = typeof value === "string" ? value : "";
+				if (!profileName) break;
+				this.#applyModelProfile(profileName, true)
+					.then(() => this.ctx.ui.requestRender())
+					.catch(error => {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					});
+				break;
+			}
 			case "clearOnShrink":
 				this.ctx.ui.setClearOnShrink(value as boolean);
 				break;
@@ -784,6 +798,29 @@ export class SelectorController {
 		}
 	}
 
+	/**
+	 * Activate a model profile through the shared /model + /settings path: swap the
+	 * live session model (and, when persistDefault, persist it as the startup
+	 * default) then refresh the status surfaces. Rethrows so callers surface errors.
+	 */
+	async #applyModelProfile(profileName: string, persistDefault: boolean): Promise<void> {
+		const profileLabel = formatModelProfileDisplayLabel(
+			this.ctx.session.modelRegistry.getModelProfile(profileName) ?? { name: profileName },
+		);
+		await activateModelProfile(
+			{
+				session: this.ctx.session,
+				modelRegistry: this.ctx.session.modelRegistry,
+				settings: this.ctx.settings,
+				profileName,
+			},
+			{ persistDefault },
+		);
+		this.ctx.statusLine.invalidate();
+		this.ctx.updateEditorBorderColor();
+		this.ctx.showStatus(persistDefault ? `Default model profile: ${profileLabel}` : `Model profile: ${profileLabel}`);
+	}
+
 	showModelSelector(options?: { temporaryOnly?: boolean }): void {
 		this.showSelector(done => {
 			let modelSelector: ModelSelectorComponent;
@@ -809,27 +846,7 @@ export class SelectorController {
 							return;
 						}
 						if (selection.kind === "profile") {
-							const profileLabel = formatModelProfileDisplayLabel(
-								this.ctx.session.modelRegistry.getModelProfile(selection.profileName) ?? {
-									name: selection.profileName,
-								},
-							);
-							await activateModelProfile(
-								{
-									session: this.ctx.session,
-									modelRegistry: this.ctx.session.modelRegistry,
-									settings: this.ctx.settings,
-									profileName: selection.profileName,
-								},
-								{ persistDefault: selection.setDefault },
-							);
-							this.ctx.statusLine.invalidate();
-							this.ctx.updateEditorBorderColor();
-							this.ctx.showStatus(
-								selection.setDefault
-									? `Default model profile: ${profileLabel}`
-									: `Model profile: ${profileLabel}`,
-							);
+							await this.#applyModelProfile(selection.profileName, selection.setDefault);
 							done();
 							this.ctx.ui.requestRender();
 							return;
@@ -843,6 +860,79 @@ export class SelectorController {
 							this.ctx.showStatus(`Temporary model: ${selectedSelector ?? model.id}`);
 							done();
 							this.ctx.ui.requestRender();
+						} else if (selection.roles) {
+							const targetRoles: readonly GjcModelAssignmentTargetId[] = selection.roles;
+							const includesDefault = targetRoles.includes("default");
+							const includesRoleAgent = targetRoles.some(targetRole => targetRole !== "default");
+							if (includesRoleAgent) {
+								const apiKey = await this.ctx.session.modelRegistry.getApiKey(
+									model,
+									this.ctx.session.sessionId,
+								);
+								if (!apiKey) {
+									throw new Error(`No API key for ${model.provider}/${model.id}`);
+								}
+							}
+							const value =
+								selectedSelector ?? formatModelSelectorValue(`${model.provider}/${model.id}`, thinkingLevel);
+							const assignments = new Map<GjcModelAssignmentTargetId, string>();
+							for (const targetRole of targetRoles) assignments.set(targetRole, value);
+							const defaultSelector =
+								selectedSelector && thinkingLevel && selectedSelector.endsWith(`:${thinkingLevel}`)
+									? selectedSelector.slice(0, -thinkingLevel.length - 1)
+									: selectedSelector;
+
+							if (includesDefault) {
+								await this.ctx.session.setModel(model, "default", {
+									selector: defaultSelector,
+									thinkingLevel,
+								});
+								if (thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit) {
+									this.ctx.session.setThinkingLevel(thinkingLevel);
+								}
+							}
+							const materializedProfile = materializeActiveModelProfileAssignments({
+								session: this.ctx.session,
+								settings: this.ctx.settings,
+								assignments,
+							});
+							if (!materializedProfile) {
+								const overrides = this.ctx.settings.get("task.agentModelOverrides");
+								const nextOverrides = { ...overrides };
+								let writesOverrides = false;
+								for (const targetRole of targetRoles) {
+									const target = GJC_MODEL_ASSIGNMENT_TARGETS[targetRole];
+									if (target.settingsPath === "modelRoles") {
+										this.ctx.settings.setModelRole(targetRole, value);
+									} else {
+										nextOverrides[targetRole] = value;
+										writesOverrides = true;
+									}
+								}
+								if (writesOverrides) {
+									this.ctx.settings.set("task.agentModelOverrides", nextOverrides);
+								}
+							}
+							modelSelector.refreshRoleAssignments({
+								currentModel: this.ctx.session.model,
+								currentThinkingLevel: this.ctx.session.thinkingLevel,
+								activeModelProfile:
+									this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
+							});
+							this.ctx.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
+							this.ctx.statusLine.invalidate();
+							this.ctx.updateEditorBorderColor();
+							await this.ctx.notifyConfigChanged?.();
+							const labels = targetRoles.map(
+								targetRole => GJC_MODEL_ASSIGNMENT_TARGETS[targetRole].tag ?? targetRole.toUpperCase(),
+							);
+							this.ctx.showStatus(
+								includesDefault
+									? `All model targets set to ${value} for ${labels.join(", ")}.`
+									: `Role-agent models set to ${value} for ${labels.join(", ")}.`,
+							);
+							done();
+							this.ctx.ui.requestRender();
 						} else if (role === "default") {
 							// Default: update agent state and persist as the active default model.
 							await this.ctx.session.setModel(model, role, {
@@ -880,19 +970,21 @@ export class SelectorController {
 							}
 							const value =
 								selectedSelector ?? formatModelSelectorValue(`${model.provider}/${model.id}`, thinkingLevel);
-							const materializedProfile = materializeActiveModelProfileAssignment({
+							const assignments = new Map<GjcModelAssignmentTargetId, string>([[role, value]]);
+							const materializedProfile = materializeActiveModelProfileAssignments({
 								session: this.ctx.session,
 								settings: this.ctx.settings,
-								role,
-								selector: value,
+								assignments,
 							});
 							if (!materializedProfile) {
 								const target = GJC_MODEL_ASSIGNMENT_TARGETS[role];
 								if (target.settingsPath === "modelRoles") {
 									this.ctx.settings.setModelRole(role, value);
 								} else {
-									const overrides = this.ctx.settings.get("task.agentModelOverrides");
-									this.ctx.settings.set("task.agentModelOverrides", { ...overrides, [role]: value });
+									this.ctx.settings.set("task.agentModelOverrides", {
+										...this.ctx.settings.get("task.agentModelOverrides"),
+										[role]: value,
+									});
 								}
 							}
 							modelSelector.refreshRoleAssignments({
@@ -902,6 +994,9 @@ export class SelectorController {
 									this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
 							});
 							this.ctx.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
+							this.ctx.statusLine.invalidate();
+							this.ctx.updateEditorBorderColor();
+							await this.ctx.notifyConfigChanged?.();
 							this.ctx.showStatus(`${role} agent model: ${value}`);
 							done();
 							this.ctx.ui.requestRender();

package/src/modes/interactive-mode.ts

@@ -117,12 +117,14 @@ 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 COMPOSER_NEWLINE_HINT = process.platform === "win32" ? "Alt+Enter/Ctrl+J" : "Shift+Enter/Ctrl+J";
+const DEFAULT_COMPOSER_PLACEHOLDER = `Type your message... ${COMPOSER_NEWLINE_HINT}: New line · Ctrl+C: Clear · Shift+Tab: Reasoning`;
+const WELCOME_RESERVED_CONTAINER_CHILD_LIMIT = 8;
 const FRIENDLY_KEY_PARTS: Record<string, string> = {
 	alt: "Alt",
-	cmd: "Command",
-	command: "Command",
-	ctrl: "Control",
+	cmd: "Cmd",
+	command: "Cmd",
+	ctrl: "Ctrl",
 	enter: "Enter",
 	meta: process.platform === "darwin" ? "Command" : "Meta",
 	option: "Option",
@@ -132,7 +134,7 @@ const FRIENDLY_KEY_PARTS: Record<string, string> = {
 function formatShortcutForPlaceholder(key: string): string {
 	return key
 		.split("+")
-		.map(part => FRIENDLY_KEY_PARTS[part.toLowerCase()] ?? part)
+		.map(part => FRIENDLY_KEY_PARTS[part.toLowerCase()] ?? (part.length === 1 ? part.toUpperCase() : part))
 		.join("+");
 }
 
@@ -443,7 +445,6 @@ export class InteractiveMode implements InteractiveModeContext {
 			logger.warn("History storage unavailable", { error: String(error) });
 		}
 		this.hookWidgetContainerAbove = new Container();
-		this.hookWidgetContainerAbove.addChild(new Spacer(1));
 		this.hookWidgetContainerBelow = new Container();
 		this.editorContainer = new Container();
 		this.editorContainer.addChild(this.editor);
@@ -531,13 +532,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 
 		if (!startupQuiet) {
-			const getWelcomeReservedBottomRows = (width: number): number =>
-				[
-					this.statusLine,
-					this.hookWidgetContainerAbove,
-					this.editorContainer,
-					this.hookWidgetContainerBelow,
-				].reduce((rows, component) => rows + component.render(width).length, 0);
+			const getWelcomeReservedBottomRows = (width: number): number => this.#getWelcomeReservedRows(width);
 
 			// Add welcome header
 			this.#welcomeComponent = new WelcomeComponent(
@@ -940,11 +935,37 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	#getComposerPlaceholder(): string {
 		if (!this.#isPromptDeliveryBusy()) return DEFAULT_COMPOSER_PLACEHOLDER;
-		const enterAction = this.settings.get("busyPromptMode") === "steer" ? "Steering" : "Message Queueing";
+		const enterAction = this.settings.get("busyPromptMode") === "steer" ? "Steer" : "Queue";
 		const parts = [`Enter: ${enterAction}`];
 		const queueKey = this.#getMessageQueueShortcut();
-		if (queueKey) parts.push(`${formatShortcutForPlaceholder(queueKey)}: Message Queueing`);
-		return `${DEFAULT_COMPOSER_PLACEHOLDER} ${parts.join(" · ")}`;
+		if (queueKey) parts.push(`${formatShortcutForPlaceholder(queueKey)}: Queue`);
+		return `${DEFAULT_COMPOSER_PLACEHOLDER} · ${parts.join(" · ")}`;
+	}
+
+	#getWelcomeReservedRows(width: number): number {
+		const transientRows = [
+			this.chatContainer,
+			this.pendingMessagesContainer,
+			this.statusContainer,
+			this.todoContainer,
+			this.btwContainer,
+		].reduce((rows, container) => rows + this.#renderShortContainerRowsForWelcomeReservation(width, container), 0);
+
+		const pinnedRows = [
+			this.statusLine,
+			this.hookWidgetContainerAbove,
+			this.editorContainer,
+			this.hookWidgetContainerBelow,
+		].reduce((rows, component) => rows + component.render(width).length, 0);
+
+		return transientRows + pinnedRows;
+	}
+
+	#renderShortContainerRowsForWelcomeReservation(width: number, container: Container): number {
+		if (container.children.length === 0 || container.children.length > WELCOME_RESERVED_CONTAINER_CHILD_LIMIT) {
+			return 0;
+		}
+		return container.render(width).length;
 	}
 
 	updateEditorChrome(): void {
@@ -1351,6 +1372,12 @@ export class InteractiveMode implements InteractiveModeContext {
 			return;
 		}
 
+		// Leaving plan mode invalidates the plan-mode steering and standing
+		// resolve handler that the in-flight turn may still be acting on. Abort
+		// before clearing that state so the model cannot continue from stale
+		// plan-mode context and retry `resolve` against a retired handler.
+		await this.session.abort({ timeoutMs: INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS });
+
 		const previousTools = this.#planModePreviousTools;
 		if (previousTools && previousTools.length > 0) {
 			await this.session.setActiveToolsByName(previousTools);

package/src/modes/print-mode.ts

@@ -5,7 +5,7 @@
  * - `gjc -p "prompt"` - text output
  * - `gjc --mode json "prompt"` - JSON event stream
  */
-import type { AssistantMessage, ImageContent } from "@gajae-code/ai";
+import { type AssistantMessage, type ImageContent, isContextOverflow } from "@gajae-code/ai";
 import { logger, sanitizeText } from "@gajae-code/utils";
 import type { AgentSession } from "../session/agent-session";
 import { isSilentAbort } from "../session/messages";
@@ -31,6 +31,33 @@ export interface PrintModeOptions {
 	suppressProcessExit?: boolean;
 }
 
+/**
+ * Exit code used when a non-interactive **text-mode** run (`gjc -p`) terminates
+ * because the model context window is exhausted and automatic compaction could
+ * not bring the request under the limit. Distinct from the generic failure code
+ * (1) so text-mode callers can detect context exhaustion specifically instead of
+ * parsing the raw provider error string.
+ *
+ * Scope: text-mode final-response path only. JSON mode (`--mode json`) streams
+ * events from the subscription and does not run this terminal-error branch, so
+ * it is intentionally NOT covered by this exit code.
+ */
+export const CONTEXT_OVERFLOW_EXIT_CODE = 2;
+
+/**
+ * Build an actionable stderr diagnostic for a terminal context-overflow error in
+ * text mode. The raw provider message is preserved (appended) for debugging, but
+ * the leading guidance explains what happened and what the operator can do —
+ * tailored to whether auto-compaction was even enabled.
+ */
+function formatContextOverflowError(message: AssistantMessage, autoCompactionEnabled: boolean): string {
+	const providerDetail = message.errorMessage ? ` (provider error: ${sanitizeText(message.errorMessage)})` : "";
+	const guidance = autoCompactionEnabled
+		? "Context window exhausted: automatic compaction ran but could not reduce the request below the model's context limit. Reduce the input size (smaller file reads / tool output), raise the compaction threshold, or switch to a larger-context model."
+		: "Context window exhausted and automatic compaction is disabled. Enable it (compaction.enabled=true with a non-off compaction.strategy) so GJC can compact and continue, reduce the input size, or switch to a larger-context model.";
+	return `${guidance}${providerDetail}`;
+}
+
 /**
  * Run in print (single-shot) mode.
  * Sends prompts to the agent and outputs the result.
@@ -88,15 +115,27 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				(assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") &&
 				!isSilentAbort(assistantMsg.errorMessage)
 			) {
-				const errorLine = sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+				// Context-overflow is an expected, recoverable-in-principle condition — not
+				// an opaque crash. Auto-compaction has already run inside session.prompt();
+				// if we still land here the request could not be made to fit. In this
+				// text-mode final-response path, surface an actionable diagnostic and a
+				// distinct exit code so text-mode (`gjc -p`) callers can detect context
+				// exhaustion instead of parsing the raw provider error string. (JSON mode
+				// does not reach this branch and is intentionally out of scope.)
+				const isOverflow =
+					assistantMsg.stopReason === "error" && isContextOverflow(assistantMsg, session.model?.contextWindow);
+				const errorLine = isOverflow
+					? formatContextOverflowError(assistantMsg, session.autoCompactionEnabled)
+					: sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+				const exitCode = isOverflow ? CONTEXT_OVERFLOW_EXIT_CODE : 1;
 				const flushed = process.stderr.write(`${errorLine}\n`);
 				// When the caller owns finalization (RLM autonomous), return instead of
 				// exiting so its cleanup runs; the caller surfaces a non-zero exit itself.
 				if (!options.suppressProcessExit) {
 					if (flushed) {
-						process.exit(1);
+						process.exit(exitCode);
 					} else {
-						process.stderr.once("drain", () => process.exit(1));
+						process.stderr.once("drain", () => process.exit(exitCode));
 					}
 				}
 			}

package/src/modes/prompt-action-autocomplete.ts

@@ -1,5 +1,12 @@
-import type { AutocompleteItem, AutocompleteProvider, SlashCommand } from "@gajae-code/tui";
-import { CombinedAutocompleteProvider, getKeybindings, getSlashCommandMatchRank } from "@gajae-code/tui";
+import {
+	type AutocompleteItem,
+	type AutocompleteProvider,
+	CombinedAutocompleteProvider,
+	extractSlashCommandTokenPrefix,
+	getKeybindings,
+	getSlashCommandMatchRank,
+	type SlashCommand,
+} from "@gajae-code/tui";
 import type { KeybindingsManager } from "../config/keybindings";
 import { formatKeyHints } from "../config/keybindings";
 import { isSettingsInitialized, settings } from "../config/settings";
@@ -147,6 +154,10 @@ function sortSlashCommandSuggestions(
 	return { ...suggestions, items };
 }
 
+function isRootPathSuggestionResult(suggestions: { items: AutocompleteItem[]; prefix: string } | null): boolean {
+	return suggestions?.prefix.startsWith("/") === true && suggestions.items.some(item => item.value.startsWith("/"));
+}
+
 function withoutSkillCommandSuggestions(
 	suggestions: { items: AutocompleteItem[]; prefix: string } | null,
 ): { items: AutocompleteItem[]; prefix: string } | null {
@@ -168,18 +179,9 @@ function getPromptActionPrefix(textBeforeCursor: string): string | null {
 }
 
 function getSlashTokenPrefix(textBeforeCursor: string): string | null {
-	const slashIndex = textBeforeCursor.lastIndexOf("/");
-	if (slashIndex === -1) return null;
-	const beforeSlash = textBeforeCursor.slice(0, slashIndex);
-	if (beforeSlash && !/\s$/.test(beforeSlash)) return null;
-	const token = textBeforeCursor.slice(slashIndex);
-	if (/[\s]/.test(token)) return null;
-	return token;
+	return extractSlashCommandTokenPrefix(textBeforeCursor);
 }
 
-function isLeadingSlashToken(textBeforeCursor: string, slashPrefix: string): boolean {
-	return textBeforeCursor.trimStart() === slashPrefix;
-}
 export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	#baseProvider: CombinedAutocompleteProvider;
 	#actions: PromptActionDefinition[];
@@ -226,14 +228,13 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 
 		const slashPrefix = getSlashTokenPrefix(textBeforeCursor);
 		if (slashPrefix) {
-			const isLeading = isLeadingSlashToken(textBeforeCursor, slashPrefix);
-			const baseSuggestions = isLeading
-				? withoutSkillCommandSuggestions(await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol))
-				: null;
-			const skillCommandSuggestions =
-				isLeading || slashPrefix.startsWith("/skill")
-					? this.#getSkillCommandSuggestions(textBeforeCursor, { includeEmpty: isLeading })
-					: null;
+			const baseSuggestions = withoutSkillCommandSuggestions(
+				await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol),
+			);
+			if (isRootPathSuggestionResult(baseSuggestions)) return baseSuggestions;
+			const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor, {
+				includeEmpty: false,
+			});
 			return sortSlashCommandSuggestions(
 				mergeAutocompleteSuggestions(baseSuggestions, skillCommandSuggestions),
 				this.#commands,

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

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

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

@@ -599,8 +599,8 @@ export class UiHelpers {
 				const queuedText = theme.fg("dim", `${entry.label}: ${entry.message}`);
 				this.ctx.pendingMessagesContainer.addChild(new TruncatedText(queuedText, 1, 0));
 			}
-			const dequeueKey = this.ctx.keybindings.getDisplayString("app.message.dequeue") || "Alt+Up";
-			const hintText = theme.fg("dim", `${theme.tree.hook} ${dequeueKey} to edit`);
+			const dequeueKey = this.ctx.keybindings.getDisplayString("app.message.dequeue") || "Alt+Up/Alt+Down";
+			const hintText = theme.fg("dim", `${theme.tree.hook} ${dequeueKey} to select/edit/reorder`);
 			this.ctx.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
 		}
 	}

package/src/notifications/config.ts

@@ -52,7 +52,14 @@ export function isGloballyConfigured(cfg: NotificationConfig): boolean {
 export function shouldRegisterNotificationsExtension(input: {
 	env: NodeJS.ProcessEnv;
 	cfg?: NotificationConfig;
+	/** Task recursion depth; helper/subagent sessions must not spawn remote surfaces. */
+	taskDepth?: number;
+	/** Parent subagent id/prefix; present for helper/subagent sessions even when depth is omitted. */
+	parentTaskPrefix?: string;
+	/** Role-agent type/name; present for task sessions even if depth metadata is lost. */
+	currentAgentType?: string;
 }): boolean {
+	if ((input.taskDepth ?? 0) > 0 || input.parentTaskPrefix || input.currentAgentType) return false;
 	if (input.env.GJC_NOTIFICATIONS === "0") return false;
 	if (input.env.GJC_NOTIFICATIONS === "1" || input.env.GJC_NOTIFICATIONS_TOKEN) return true;
 	return input.cfg ? isGloballyConfigured(input.cfg) : false;
@@ -112,7 +119,8 @@ export interface RedactableAction {
  * When redact is false, return the action unchanged.
  *
  * Redaction still applies to streamed content frames (turn_stream, context_update,
- * image_attachment) which are suppressed at their emit sites, not here.
+ * image_attachment) which are suppressed at their emit sites, not here. Explicit
+ * `telegram_send` file attachments are rejected before the file is read or forwarded.
  */
 export function buildRedactedAction(
 	action: RedactableAction,

package/src/notifications/daemon-paths.ts

@@ -7,6 +7,7 @@ export interface DaemonPaths {
 	roots: string;
 	steal: string;
 	aliases: string;
+	seenUpdates: string;
 }
 
 export function daemonPaths(agentDir: string): DaemonPaths {
@@ -18,5 +19,6 @@ export function daemonPaths(agentDir: string): DaemonPaths {
 		roots: path.join(dir, "telegram-daemon.roots.json"),
 		steal: path.join(dir, "telegram-daemon.steal"),
 		aliases: path.join(dir, "telegram-callback-aliases.json"),
+		seenUpdates: path.join(dir, "telegram-seen-updates.json"),
 	};
 }

package/src/notifications/index.ts

@@ -28,7 +28,7 @@ import type { ImageContent, TextContent } from "@gajae-code/ai";
 import { NotificationServer } from "@gajae-code/natives";
 import { logger, postmortem } from "@gajae-code/utils";
 import { Settings } from "../config/settings";
-import type { ExtensionCommandContext, ExtensionContext, ExtensionFactory } from "../extensibility/extensions";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "../extensibility/extensions";
 import { registerAskAnswerSource } from "../tools/ask-answer-registry";
 import { registerTelegramFileSink } from "./attachment-registry";
 import {
@@ -100,7 +100,7 @@ export interface SessionCloseFrame {
 	chatId: string;
 	token: string;
 	target: SessionCloseTarget;
-	/** Hard-kill even if a live pane is attached (GJC-managed only). */
+	/** Required force-only close flag; false/omitted is rejected by daemon policy. */
 	force?: boolean;
 }
 
@@ -336,6 +336,8 @@ interface SessionRuntime {
 	disposeAnswerSource: () => void;
 	/** Deregisters this session's Telegram file sink. */
 	disposeFileSink: () => void;
+	/** Deregisters this session's unattended workflow-gate listener. */
+	disposeGateListener: () => void;
 	redact: boolean;
 	verbosity: "lean" | "verbose";
 	sessionTag: string;
@@ -358,6 +360,8 @@ interface ResolvedSettings {
 	settingsAvailable: boolean;
 }
 
+const TELEGRAM_FILE_REDACTION_ERROR = "Telegram file attachments are disabled while notifications redaction is on.";
+
 const defaultConfig: NotificationConfig = {
 	enabled: false,
 	botToken: undefined,
@@ -379,7 +383,9 @@ export function notificationsEnabled(): boolean {
 	return process.env.GJC_NOTIFICATIONS === "1" || Boolean(process.env.GJC_NOTIFICATIONS_TOKEN);
 }
 
-function resolveSettings(): ResolvedSettings {
+function resolveSettings(settingsOverride?: Settings): ResolvedSettings {
+	if (settingsOverride)
+		return { settings: settingsOverride, cfg: getNotificationConfig(settingsOverride), settingsAvailable: true };
 	try {
 		const settings = Settings.instance;
 		return { settings, cfg: getNotificationConfig(settings), settingsAvailable: true };
@@ -491,7 +497,7 @@ function sessionIdFromFile(file: string | undefined): string | undefined {
 	return underscore >= 0 ? base.slice(underscore + 1) : undefined;
 }
 
-export const createNotificationsExtension: ExtensionFactory = api => {
+export function createNotificationsExtension(api: ExtensionAPI, options: { settings?: Settings } = {}): void {
 	const runtimes = new Map<string, SessionRuntime>();
 	const disabledSessions = new Set<string>();
 	const sessionId = (ctx: ExtensionContext): string => ctx.sessionManager.getSessionId();
@@ -503,9 +509,16 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		runtimes.delete(id);
 		try {
 			rt.cancelPostmortemCleanup();
+		} catch {}
+		try {
 			rt.disposeAnswerSource();
+		} catch {}
+		try {
 			rt.disposeFileSink();
 		} catch {}
+		try {
+			rt.disposeGateListener();
+		} catch {}
 		// 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();
@@ -529,10 +542,14 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		return isSessionNotificationsEnabled({ cfg, env: process.env, sessionDisabled: disabledSessions.has(id) });
 	}
 
+	function isNotificationEligibleContext(ctx: ExtensionContext): boolean {
+		return ctx.sessionMetadata?.kind !== "sub";
+	}
+
 	async function startSession(ctx: ExtensionContext): Promise<"started" | "already" | "disabled" | "failed"> {
 		const id = sessionId(ctx);
-		const { settings, cfg, settingsAvailable } = resolveSettings();
-		if (!isEnabledForSession(id, cfg)) return "disabled";
+		const { settings, cfg, settingsAvailable } = resolveSettings(options.settings);
+		if (!isNotificationEligibleContext(ctx) || !isEnabledForSession(id, cfg)) return "disabled";
 		if (runtimes.has(id)) return "already";
 
 		const stateRoot = path.join(ctx.cwd, ".gjc", "state");
@@ -660,6 +677,10 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 				tag,
 			);
 			const disposeFileSink = registerTelegramFileSink(id, async file => {
+				if (runtime?.redact ?? redact) {
+					return { ok: false, error: TELEGRAM_FILE_REDACTION_ERROR };
+				}
+
 				try {
 					const data = await fs.promises.readFile(file.path);
 					server.pushFrame(
@@ -683,6 +704,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 				pendingInteractive,
 				disposeAnswerSource,
 				disposeFileSink,
+				disposeGateListener: () => {},
 				cancelPostmortemCleanup: () => {},
 				redact,
 				verbosity,
@@ -726,7 +748,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 
 			// Unattended: a real ask emits a workflow gate; register it repliable by gate_id.
 			if (unattended && gate?.onGateEmitted) {
-				gate.onGateEmitted(g => {
+				runtime.disposeGateListener = gate.onGateEmitted(g => {
 					const options = (g.options ?? []).map(o => String((o as { label?: unknown }).label ?? ""));
 					gateOptions.set(g.gate_id, options);
 					const promptCtx = g.context as { prompt?: unknown; title?: unknown } | undefined;
@@ -761,7 +783,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		async handler(args: string, ctx: ExtensionCommandContext): Promise<void> {
 			const id = sessionId(ctx);
 			const command = args.trim().split(/\s+/, 1)[0]?.toLowerCase() || "status";
-			const resolved = resolveSettings();
+			const resolved = resolveSettings(options.settings);
 			const enabledWithoutLocalOff = isSessionNotificationsEnabled({
 				cfg: resolved.cfg,
 				env: process.env,
@@ -781,6 +803,10 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 			}
 
 			if (command === "on") {
+				if (!isNotificationEligibleContext(ctx)) {
+					ctx.ui.notify("Notifications are disabled for subagent sessions.", "warning");
+					return;
+				}
 				if (process.env.GJC_NOTIFICATIONS === "0") {
 					ctx.ui.notify(
 						"Notifications remain disabled: GJC_NOTIFICATIONS=0 is an authoritative opt-out.",
@@ -878,6 +904,10 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 			rt.sessionTag,
 		);
 		rt.disposeFileSink = registerTelegramFileSink(newId, async file => {
+			if (rt.redact) {
+				return { ok: false, error: TELEGRAM_FILE_REDACTION_ERROR };
+			}
+
 			try {
 				const data = await fs.promises.readFile(file.path);
 				rt.server.pushFrame(
@@ -1099,4 +1129,4 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 	api.on("session_shutdown", async (_event, ctx) => {
 		await stopSession(sessionId(ctx));
 	});
-};
+}