@gajae-code/coding-agent 0.7.10 → 0.7.11

package/src/main.ts

@@ -671,7 +671,7 @@ async function buildSessionOptions(
 		options.thinkingLevel = scopedModels[0].thinkingLevel;
 	}
 
-	// Scoped models for Ctrl+P cycling - fill in default thinking levels when not explicit
+	// Scoped models for Alt+N cycling - fill in default thinking levels when not explicit
 	if (scopedModels.length > 0) {
 		const defaultThinkingLevel = activeSettings.get("defaultThinkingLevel");
 		options.scopedModels = scopedModels.map(scopedModel => ({
@@ -1067,7 +1067,7 @@ export async function runRootCommand(
 						return `${scopedModel.model.id}${thinkingStr}`;
 					})
 					.join(", ");
-				process.stdout.write(`${chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`)}\n`);
+				process.stdout.write(`${chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Alt+N to cycle)")}`)}\n`);
 			}
 
 			if ($env.PI_TIMING) {

package/src/migrate/executor.ts

@@ -12,11 +12,28 @@ import * as path from "node:path";
 import { upsertMCPServer } from "../runtime-mcp/config-writer";
 import type { MigrateAction } from "./types";
 
-async function ensureRealDirectoryPathNoFollow(directory: string): Promise<void> {
-	const resolved = path.resolve(directory);
-	const parsed = path.parse(resolved);
-	let current = parsed.root;
-	for (const part of resolved.slice(parsed.root.length).split(path.sep).filter(Boolean)) {
+function trustedSkillDestinationBase(destination: string): string {
+	const skillDir = path.dirname(path.resolve(destination));
+	const skillsRoot = path.dirname(skillDir);
+	const scopeRoot = path.dirname(skillsRoot);
+	return path.basename(scopeRoot) === ".gjc" ? path.dirname(scopeRoot) : scopeRoot;
+}
+
+async function ensureRealDirectoryPathNoFollow(directory: string, trustedBase: string): Promise<void> {
+	const resolvedBase = path.resolve(trustedBase);
+	const resolvedDirectory = path.resolve(directory);
+	const relative = path.relative(resolvedBase, resolvedDirectory);
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+		throw new Error(`skill destination escapes trusted base: ${resolvedDirectory}`);
+	}
+
+	const baseStat = await fs.stat(resolvedBase);
+	if (!baseStat.isDirectory()) {
+		throw new Error(`skill destination base is not a directory: ${resolvedBase}`);
+	}
+
+	let current = resolvedBase;
+	for (const part of relative.split(path.sep).filter(part => part && part !== ".")) {
 		current = path.join(current, part);
 		try {
 			const stat = await fs.lstat(current);
@@ -36,7 +53,7 @@ async function ensureRealDirectoryPathNoFollow(directory: string): Promise<void>
 
 async function writeSkillFileNoFollow(destination: string, content: string): Promise<void> {
 	const skillDir = path.dirname(destination);
-	await ensureRealDirectoryPathNoFollow(skillDir);
+	await ensureRealDirectoryPathNoFollow(skillDir, trustedSkillDestinationBase(destination));
 	const handle = await fs.open(
 		destination,
 		fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_TRUNC | fsSync.constants.O_NOFOLLOW,

package/src/modes/components/custom-editor.ts

@@ -9,6 +9,7 @@ type ConfigurableEditorAction = Extract<
 	| "app.exit"
 	| "app.suspend"
 	| "app.thinking.cycle"
+	| "app.commandPalette.open"
 	| "app.model.cycleForward"
 	| "app.model.cycleBackward"
 	| "app.model.select"
@@ -33,6 +34,7 @@ const CONFIGURABLE_EDITOR_ACTIONS = [
 	"app.exit",
 	"app.suspend",
 	"app.thinking.cycle",
+	"app.commandPalette.open",
 	"app.model.cycleForward",
 	"app.model.cycleBackward",
 	"app.model.select",
@@ -76,6 +78,7 @@ export class CustomEditor extends Editor {
 	onClear?: () => void;
 	onExit?: () => void;
 	onCycleThinkingLevel?: () => void;
+	onOpenCommandPalette?: () => void;
 	onCycleModelForward?: () => void;
 	onCycleModelBackward?: () => void;
 	onSelectModel?: () => void;
@@ -288,6 +291,11 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
+		// Intercept configured command palette shortcut before model cycling (Ctrl+P default).
+		if (this.#matchesAction(data, "app.commandPalette.open") && this.onOpenCommandPalette) {
+			this.onOpenCommandPalette();
+			return;
+		}
 		// Intercept configured backward model cycling (check before forward cycling)
 		if (this.#matchesAction(data, "app.model.cycleBackward") && this.onCycleModelBackward) {
 			this.onCycleModelBackward();

package/src/modes/components/model-selector.ts

@@ -405,7 +405,7 @@ export class ModelSelectorComponent extends Container {
 		// Create search input
 		this.#searchInput = new Input();
 		if (initialSearchInput) {
-			this.#searchInput.setValue(initialSearchInput);
+			this.#setSearchInputValue(initialSearchInput);
 		}
 		this.#searchInput.onSubmit = () => {
 			const selectedItem = this.#getSelectedItem();
@@ -1012,6 +1012,10 @@ export class ModelSelectorComponent extends Container {
 		if (!this.#relocatePresetCursor(targetIdentity)) this.#clampPresetCursor();
 	}
 
+	#setSearchInputValue(value: string): void {
+		this.#searchInput.setValue(value);
+	}
+
 	#switchToModelMode(seed?: string): void {
 		this.#viewMode = "models";
 		this.#expandedPresetProviderId = undefined;
@@ -1021,7 +1025,7 @@ export class ModelSelectorComponent extends Container {
 		this.#presetLoginHint = undefined;
 		this.#activeTabIndex = 0;
 		this.#selectedIndex = 0;
-		this.#searchInput.setValue(seed ?? this.#searchInput.getValue());
+		this.#setSearchInputValue(seed ?? this.#searchInput.getValue());
 		this.#updateTabBar();
 		this.#filterModels(this.#searchInput.getValue());
 	}

package/src/modes/components/settings-selector.ts

@@ -60,8 +60,6 @@ class TextInputSubmenu extends Container {
 		this.#input = new Input();
 		if (currentValue) {
 			this.#input.setValue(currentValue);
-			// Move cursor to end of pre-filled value (ctrl+e = cursorLineEnd).
-			this.#input.handleInput("\x05");
 		}
 		this.#input.onSubmit = value => {
 			this.onSubmit(value); // empty string clears the setting

package/src/modes/components/skill-message.ts

@@ -13,18 +13,20 @@ import {
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import type { CustomMessage, SkillPromptDetails } from "../../session/messages";
 
-const COLLAPSED_ARGS_PREVIEW_WIDTH = 96;
+const DEFAULT_COLLAPSED_ARGS_PREVIEW_WIDTH = 96;
 const COLLAPSED_ARGS_PREVIEW_LINES = 6;
+const SKILL_BOX_HORIZONTAL_PADDING = 1;
 export class SkillMessageComponent extends Container {
 	#box: Box;
 	#contentComponent?: Component;
 	#expanded = false;
+	#argsPreviewWidth = DEFAULT_COLLAPSED_ARGS_PREVIEW_WIDTH;
 
 	constructor(private readonly message: CustomMessage<SkillPromptDetails>) {
 		super();
 		this.addChild(new Spacer(1));
 
-		this.#box = new Box(1, 1, t => theme.bg("customMessageBg", t));
+		this.#box = new Box(SKILL_BOX_HORIZONTAL_PADDING, 1, t => theme.bg("customMessageBg", t));
 		this.#rebuild();
 	}
 
@@ -40,6 +42,15 @@ export class SkillMessageComponent extends Container {
 		this.#rebuild();
 	}
 
+	override render(width: number): string[] {
+		const contentWidth = Math.max(1, width - SKILL_BOX_HORIZONTAL_PADDING * 2);
+		if (this.#argsPreviewWidth !== contentWidth) {
+			this.#argsPreviewWidth = contentWidth;
+			this.#rebuild();
+		}
+		return super.render(width);
+	}
+
 	#rebuild(): void {
 		if (this.#contentComponent) {
 			this.removeChild(this.#contentComponent);
@@ -57,7 +68,7 @@ export class SkillMessageComponent extends Container {
 		// Collapsed view keeps args readable without exposing the full prompt body.
 		// Each visual line is bounded, but multi-line arguments remain multi-line so
 		// the invocation context is not mistaken for a one-line truncated payload.
-		const argsPreview = args ? this.#formatArgsPreview(args) : [];
+		const argsPreview = args ? this.#formatArgsPreview(args, this.#argsPreviewWidth) : [];
 		const header = `${theme.fg("customMessageLabel", theme.bold("[skill]"))} ${theme.fg("customMessageText", name)}`;
 		this.#box.addChild(new Text(header, 0, 0));
 		if (argsPreview.length > 0) {
@@ -111,19 +122,19 @@ export class SkillMessageComponent extends Container {
 		this.#box.addChild(this.#contentComponent);
 	}
 
-	#formatArgsPreview(args: string): string[] {
+	#formatArgsPreview(args: string, width: number): string[] {
 		const preview: string[] = [];
 		let omitted = false;
 		const sourceLines = replaceTabs(args).split(/\r?\n/);
 		for (let index = 0; index < sourceLines.length; index += 1) {
 			const sourceLine = sourceLines[index]?.trimEnd() ?? "";
-			const wrapped = wrapTextWithAnsi(sourceLine.length > 0 ? sourceLine : " ", COLLAPSED_ARGS_PREVIEW_WIDTH);
+			const wrapped = wrapTextWithAnsi(sourceLine.length > 0 ? sourceLine : " ", width);
 			for (const line of wrapped.length > 0 ? wrapped : [""]) {
 				if (preview.length >= COLLAPSED_ARGS_PREVIEW_LINES) {
 					omitted = true;
 					break;
 				}
-				preview.push(truncateToWidth(line, COLLAPSED_ARGS_PREVIEW_WIDTH));
+				preview.push(truncateToWidth(line, width));
 			}
 			if (omitted) break;
 		}
@@ -132,10 +143,7 @@ export class SkillMessageComponent extends Container {
 			omitted ||= replaceTabs(args).trimEnd().length > visibleSource.trimEnd().length;
 		}
 		if (omitted && preview.length > 0) {
-			preview[preview.length - 1] = truncateToWidth(
-				`${preview[preview.length - 1]} …`,
-				COLLAPSED_ARGS_PREVIEW_WIDTH,
-			);
+			preview[preview.length - 1] = truncateToWidth(`${preview[preview.length - 1]} …`, width);
 		}
 		return preview;
 	}

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

@@ -556,6 +556,29 @@ export class CommandController {
 		showMarkdownPanel(this.ctx, "Keyboard Shortcuts", hotkeys);
 	}
 
+	handleHelpCommand(): void {
+		const sessionNewKey = this.ctx.keybindings.getDisplayString("app.session.new") || "/new";
+		const markdown = [
+			"**Beginner actions**",
+			"",
+			"| Action | How |",
+			"|---|---|",
+			`| Start a fresh session | \`${sessionNewKey}\` or \`/new\` |`,
+			"| Resume another session | `/resume` |",
+			"| Show session details | `/session info` |",
+			"| Delete current session | `/session delete` |",
+			"| Select a model | `/model` or `Ctrl+L` |",
+			"| Show all shortcuts | `?` on an empty prompt or `/hotkeys` |",
+			"",
+			"**Finding commands**",
+			"",
+			"- Type `/` to browse slash commands, then use arrows and Enter/Tab.",
+			"- Type `#` to browse prompt actions like starting a session, pasting an image, or moving the cursor.",
+			"- Type `!` for shell commands and `$` for Python snippets.",
+		].join("\n");
+		showMarkdownPanel(this.ctx, "GJC Help", markdown);
+	}
+
 	handleToolsCommand(): void {
 		const tools = buildToolsMarkdown({ tools: this.ctx.session.agent.state.tools });
 		showMarkdownPanel(this.ctx, "Available Tools", tools);

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

@@ -156,6 +156,8 @@ export class InputController {
 		this.ctx.editor.onSuspend = () => this.handleCtrlZ();
 		this.ctx.editor.setActionKeys("app.thinking.cycle", this.ctx.keybindings.getKeys("app.thinking.cycle"));
 		this.ctx.editor.onCycleThinkingLevel = () => this.cycleThinkingLevel();
+		this.ctx.editor.setActionKeys("app.commandPalette.open", this.ctx.keybindings.getKeys("app.commandPalette.open"));
+		this.ctx.editor.onOpenCommandPalette = () => this.openCommandPalette();
 		this.ctx.editor.setActionKeys("app.model.cycleForward", this.ctx.keybindings.getKeys("app.model.cycleForward"));
 		this.ctx.editor.onCycleModelForward = () => this.cycleRoleModel();
 		this.ctx.editor.setActionKeys("app.model.cycleBackward", this.ctx.keybindings.getKeys("app.model.cycleBackward"));
@@ -201,7 +203,7 @@ export class InputController {
 		this.ctx.editor.setActionKeys("app.message.queue", this.ctx.keybindings.getKeys("app.message.queue"));
 		this.ctx.editor.onQueue = () => void this.handleQueueSubmit();
 		this.ctx.editor.onTabDeclined = () => {
-			if (this.ctx.session.isStreaming) void this.handleQueueSubmit();
+			if (this.ctx.session.isStreaming || this.ctx.session.isCompacting) void this.handleQueueSubmit();
 		};
 
 		this.ctx.editor.clearCustomKeyHandlers();
@@ -492,7 +494,7 @@ export class InputController {
 	}
 
 	handleDequeue(): void {
-		const restored = this.restoreQueuedMessagesToEditor();
+		const restored = this.restoreLatestQueuedMessageToEditor();
 		if (restored === 0) {
 			this.ctx.showStatus("No queued messages to restore");
 		} else {
@@ -603,13 +605,15 @@ export class InputController {
 		const text = this.ctx.editor.getText().trim();
 		if (!text) return;
 
-		// Compaction first: while compacting, free text gets queued via
-		// `queueCompactionMessage`, and `/skill:*` rides the same queue so a
-		// skill typed during compaction is not lost or short-circuited through
-		// `promptCustomMessage`. The skill text is queued verbatim; whether
-		// the queued entry is later re-parsed into a skill invocation is a
-		// separate concern owned by the compaction-resume path.
+		// Compaction first: while compacting, queue free text and `/skill:*`
+		// commands in the compaction-local queue. `flushCompactionQueue`
+		// replays skill entries through the custom-message skill path after
+		// compaction finishes so they are not degraded into plain prompts.
 		if (this.ctx.session.isCompacting) {
+			if (this.ctx.pendingImages.length > 0) {
+				this.ctx.showStatus("Compaction in progress. Retry after it completes to send images.");
+				return;
+			}
 			this.ctx.queueCompactionMessage(text, "followUp");
 			return;
 		}
@@ -643,10 +647,28 @@ export class InputController {
 		return this.handleFollowUp();
 	}
 
+	restoreLatestQueuedMessageToEditor(options?: { currentText?: string }): number {
+		const compactionQueued = this.ctx.compactionQueuedMessages.pop();
+		const queuedText = compactionQueued?.text ?? this.ctx.session.popLastQueuedMessage();
+		if (!queuedText) {
+			this.ctx.updatePendingMessagesDisplay();
+			return 0;
+		}
+
+		this.ctx.locallySubmittedUserSignatures.delete(`${queuedText}\u00000`);
+		const currentText = options?.currentText ?? this.ctx.editor.getText();
+		const combinedText = [queuedText, currentText].filter(t => t.trim()).join("\n\n");
+		this.ctx.editor.setText(combinedText);
+		this.ctx.updatePendingMessagesDisplay();
+		return 1;
+	}
+
 	restoreQueuedMessagesToEditor(options?: { abort?: boolean; currentText?: string }): number {
 		this.ctx.locallySubmittedUserSignatures.clear();
 		const { steering, followUp } = this.ctx.session.clearQueue();
-		const allQueued = [...steering, ...followUp];
+		const compactionQueued = (this.ctx.compactionQueuedMessages ?? []).map(entry => entry.text);
+		this.ctx.compactionQueuedMessages = [];
+		const allQueued = [...steering, ...followUp, ...compactionQueued];
 		if (allQueued.length === 0) {
 			this.ctx.updatePendingMessagesDisplay();
 			if (options?.abort) {
@@ -859,6 +881,8 @@ export class InputController {
 			copyCurrentLine: () => this.handleCopyCurrentLine(),
 			copyPrompt: () => this.handleCopyPrompt(),
 			pasteImage: () => void this.handleImagePaste(),
+			newSession: () => void this.ctx.handleClearCommand(),
+			showHelp: () => this.ctx.handleHelpCommand(),
 			scrollTmuxToPreviousUserInput: () => this.scrollTmuxToPreviousUserInput(),
 			undo: prefix => this.ctx.editor.undoPastTransientText(prefix),
 			moveCursorToMessageEnd: () => this.ctx.editor.moveToMessageEnd(),
@@ -903,6 +927,14 @@ export class InputController {
 		}
 	}
 
+	openCommandPalette(): void {
+		if (this.ctx.editor.getText().trim().length > 0) {
+			this.ctx.showStatus("Command palette opens from an empty prompt. Type / for inline commands.");
+			return;
+		}
+		this.ctx.editor.handleInput("/");
+	}
+
 	cycleThinkingLevel(): void {
 		const newLevel = this.ctx.session.cycleThinkingLevel();
 		if (newLevel === undefined) {

package/src/modes/interactive-mode.ts

@@ -71,7 +71,6 @@ import { normalizeLocalScheme } from "../tools/path-utils";
 import { type ResolveToolDetails, runResolveInvocation } from "../tools/resolve";
 import { formatPhaseDisplayName } from "../tools/todo-write";
 import { ToolError } from "../tools/tool-errors";
-
 import type { EventBus } from "../utils/event-bus";
 import { getEditorCommand, openInEditor } from "../utils/external-editor";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../utils/session-color";
@@ -103,6 +102,7 @@ import { JobsObserver } from "./jobs-observer";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
 import { interruptHint } from "./shared";
+import { shouldShowExtensionCommand } from "./slash-command-visibility";
 import { type ShimmerPalette, shimmerSegments, shimmerText } from "./theme/shimmer";
 import type { Theme } from "./theme/theme";
 import {
@@ -452,13 +452,16 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.hideThinkingBlock = settings.get("hideThinkingBlock");
 
 		const builtinCommandNames = new Set(BUILTIN_SLASH_COMMANDS.map(c => c.name));
+		const activeProvider = this.session.model?.provider;
 		const hookCommands: SlashCommand[] = (
 			this.session.extensionRunner?.getRegisteredCommands(builtinCommandNames) ?? []
-		).map(cmd => ({
-			name: cmd.name,
-			description: cmd.description ?? "(hook command)",
-			getArgumentCompletions: cmd.getArgumentCompletions,
-		}));
+		)
+			.filter(cmd => shouldShowExtensionCommand(cmd.name, activeProvider))
+			.map(cmd => ({
+				name: cmd.name,
+				description: cmd.description ?? "(hook command)",
+				getArgumentCompletions: cmd.getArgumentCompletions,
+			}));
 
 		// Convert custom commands (TypeScript) to SlashCommand format
 		const customCommands: SlashCommand[] = this.session.customCommands.map(loaded => ({
@@ -2035,7 +2038,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		const sessionId = this.sessionManager.getSessionId();
 		const sessionFile = this.sessionManager.getSessionFile();
 		if (sessionId && sessionFile) {
-			process.stderr.write(`\n${chalk.dim(`Resume this session with ${APP_NAME} --resume ${sessionId}`)}\n`);
+			process.stderr.write(
+				`\n${chalk.dim("Resume this session with:")}\n${chalk.dim(`${APP_NAME} --resume ${sessionId}`)}\n`,
+			);
 		}
 
 		await postmortem.quit(0);
@@ -2311,6 +2316,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#commandController.handleHotkeysCommand();
 	}
 
+	handleHelpCommand(): void {
+		this.#commandController.handleHelpCommand();
+	}
+
 	handleToolsCommand(): void {
 		this.#commandController.handleToolsCommand();
 	}

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

@@ -29,6 +29,8 @@ interface PromptActionAutocompleteOptions {
 	copyCurrentLine: () => void;
 	copyPrompt: () => void;
 	pasteImage: () => void;
+	newSession: () => void;
+	showHelp: () => void;
 	scrollTmuxToPreviousUserInput: () => void;
 	undo: (prefix: string) => void;
 	moveCursorToMessageEnd: () => void;
@@ -101,6 +103,12 @@ function mergeAutocompleteSuggestions(
 
 	return { items, prefix: primary.prefix };
 }
+const ADVANCED_SLASH_COMMAND_PRIORITIES = new Map<string, number>([["grok-build-usage", -100]]);
+
+function getSlashCommandPriority(command: SlashCommand | undefined, item: AutocompleteItem): number {
+	if (command?.priority !== undefined) return command.priority;
+	return ADVANCED_SLASH_COMMAND_PRIORITIES.get(item.value) ?? 0;
+}
 
 function sortSlashCommandSuggestions(
 	suggestions: { items: AutocompleteItem[]; prefix: string } | null,
@@ -123,7 +131,7 @@ function sortSlashCommandSuggestions(
 				index,
 				commandIndex,
 				matchRank: getSlashCommandMatchRank(query, lowerName),
-				priority: command?.priority ?? 0,
+				priority: getSlashCommandPriority(command, item),
 				score: Math.max(nameScore, descScore),
 			};
 		})
@@ -358,6 +366,20 @@ export function createPromptActionAutocompleteProvider(
 ): PromptActionAutocompleteProvider {
 	const editorKeybindings = getKeybindings();
 	const actions: PromptActionDefinition[] = [
+		{
+			id: "new-session",
+			label: "Start new session",
+			description: formatKeyHints(options.keybindings.getKeys("app.session.new")) || "/new",
+			keywords: ["new", "session", "fresh", "clear", "start", "conversation"],
+			execute: options.newSession,
+		},
+		{
+			id: "help",
+			label: "Open command help",
+			description: "/help",
+			keywords: ["help", "commands", "command", "palette", "shortcuts", "beginner"],
+			execute: options.showHelp,
+		},
 		{
 			id: "copy-line",
 			label: "Copy current line",

package/src/modes/slash-command-visibility.ts

@@ -0,0 +1,9 @@
+const BEGINNER_HIDDEN_EXTENSION_COMMANDS = new Set(["grok-build-usage"]);
+
+export function shouldShowExtensionCommand(name: string, activeProvider: string | undefined): boolean {
+	if (!BEGINNER_HIDDEN_EXTENSION_COMMANDS.has(name)) return true;
+	if (name === "grok-build-usage") {
+		return activeProvider === "grok-build" || Boolean(process.env.GROK_CLI_OAUTH_TOKEN);
+	}
+	return true;
+}

package/src/modes/types.ts

@@ -209,6 +209,7 @@ export interface InteractiveModeContext {
 	handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;
 	handleChangelogCommand(showFull?: boolean): Promise<void>;
 	handleHotkeysCommand(): void;
+	handleHelpCommand(): void;
 	handleToolsCommand(): void;
 	handleContextCommand(): void;
 	handleDumpCommand(): void;

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

@@ -38,6 +38,8 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		`| \`${appKey(bindings, "app.clear")}\` | Clear editor (first) / exit (second) |`,
 		`| \`${appKey(bindings, "app.exit")}\` | Exit (when editor is empty) |`,
 		`| \`${appKey(bindings, "app.suspend")}\` | Suspend to background |`,
+		`| \`${appKey(bindings, "app.commandPalette.open")}\` | Open command palette |`,
+		`| \`${appKey(bindings, "app.session.new")}\` | Start a fresh session |`,
 		`| \`${appKey(bindings, "app.thinking.cycle")}\` | Cycle thinking level |`,
 		`| \`${appKey(bindings, "app.model.cycleForward")}\` | Cycle configured model roles |`,
 		`| \`${appKey(bindings, "app.model.cycleBackward")}\` | Cycle configured model roles temporarily |`,
@@ -51,8 +53,9 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		`| \`${appKey(bindings, "app.editor.external")}\` | Edit message in external editor |`,
 		`| \`${appKey(bindings, "app.clipboard.pasteImage")}\` | Paste image from clipboard |`,
 		`| \`${appKey(bindings, "app.stt.toggle")}\` | Toggle speech-to-text recording |`,
-		"| `#` | Open prompt actions |",
-		"| `/` | Slash commands |",
+		"| `?` | Show help / shortcuts |",
+		"| `#` | Prompt actions (command-palette style actions) |",
+		"| `/` | Slash commands (try `/help` or `/new`) |",
 		"| `!` | Run bash command |",
 		"| `!!` | Run bash command (excluded from context) |",
 		"| `$` | Run Python in shared kernel |",

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

@@ -2,6 +2,8 @@ import type { AgentMessage } from "@gajae-code/agent-core";
 import type { AssistantMessage, ImageContent, Message } from "@gajae-code/ai";
 import { type Component, Spacer, Text, TruncatedText } from "@gajae-code/tui";
 import { settings } from "../../config/settings";
+import { resolveSubskillActivationForSkillInvocation } from "../../extensibility/gjc-plugins";
+import { buildSkillPromptMessage, parseSkillInvocations } from "../../extensibility/skills";
 import { AssistantMessageComponent } from "../../modes/components/assistant-message";
 import { BashExecutionComponent } from "../../modes/components/bash-execution";
 import { BranchSummaryMessageComponent } from "../../modes/components/branch-summary-message";
@@ -610,9 +612,80 @@ export class UiHelpers {
 		this.ctx.updatePendingMessagesDisplay();
 		this.ctx.showStatus("Queued message for after compaction");
 	}
+	#hasSkillInvocations(text: string): boolean {
+		return parseSkillInvocations(text, this.ctx.skillCommands ?? new Map()).length > 0;
+	}
+
+	#isCompactionCommandMessage(text: string): boolean {
+		return this.#hasSkillInvocations(text) || this.isKnownSlashCommand(text);
+	}
+
+	async #deliverQueuedSkillMessage(message: CompactionQueuedMessage): Promise<boolean> {
+		const invocations = parseSkillInvocations(message.text, this.ctx.skillCommands ?? new Map());
+		if (invocations.length === 0) {
+			return false;
+		}
+
+		for (let index = 0; index < invocations.length; index += 1) {
+			const invocation = invocations[index];
+			if (!invocation) continue;
+
+			const activationResult = await resolveSubskillActivationForSkillInvocation({
+				cwd: this.ctx.sessionManager.getCwd(),
+				sessionId: this.ctx.session.sessionId,
+				skillName: invocation.skill.name,
+				args: invocation.args,
+			});
+			const built = await buildSkillPromptMessage(invocation.skill, activationResult.cleanedArgs, {
+				subskillActivation: activationResult.activation,
+				subskillActivationSet: activationResult.activeSubskillsToPersist,
+				cwd: this.ctx.sessionManager.getCwd(),
+				sessionId: this.ctx.session.sessionId,
+			});
+			const details: SkillPromptDetails = built.details;
+			const displayText = `/${invocation.commandName}${activationResult.cleanedArgs ? ` ${activationResult.cleanedArgs}` : ""}`;
+
+			if (this.ctx.session.isStreaming) {
+				const tag = this.ctx.session.enqueueCustomMessageDisplay(displayText, message.mode);
+				details.__pendingDisplayTag = tag;
+			}
+
+			const isLast = index === invocations.length - 1;
+			if (!this.ctx.session.isStreaming && !isLast) {
+				await this.ctx.session.sendCustomMessage({
+					customType: SKILL_PROMPT_MESSAGE_TYPE,
+					content: built.message,
+					display: true,
+					details,
+					attribution: "user",
+				});
+				continue;
+			}
 
+			await this.ctx.session.promptCustomMessage(
+				{
+					customType: SKILL_PROMPT_MESSAGE_TYPE,
+					content: built.message,
+					display: true,
+					details,
+					attribution: "user",
+				},
+				{ streamingBehavior: message.mode },
+			);
+		}
+
+		if (this.ctx.session.isStreaming) {
+			this.ctx.updatePendingMessagesDisplay();
+			this.ctx.ui.requestRender();
+		}
+
+		return true;
+	}
 	async #deliverQueuedMessage(message: CompactionQueuedMessage): Promise<void> {
-		if (this.ctx.isKnownSlashCommand(message.text)) {
+		if (await this.#deliverQueuedSkillMessage(message)) {
+			return;
+		}
+		if (this.isKnownSlashCommand(message.text)) {
 			await this.ctx.session.prompt(message.text);
 			return;
 		}
@@ -671,14 +744,14 @@ export class UiHelpers {
 
 			let firstPromptIndex = -1;
 			for (let i = 0; i < queuedMessages.length; i++) {
-				if (!this.ctx.isKnownSlashCommand(queuedMessages[i].text)) {
+				if (!this.#isCompactionCommandMessage(queuedMessages[i].text)) {
 					firstPromptIndex = i;
 					break;
 				}
 			}
 			if (firstPromptIndex === -1) {
 				for (const message of queuedMessages) {
-					await this.ctx.session.prompt(message.text);
+					await this.#deliverQueuedMessage(message);
 				}
 				return;
 			}

package/src/notifications/telegram-daemon.ts

@@ -13,7 +13,7 @@ import { parseInThreadConfigCommand } from "./config-commands";
 import { daemonPaths } from "./daemon-paths";
 import {
 	buildCompactChoiceGrid,
-	pre,
+	code,
 	splitTelegramHtml,
 	TELEGRAM_MESSAGE_LIMIT,
 	TELEGRAM_PARSE_MODE,
@@ -1117,10 +1117,10 @@ export class TelegramNotificationDaemon {
 				limit: 10,
 				includeInternal: false,
 			});
-			const lines = recent.length
-				? recent.map(e => `• ${e.sessionId}${e.path ? ` (${e.path})` : ""}`).join("\n")
+			const body = recent.length
+				? recent.map(e => `• ${code(e.sessionId)}${e.path ? ` (${code(e.path)})` : ""}`).join("\n")
 				: "No recent sessions.";
-			await replyHtml(pre(lines));
+			await replyHtml(body);
 			return true;
 		}