@gajae-code/coding-agent 0.18.11 → 0.19.0

package/src/migrate/types.ts

@@ -1,8 +1,8 @@
 /**
  * Shared types for `gjc migrate`.
  *
- * Imports MCP servers and skills from other coding agents (Claude Code, Codex,
- * OpenCode) into native GJC config. See the consensus plan under
+ * Imports MCP servers, skills, slash commands, and instruction files from other coding agents
+ * (Claude Code, Codex, OpenCode) into native GJC config. See the consensus plan under
  * `.gjc/plans/ralplan/` for the full taxonomy and force/collision semantics.
  */
 import type { MCPServerConfig } from "../runtime-mcp/types";
@@ -16,7 +16,7 @@ export const MIGRATE_SOURCES: readonly MigrateSource[] = ["claude-code", "codex"
 export const CANONICAL_SOURCE_ORDER: readonly MigrateSource[] = MIGRATE_SOURCES;
 
 /** What kind of thing an action/coverage row is about. */
-export type MigrateItemType = "mcp" | "skill" | "source";
+export type MigrateItemType = "mcp" | "skill" | "command" | "agent" | "hook" | "instruction" | "source";
 
 /**
  * Per-item outcome taxonomy.
@@ -77,6 +77,31 @@ export interface SkillCandidate {
 	warnings: string[];
 }
 
+/** An instructions file imported as the active GJC AGENTS.md for its scope. */
+export interface InstructionCandidate {
+	source: MigrateSource;
+	name: string;
+	content: string;
+}
+
+/** A Markdown subagent collected from a foreign coding-agent setup. */
+export interface AgentCandidate {
+	source: MigrateSource;
+	/** Agent name exactly as it will be loaded from `<agentsDir>/<name>.md`. */
+	name: string;
+	/** Full Markdown content with normalized GJC frontmatter. */
+	content: string;
+	warnings: string[];
+}
+
+/** A Markdown slash command collected from a foreign coding-agent setup. */
+export interface SlashCommandCandidate {
+	source: MigrateSource;
+	/** Name without the leading slash; nested path components use `:`. */
+	name: string;
+	content: string;
+}
+
 /**
  * Source-level diagnostic for a single source/type pair (e.g. "codex mcp config
  * was malformed"). Distinct from per-item actions so absent/unreadable sources
@@ -89,11 +114,48 @@ export interface SourceDiagnostic {
 	message: string;
 }
 
+/**
+ * A foreign hook command that maps onto a gjc hook event.
+ *
+ * Claude Code hooks are shell commands that receive a JSON payload on stdin and
+ * signal a block with exit code 2; gjc hooks are TypeScript modules. The
+ * importer generates a module that reproduces that contract for the events whose
+ * semantics are unambiguous.
+ */
+export interface HookCandidate {
+	source: MigrateSource;
+	/** Foreign event name, e.g. `PreToolUse`. */
+	event: string;
+	/** Tool-name matcher; empty or absent means every tool. */
+	matcher?: string;
+	/** Shell command exactly as the source declared it. */
+	command: string;
+}
+
+/**
+ * A source setting the migration cannot express in gjc. Reported instead of
+ * guessed at: silently translating an approval or hook policy would change what
+ * the agent is allowed to do. Secret values are never read, so detail may name
+ * keys but never their contents.
+ */
+export interface ManualAction {
+	source: MigrateSource;
+	/** Setting area, e.g. `hooks`, `settings.model`, `env`. */
+	area: string;
+	/** One-line instruction naming the concrete follow-up. */
+	detail: string;
+}
+
 /** Normalized candidates + diagnostics returned by an adapter. */
 export interface AdapterResult {
 	mcpCandidates: McpCandidate[];
 	skillCandidates: SkillCandidate[];
+	slashCommandCandidates: SlashCommandCandidate[];
+	agentCandidates: AgentCandidate[];
+	hookCandidates: HookCandidate[];
+	instructionCandidates: InstructionCandidate[];
 	diagnostics: SourceDiagnostic[];
+	manualActions: ManualAction[];
 }
 
 /** A single planned action consumed identically by dry-run and live execution. */
@@ -112,6 +174,10 @@ export interface MigrateAction {
 	/** Resolved payload the executor needs; never serialized to the report. */
 	mcp?: { config: MCPServerConfig; force: boolean };
 	skill?: { content: string };
+	command?: { content: string };
+	agent?: { content: string };
+	hook?: { content: string };
+	instruction?: { content: string };
 }
 
 export interface MigrateWarning {
@@ -126,6 +192,11 @@ export type StatusCounts = Record<MigrationStatus, number>;
 export interface MigrateDestinations {
 	mcpConfigPath: string;
 	skillsDir: string;
+	commandsDir: string;
+	agentsDir: string;
+	/** Directory that receives generated hook modules. */
+	hooksDir: string;
+	instructionsPath: string;
 }
 
 /** The full machine-readable report emitted with `--json`. */
@@ -138,7 +209,15 @@ export interface MigrateReport {
 	destinations: MigrateDestinations;
 	summary: {
 		total: StatusCounts;
-		byType: { mcp: StatusCounts; skill: StatusCounts; source: StatusCounts };
+		byType: {
+			mcp: StatusCounts;
+			skill: StatusCounts;
+			command: StatusCounts;
+			agent: StatusCounts;
+			hook: StatusCounts;
+			instruction: StatusCounts;
+			source: StatusCounts;
+		};
 		bySource: Record<MigrateSource, StatusCounts>;
 	};
 	actions: Array<{
@@ -153,6 +232,7 @@ export interface MigrateReport {
 		warnings?: string[];
 	}>;
 	warnings: MigrateWarning[];
+	manualActions: ManualAction[];
 }
 
 /** Create a zeroed status-count record. */

package/src/modes/DESIGN.md

@@ -112,6 +112,11 @@ condition in prose. Error guidance states the safe recovery action without
 showing credentials. Confirmations are explicit focused choices; destructive
 remove/disable actions are never the default side effect of navigation.
 
+Guidance the user must act on (for example the subagent await-timeout
+"inspect before cancelling" instruction) wraps to the terminal width instead of
+being clipped to one preview line, so the action survives narrow terminals. It
+stays bounded: at most 12 wrapped rows, the last ending in `…` if cut.
+
 A non-cancellable action visibly locks navigation and names the reason. A
 cancellable action names cancellation while it is pending, aborts on exit, and
 must not render a late completion after disposal. This follows the selector's
@@ -469,3 +474,49 @@ differently named bundles, and a stored `uri#ref` differs from a bare `uri`, so
 locator-based refusal would refuse installs that should proceed. Refusing on a
 guess is worse than reporting the real failure, so identity must be readable for
 refusal to apply.
+
+## Subagent compact await panel
+
+Source: `tools/subagent-render.ts` (the `subagent` await panel), behind the
+`task.compactSubagentPanel` setting (default off). This section extends the
+existing tool-panel grammar; it adds no tokens.
+
+- **Scope:** live await progress only. A final result (timeout guidance,
+  failure and completion receipts, status/steer/resume replies) always keeps the
+  full per-subagent rendering, so nothing the user must act on is summarized.
+- **Anatomy (collapsed, setting on):** a height independent of the number of
+  subagents — the existing status header, one `dim` summary row of group counts
+  joined by ` · `, at most one `warning` row naming the most-degraded provider and
+  how many more providers degrade (the expanded view keeps one row per provider), and one `dim` hint row in parentheses
+  naming the effective `app.tools.expand` key and, while anything runs, the
+  existing `ctrl+s to observe sessions` hint.
+- **Count order:** `N subagents running`, then `failed`, `retrying`,
+  `idle >30s`, `queued`, `paused`, `done`, `cancelled`. Zero counts are omitted.
+  Attention states come first because a narrow terminal truncates the row end;
+  truncation shows `…` so a dropped count is visible.
+- **States:** collapsed → summary; expanded (the existing tool-output toggle)
+  → the unchanged per-subagent list. With the setting off the panel is the
+  unchanged per-subagent list in both states. Status is carried by words and
+  counts, never by color or the spinner alone; ASCII/no-color keeps the same
+  text.
+- **Motion:** no new animation. With the setting on, await progress re-emits
+  only when the summary counts or per-provider retry counts change (plus the
+  existing liveness interval).
+- **International text:** the summary and hint are fixed English labels and
+  numbers; subagent descriptions (which may be CJK) appear only in the expanded
+  list, whose layout is unchanged.
+
+Capture command (fixture-backed, real renderer, fixed clock):
+
+```sh
+bun packages/coding-agent/scripts/capture-subagent-compact-panel-showcase.ts --out .gjc/qa/subagent-compact-panel-<run>
+```
+
+The matrix is every state at `80x24`, `120x36`, and `160x48` in
+`unicode-color` (including `compact-final-timeout`, a final timeout receipt
+with the setting on), plus `compact-collapsed-15-live` and `compact-collapsed-mixed`
+at `80x24/ascii-no-color`, `compact-collapsed-mixed/48x36/unicode-color`, and
+`narrow-cjk/48x36` in both render modes: 26 entries. An entry whose panel fits
+the viewport is captured once (`top`); an overflowing entry is captured at
+`top`, `middle`, and `bottom` so no tail is hidden. Every capture has
+`terminal.txt`, `terminal-ansi.txt`, `terminal.html`, and `metadata.json`.

package/src/modes/acp/acp-agent.ts

@@ -631,6 +631,11 @@ function isAbortNoEffect(value: unknown): boolean {
 	const result = object(candidate?.result) ?? candidate;
 	return result?.turn === "no_active_turn" || result?.turn === "no_effect" || result?.turn === "no_store";
 }
+function isAbortUncertain(value: unknown): boolean {
+	const candidate = object(value);
+	const result = object(candidate?.result) ?? candidate;
+	return result?.turn === "uncertain";
+}
 
 function strictCorrelationFrom(...values: unknown[]): PromptCorrelation | undefined {
 	const correlation: PromptCorrelation = {};
@@ -3064,12 +3069,16 @@ export class AcpAgent implements Agent {
 			let acknowledgementScope = scope;
 			if (
 				!isAbortAcknowledged(acknowledgement, scope) &&
-				isAbortNoEffect(acknowledgement) &&
+				(isAbortNoEffect(acknowledgement) || isAbortUncertain(acknowledgement)) &&
 				(waiterWasUnacknowledged || waiterWasBeforeActivity) &&
 				waiter &&
 				record.activePrompt === waiter &&
 				!waiter.settled
 			) {
+				// An uncertain replay result is not proof that the worker stopped, but it
+				// also must not erase a cancellation that arrived before prompt admission.
+				// Retain the intent and retry once the prompt acknowledgement/start gives
+				// the abort a concrete active turn to target.
 				waiter.cancelBeforeAdmission = true;
 				waiter.cancelBeforeAdmissionScope =
 					waiter.cancelBeforeAdmissionScope === "owned" || scope === "owned" ? "owned" : "turn";

package/src/modes/acp/permission-mode.ts

@@ -1,4 +1,6 @@
 import type { ClientCapabilities } from "@agentclientprotocol/sdk";
+import { startupProjectEnvSnapshot } from "@gajae-code/utils/env";
+import { canonicalEnvKey } from "@gajae-code/utils/env-file";
 
 export type AcpPermissionMode = "auto" | "prompt" | "always-allow";
 
@@ -9,6 +11,21 @@ function parseAcpPermissionMode(value: unknown): AcpPermissionMode {
 	return "prompt";
 }
 
+/**
+ * The default process environment includes the cwd `.env` merge. A live value
+ * equal to that startup declaration is the overlay and fails safe. A different
+ * live value is the launching environment, including when the declaration is
+ * dynamic (`$` or backticks) and is not that value. An explicit env map is
+ * the caller's value. The raw string is parsed so padding still fails safe.
+ */
+function permissionModeFromEnv(env: NodeJS.ProcessEnv): unknown {
+	const raw = env[ACP_PERMISSION_MODE_ENV];
+	if (env !== process.env || typeof raw !== "string") return raw;
+	const declared = startupProjectEnvSnapshot().values[canonicalEnvKey(ACP_PERMISSION_MODE_ENV)];
+	if (declared !== undefined && raw.trim() === declared.trim()) return undefined;
+	return raw;
+}
+
 /** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
 export function resolveAcpPermissionMode(
 	clientCapabilities: ClientCapabilities | undefined,
@@ -21,5 +38,5 @@ export function resolveAcpPermissionMode(
 			return parseAcpPermissionMode((gjc as { permissionHandling?: unknown }).permissionHandling);
 		}
 	}
-	return parseAcpPermissionMode(env[ACP_PERMISSION_MODE_ENV]);
+	return parseAcpPermissionMode(permissionModeFromEnv(env));
 }

package/src/modes/components/agent-dashboard.ts

@@ -90,14 +90,22 @@ export function resolveAgentCreationModel(
 	modelPatterns: string[],
 	modelRegistry: ModelRegistry,
 	settings: Settings | undefined,
+	credentialSessionId?: string,
 ) {
-	const { model } = resolveModelOverride(modelPatterns, modelRegistry, settings);
+	const { model } = resolveModelOverride(
+		modelPatterns,
+		modelRegistry,
+		settings,
+		undefined,
+		undefined,
+		credentialSessionId,
+	);
 	if (model) return model;
 	if (modelPatterns.length > 0) {
 		throw new Error(`Configured model selector(s) did not resolve: ${modelPatterns.join(", ")}.`);
 	}
 
-	const fallbackModel = modelRegistry.getAvailable()[0];
+	const fallbackModel = modelRegistry.getAvailable(credentialSessionId)[0];
 	if (!fallbackModel) {
 		throw new Error("No available model to generate agent specification.");
 	}
@@ -612,7 +620,12 @@ export class AgentDashboard extends Container {
 				settings?.getModelRole("default"),
 			settings,
 		);
-		const selectedModel = resolveAgentCreationModel(modelPatterns, modelRegistry, settings);
+		const selectedModel = resolveAgentCreationModel(
+			modelPatterns,
+			modelRegistry,
+			settings,
+			this.modelContext.credentialSessionId,
+		);
 
 		const systemPrompt = prompt.render(agentCreationArchitectPrompt, { TASK_TOOL_NAME: "task" });
 		const userPrompt = prompt.render(agentCreationUserPrompt, { request: description });
@@ -701,7 +714,7 @@ export class AgentDashboard extends Container {
 		if (!modelRegistry) return [];
 		const query = input.trim().toLowerCase();
 		if (!query) return [];
-		const available = modelRegistry.getAvailable();
+		const available = modelRegistry.getAvailable(this.modelContext.credentialSessionId);
 		const seen = new Set<string>();
 		const matches: string[] = [];
 		for (const model of available) {
@@ -757,6 +770,9 @@ export class AgentDashboard extends Container {
 			patterns,
 			modelRegistry,
 			this.#settingsManager ?? undefined,
+			undefined,
+			undefined,
+			this.modelContext.credentialSessionId,
 		);
 		if (!model) return undefined;
 		return {

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

@@ -4,13 +4,17 @@ import {
 	Container,
 	Image,
 	ImageProtocol,
+	isCursorNeutralImagePermittedInFallback,
+	isTerminalGraphicsFallbackActive,
 	isViewportAnchorSourceRenderer,
 	Markdown,
+	type MarkdownTheme,
 	Spacer,
 	TERMINAL,
 	Text,
 	type ViewportAnchorSource,
 } from "@gajae-code/tui";
+import { SvgFigure } from "@gajae-code/tui/chat/svg-figure";
 import { formatNumber } from "@gajae-code/utils";
 import { settings } from "../../config/settings";
 import { renderDeepInterviewAssistantText } from "../../deep-interview/render-middleware";
@@ -27,6 +31,44 @@ const THINKING_REPETITION_ELIDE_MIN_RUN = 24;
 const THINKING_REPETITION_VISIBLE_TOKENS = 3;
 const THINKING_REPETITION_TOKEN_PATTERN = /[\p{L}\p{N}_'-]{1,32}/gu;
 
+let assistantMarkdownThemeBase: MarkdownTheme | undefined;
+let cachedAssistantMarkdownTheme: MarkdownTheme | undefined;
+
+function getAssistantMarkdownTheme(): MarkdownTheme {
+	const base = getMarkdownTheme();
+	if (base === assistantMarkdownThemeBase && cachedAssistantMarkdownTheme) return cachedAssistantMarkdownTheme;
+	assistantMarkdownThemeBase = base;
+	cachedAssistantMarkdownTheme = {
+		...base,
+		resolveSvgFigure: (source, context) => {
+			if (!settings.get("terminal.showImages")) return null;
+			const graphicsSuppressed =
+				isTerminalGraphicsFallbackActive() &&
+				!(TERMINAL.imageProtocol === ImageProtocol.Kitty && isCursorNeutralImagePermittedInFallback());
+			if (!TERMINAL.imageProtocol) return null; // Stable environment: cache the code fallback.
+			if (graphicsSuppressed) return undefined; // The suppression scope can end; retry on repaint.
+			const palette = theme.getSvgPalette();
+			const previous = context.previous instanceof SvgFigure ? context.previous : undefined;
+			const figure =
+				previous ??
+				new SvgFigure({
+					theme: { fallbackColor: (text: string) => theme.fg("toolOutput", text) },
+					palette,
+					onChange: context.onChange,
+				});
+			figure.update(source, context.closed || !context.streaming, context.closed, palette);
+			if (figure.retryable) {
+				// A failed preview remains a code block, but must observe layout changes
+				// so a smaller terminal canvas can retry the same source.
+				figure.render(context.width);
+				return undefined;
+			}
+			return figure.failed ? null : figure;
+		},
+	};
+	return cachedAssistantMarkdownTheme;
+}
+
 interface ThinkingRepetitionToken {
 	text: string;
 	normalized: string;
@@ -92,6 +134,7 @@ export class AssistantMessageComponent extends Container {
 	#convertedKittyImages = new Map<string, ImageContent & { source: string }>();
 	#kittyConversionsInFlight = new Map<string, string>();
 	#toolImageGenerations = new Map<string, number>();
+	#unsubscribeSettings?: () => void;
 
 	#responseHeader = new Text(theme.bold(theme.fg("statusLineModel", "gajae")), 1, 0);
 	#contentBlocksCache = new WeakMap<object, { source: string; component: Component }>();
@@ -133,6 +176,15 @@ export class AssistantMessageComponent extends Container {
 		}
 		this.#visibleSignature = this.#visibleContentSignature();
 		this.#visibleSignatureInitialized = true;
+		this.#unsubscribeSettings = settings.onChanged(path => {
+			if (path !== "terminal.showImages") return;
+			for (const block of this.#lastMessage?.content ?? []) {
+				if (block.type !== "text") continue;
+				const cached = this.#contentBlocksCache.get(block);
+				if (cached?.component instanceof Markdown) cached.component.invalidate();
+			}
+			this.#requestRepaint?.();
+		});
 	}
 
 	#visibleContentSignature(): string {
@@ -339,7 +391,7 @@ export class AssistantMessageComponent extends Container {
 			cached.source = content.text;
 			return cached.component;
 		}
-		const component = deepInterview ?? new Markdown(trimmed, 1, 0, getMarkdownTheme());
+		const component = deepInterview ?? new Markdown(trimmed, 1, 0, getAssistantMarkdownTheme());
 		if (component instanceof Markdown) {
 			component.setOnStaleThrottle(this.#requestRepaint);
 			component.setStreaming(streaming);
@@ -626,6 +678,8 @@ export class AssistantMessageComponent extends Container {
 	override dispose(): void {
 		if (this.#disposed) return;
 		this.#disposed = true;
+		this.#unsubscribeSettings?.();
+		this.#unsubscribeSettings = undefined;
 		this.#toolImageGenerations.clear();
 		this.#kittyConversionsInFlight.clear();
 		this.#convertedKittyImages.clear();

package/src/modes/components/customization/customization-dashboard.ts

@@ -59,6 +59,7 @@ function safe(text: string): string {
 
 const STATUS_COLORS: Record<InventoryRow["status"], (text: string) => string> = {
 	enabled: text => theme.fg("success", text),
+	"stored-only": text => theme.fg("warning", text),
 	disabled: text => theme.fg("muted", text),
 	invalid: text => theme.fg("error", text),
 	shadowed: text => theme.fg("warning", text),
@@ -281,6 +282,12 @@ export class CustomizationDashboard extends Container {
 	async #toggleSelected(): Promise<void> {
 		const row = this.#selectedRow();
 		if (!row || !this.#guardScope(row)) return;
+		if (row.status === "stored-only") {
+			this.#flashStatus(
+				"project hooks are stored-only; import into Global .gjc or configure an explicit hook path to load them",
+			);
+			return;
+		}
 		if (row.status === "invalid" || row.status === "shadowed" || row.status === "quarantined") {
 			this.#flashStatus(`cannot toggle a ${row.status} entry; resolve its diagnostics first`);
 			return;

package/src/modes/components/customization/import-wizard.ts

@@ -313,20 +313,46 @@ export class ImportWizard extends Container {
 			counts.set(entry.outcome, (counts.get(entry.outcome) ?? 0) + 1);
 		}
 		const summary = [...counts.entries()].map(([outcome, count]) => `${count} ${outcome}`).join(", ");
+		const storedOnlyProjectHooks =
+			this.#result.ok &&
+			this.#plan?.preview.destinationScope === "project" &&
+			this.#result.entries.some(
+				entry =>
+					entry.surface === "hooks" &&
+					(entry.outcome === "imported" || entry.outcome === "renamed" || entry.outcome === "overwritten"),
+			);
 		this.#headerText.setText(
 			this.#result.ok
 				? theme.bold(theme.fg("success", "Import complete"))
 				: theme.bold(theme.fg("error", "Import failed — rolled back, no partial import")),
 		);
 		const failed = this.#result.entries.filter(e => e.outcome === "failed").slice(0, 5);
+		const completionMessages: string[] = [];
+		if (this.#result.ok) {
+			if (storedOnlyProjectHooks) {
+				completionMessages.push(
+					theme.fg(
+						"warning",
+						"Project-scope hooks are stored-only; ordinary sessions do not load repository hook modules.",
+					),
+					theme.fg("muted", "Import hooks into Global .gjc or configure an explicit hook path to activate them."),
+					theme.fg(
+						"muted",
+						"Other imported entries take effect after the documented reload/new-session boundary.",
+					),
+				);
+			} else {
+				completionMessages.push(
+					theme.fg("muted", "Imported entries take effect after the documented reload/new-session boundary."),
+				);
+			}
+		}
 		this.#bodyText.setText(
 			[
 				summary,
 				"",
 				...failed.map(e => theme.fg("error", ` ✗ ${e.surface}: ${safe(e.sourceName)} — ${safe(e.reason ?? "")}`)),
-				...(this.#result.ok
-					? [theme.fg("muted", "Imported entries take effect after the documented reload/new-session boundary.")]
-					: []),
+				...completionMessages,
 			].join("\n"),
 		);
 		this.#footerText.setText(theme.fg("muted", "enter/esc: close"));