@gajae-code/coding-agent 0.1.1 → 0.1.2

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

@@ -12,9 +12,9 @@ import {
 	Text,
 	type TUI,
 } from "@gajae-code/tui";
-import type { ModelRegistry } from "../../config/model-registry";
-import { getRoleInfo } from "../../config/model-registry";
-import { resolveModelRoleValue } from "../../config/model-resolver";
+import type { GjcModelAssignmentTargetId, ModelRegistry } from "../../config/model-registry";
+import { GJC_MODEL_ASSIGNMENT_TARGET_IDS, GJC_MODEL_ASSIGNMENT_TARGETS } from "../../config/model-registry";
+import { formatModelSelectorValue, resolveModelRoleValue } from "../../config/model-resolver";
 import type { Settings } from "../../config/settings";
 import { type ThemeColor, theme } from "../../modes/theme/theme";
 import { formatModelOnboardingInlineHint } from "../../setup/model-onboarding-guidance";
@@ -53,6 +53,7 @@ interface ModelItem {
 	id: string;
 	model: Model;
 	selector: string;
+	thinkingLevel?: ThinkingLevel;
 }
 
 interface CanonicalModelItem {
@@ -64,11 +65,12 @@ interface CanonicalModelItem {
 	searchText: string;
 	normalizedSearchText: string;
 	compactSearchText: string;
+	thinkingLevel?: ThinkingLevel;
 }
 
 interface ScopedModelItem {
 	model: Model;
-	thinkingLevel?: string;
+	thinkingLevel?: ThinkingLevel;
 }
 
 interface RoleAssignment {
@@ -78,7 +80,7 @@ interface RoleAssignment {
 
 type RoleSelectCallback = (
 	model: Model,
-	role: "default" | null,
+	role: GjcModelAssignmentTargetId | null,
 	thinkingLevel?: ThinkingLevel,
 	selector?: string,
 ) => void;
@@ -108,7 +110,7 @@ function createProviderTab(providerId: string): ProviderTabState {
  * Component that renders a canonical model selector with provider tabs.
  * - Tab/Arrow Left/Right: Switch between provider tabs
  * - Arrow Up/Down: Navigate model list
- * - Enter: Select the highlighted model as the canonical/default model
+ * - Enter: Open assignment actions for default plus GJC role-agent models
  * - Escape: Close selector
  */
 export class ModelSelectorComponent extends Container {
@@ -130,6 +132,8 @@ export class ModelSelectorComponent extends Container {
 	#tui: TUI;
 	#scopedModels: ReadonlyArray<ScopedModelItem>;
 	#temporaryOnly: boolean;
+	#pendingActionItem?: ModelItem | CanonicalModelItem;
+	#selectedActionIndex: number = 0;
 
 	// Tab state
 	#providers: ProviderTabState[] = STATIC_PROVIDER_TABS;
@@ -141,7 +145,12 @@ export class ModelSelectorComponent extends Container {
 		settings: Settings,
 		modelRegistry: ModelRegistry,
 		scopedModels: ReadonlyArray<ScopedModelItem>,
-		onSelect: (model: Model, role: "default" | null, thinkingLevel?: ThinkingLevel, selector?: string) => void,
+		onSelect: (
+			model: Model,
+			role: GjcModelAssignmentTargetId | null,
+			thinkingLevel?: ThinkingLevel,
+			selector?: string,
+		) => void,
 		onCancel: () => void,
 		options?: { temporaryOnly?: boolean; initialSearchInput?: string },
 	) {
@@ -183,7 +192,7 @@ export class ModelSelectorComponent extends Container {
 		this.#searchInput.onSubmit = () => {
 			const selectedItem = this.#getSelectedItem();
 			if (selectedItem) {
-				this.#handleSelect(selectedItem, this.#temporaryOnly ? null : "default");
+				this.#beginActionMenuOrSelect(selectedItem);
 			}
 		};
 		this.addChild(this.#searchInput);
@@ -219,8 +228,11 @@ export class ModelSelectorComponent extends Container {
 	#loadRoleModels(): void {
 		const allModels = this.#modelRegistry.getAll();
 		const matchPreferences = { usageOrder: this.#settings.getStorage()?.getModelUsageOrder() };
-		for (const role of ["default"]) {
-			const roleValue = this.#settings.getModelRole(role);
+		const agentModelOverrides = this.#settings.get("task.agentModelOverrides");
+		for (const role of GJC_MODEL_ASSIGNMENT_TARGET_IDS) {
+			const target = GJC_MODEL_ASSIGNMENT_TARGETS[role];
+			const roleValue =
+				target.settingsPath === "modelRoles" ? this.#settings.getModelRole(role) : agentModelOverrides[role];
 			if (!roleValue) continue;
 
 			const resolved = resolveModelRoleValue(roleValue, allModels, {
@@ -336,6 +348,7 @@ export class ModelSelectorComponent extends Container {
 				id: scoped.model.id,
 				model: scoped.model,
 				selector: `${scoped.model.provider}/${scoped.model.id}`,
+				thinkingLevel: scoped.thinkingLevel,
 			}));
 		} else {
 			// Reload config and cached discovery state without blocking on live provider refresh
@@ -369,17 +382,20 @@ export class ModelSelectorComponent extends Container {
 			}
 		}
 
+		const candidateModels = models.map(item => item.model);
 		const canonicalRecords = this.#modelRegistry.getCanonicalModels({
 			availableOnly: this.#scopedModels.length === 0,
-			candidates: models.map(item => item.model),
+			candidates: candidateModels,
 		});
+		const scopedThinkingBySelector = new Map(models.map(item => [item.selector, item.thinkingLevel]));
 		const canonicalModels = canonicalRecords
-			.map(record => {
+			.map((record): CanonicalModelItem | undefined => {
 				const selectedModel = this.#modelRegistry.resolveCanonicalModel(record.id, {
 					availableOnly: this.#scopedModels.length === 0,
-					candidates: models.map(item => item.model),
+					candidates: candidateModels,
 				});
 				if (!selectedModel) return undefined;
+				const selectedSelector = `${selectedModel.provider}/${selectedModel.id}`;
 				const searchText = [
 					record.id,
 					record.name,
@@ -388,8 +404,8 @@ export class ModelSelectorComponent extends Container {
 					selectedModel.name,
 					...record.variants.flatMap(variant => [variant.selector, variant.model.name]),
 				].join(" ");
-				return {
-					kind: "canonical" as const,
+				const item: CanonicalModelItem = {
+					kind: "canonical",
 					id: record.id,
 					model: selectedModel,
 					selector: record.id,
@@ -398,6 +414,11 @@ export class ModelSelectorComponent extends Container {
 					normalizedSearchText: normalizeSearchText(searchText),
 					compactSearchText: compactSearchText(searchText),
 				};
+				const scopedThinkingLevel = scopedThinkingBySelector.get(selectedSelector);
+				if (scopedThinkingLevel !== undefined) {
+					item.thinkingLevel = scopedThinkingLevel;
+				}
+				return item;
 			})
 			.filter((item): item is CanonicalModelItem => item !== undefined);
 
@@ -627,12 +648,14 @@ export class ModelSelectorComponent extends Container {
 
 			// Build role badges (inverted: color as background, black text)
 			const roleBadgeTokens: string[] = [];
-			const defaultRoleInfo = getRoleInfo("default", this.#settings);
-			const defaultAssigned = this.#roles.default;
-			if (defaultRoleInfo.tag && defaultAssigned && modelsAreEqual(defaultAssigned.model, item.model)) {
-				const badge = makeInvertedBadge(defaultRoleInfo.tag, defaultRoleInfo.color ?? "success");
-				const thinkingLabel = getThinkingLevelMetadata(defaultAssigned.thinkingLevel).label;
-				roleBadgeTokens.push(`${badge} ${theme.fg("dim", `(${thinkingLabel})`)}`);
+			for (const role of GJC_MODEL_ASSIGNMENT_TARGET_IDS) {
+				const roleInfo = GJC_MODEL_ASSIGNMENT_TARGETS[role];
+				const assigned = this.#roles[role];
+				if (roleInfo.tag && assigned && modelsAreEqual(assigned.model, item.model)) {
+					const badge = makeInvertedBadge(roleInfo.tag, roleInfo.color ?? "muted");
+					const thinkingLabel = getThinkingLevelMetadata(assigned.thinkingLevel).label;
+					roleBadgeTokens.push(`${badge} ${theme.fg("dim", `(${thinkingLabel})`)}`);
+				}
 			}
 			const badgeText = roleBadgeTokens.length > 0 ? ` ${roleBadgeTokens.join(" ")}` : "";
 
@@ -699,8 +722,26 @@ export class ModelSelectorComponent extends Container {
 			this.#listContainer.addChild(
 				new Text(theme.fg("muted", `  Model Name: ${selected.model.name}${suffix}`), 0, 0),
 			);
+			if (this.#pendingActionItem) {
+				this.#renderActionMenu(this.#pendingActionItem);
+			}
 		}
 	}
+	#renderActionMenu(item: ModelItem | CanonicalModelItem): void {
+		this.#listContainer.addChild(new Spacer(1));
+		this.#listContainer.addChild(new Text(theme.fg("muted", `  Action for: ${item.model.id}`), 0, 0));
+		this.#listContainer.addChild(new Spacer(1));
+		for (let i = 0; i < GJC_MODEL_ASSIGNMENT_TARGET_IDS.length; i++) {
+			const role = GJC_MODEL_ASSIGNMENT_TARGET_IDS[i];
+			const target = GJC_MODEL_ASSIGNMENT_TARGETS[role];
+			const prefix = i === this.#selectedActionIndex ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
+			const label = `Set as ${target.tag ?? role.toUpperCase()} (${target.name})`;
+			this.#listContainer.addChild(
+				new Text(`${prefix}${i === this.#selectedActionIndex ? theme.fg("accent", label) : label}`, 0, 0),
+			);
+		}
+	}
+
 	#getCurrentRoleThinkingLevel(role: string): ThinkingLevel {
 		return this.#roles[role]?.thinkingLevel ?? ThinkingLevel.Inherit;
 	}
@@ -712,6 +753,11 @@ export class ModelSelectorComponent extends Container {
 	}
 
 	handleInput(keyData: string): void {
+		if (this.#pendingActionItem) {
+			this.#handleActionMenuInput(keyData);
+			return;
+		}
+
 		// Tab bar navigation
 		if (this.#tabBar?.handleInput(keyData)) {
 			return;
@@ -735,12 +781,12 @@ export class ModelSelectorComponent extends Container {
 			return;
 		}
 
-		// Enter - select highlighted model directly. Canonical setup exposes one default model,
-		// while temporary-only mode keeps the existing non-persistent quick-switch behavior.
+		// Enter opens the persistent assignment menu. Temporary-only mode keeps the
+		// existing non-persistent quick-switch behavior.
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			const selectedItem = this.#getSelectedItem();
 			if (selectedItem) {
-				this.#handleSelect(selectedItem, this.#temporaryOnly ? null : "default");
+				this.#beginActionMenuOrSelect(selectedItem);
 			}
 			return;
 		}
@@ -755,20 +801,66 @@ export class ModelSelectorComponent extends Container {
 		this.#searchInput.handleInput(keyData);
 		this.#filterModels(this.#searchInput.getValue());
 	}
-	#handleSelect(item: ModelItem | CanonicalModelItem, role: "default" | null, thinkingLevel?: ThinkingLevel): void {
+	#beginActionMenuOrSelect(item: ModelItem | CanonicalModelItem): void {
+		if (this.#temporaryOnly) {
+			this.#handleSelect(item, null);
+			return;
+		}
+		this.#pendingActionItem = item;
+		this.#selectedActionIndex = 0;
+		this.#updateList();
+	}
+
+	#handleActionMenuInput(keyData: string): void {
+		if (matchesKey(keyData, "up")) {
+			this.#selectedActionIndex =
+				this.#selectedActionIndex === 0
+					? GJC_MODEL_ASSIGNMENT_TARGET_IDS.length - 1
+					: this.#selectedActionIndex - 1;
+			this.#updateList();
+			return;
+		}
+		if (matchesKey(keyData, "down")) {
+			this.#selectedActionIndex = (this.#selectedActionIndex + 1) % GJC_MODEL_ASSIGNMENT_TARGET_IDS.length;
+			this.#updateList();
+			return;
+		}
+		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
+			const item = this.#pendingActionItem;
+			if (!item) return;
+			const role = GJC_MODEL_ASSIGNMENT_TARGET_IDS[this.#selectedActionIndex];
+			this.#pendingActionItem = undefined;
+			this.#handleSelect(item, role);
+			return;
+		}
+		if (getKeybindings().matches(keyData, "tui.select.cancel")) {
+			this.#pendingActionItem = undefined;
+			this.#updateList();
+		}
+	}
+
+	#handleSelect(
+		item: ModelItem | CanonicalModelItem,
+		role: GjcModelAssignmentTargetId | null,
+		thinkingLevel?: ThinkingLevel,
+	): void {
+		const itemThinkingLevel = thinkingLevel ?? item.thinkingLevel;
+
 		// For temporary role, don't save to settings - just notify caller
 		if (role === null) {
-			this.#onSelectCallback(item.model, null, undefined, item.selector);
+			this.#onSelectCallback(item.model, null, itemThinkingLevel, item.selector);
 			return;
 		}
 
-		const selectedThinkingLevel = thinkingLevel ?? this.#getCurrentRoleThinkingLevel(role);
+		const selectedThinkingLevel = itemThinkingLevel ?? this.#getCurrentRoleThinkingLevel(role);
+		const selectorValue =
+			role === "default" ? item.selector : formatModelSelectorValue(item.selector, selectedThinkingLevel);
 
 		// Update local state for UI
 		this.#roles[role] = { model: item.model, thinkingLevel: selectedThinkingLevel };
 
 		// Notify caller (for updating agent state if needed)
-		this.#onSelectCallback(item.model, role, selectedThinkingLevel, item.selector);
+		this.#onSelectCallback(item.model, role, selectedThinkingLevel, selectorValue);
 
 		// Update list to show new badges
 		this.#updateList();

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

@@ -435,14 +435,14 @@ export class SelectorController {
 					try {
 						if (role === null) {
 							// Temporary: update agent state but don't persist to settings
-							await this.ctx.session.setModelTemporary(model);
+							await this.ctx.session.setModelTemporary(model, thinkingLevel);
 							this.ctx.statusLine.invalidate();
 							this.ctx.updateEditorBorderColor();
 							this.ctx.showStatus(`Temporary model: ${selector ?? model.id}`);
 							done();
 							this.ctx.ui.requestRender();
-						} else {
-							// Default: update agent state and persist
+						} else if (role === "default") {
+							// Default: update agent state and persist as the active default model.
 							await this.ctx.session.setModel(model, role, {
 								selector,
 								thinkingLevel,
@@ -455,6 +455,19 @@ export class SelectorController {
 							this.ctx.showStatus(`Default model: ${selector ?? model.id}`);
 							done();
 							this.ctx.ui.requestRender();
+						} else {
+							// Role-agent assignments configure Task dispatch and must not switch the active chat model.
+							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 overrides = this.ctx.settings.get("task.agentModelOverrides");
+							const value = selector ?? `${model.provider}/${model.id}`;
+							this.ctx.settings.set("task.agentModelOverrides", { ...overrides, [role]: value });
+							this.ctx.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
+							this.ctx.showStatus(`${role} agent model: ${value}`);
+							done();
+							this.ctx.ui.requestRender();
 						}
 					} catch (error) {
 						this.ctx.showError(error instanceof Error ? error.message : String(error));

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

@@ -84,6 +84,34 @@ function isSkillCommandAutocompleteItem(item: AutocompleteItem): item is SkillCo
 	return "normalizedSkillCommand" in item && item.normalizedSkillCommand === true;
 }
 
+function mergeAutocompleteSuggestions(
+	primary: { items: AutocompleteItem[]; prefix: string } | null,
+	secondary: { items: AutocompleteItem[]; prefix: string } | null,
+): { items: AutocompleteItem[]; prefix: string } | null {
+	if (!primary) return secondary;
+	if (!secondary) return primary;
+	if (primary.prefix !== secondary.prefix) return primary;
+
+	const seen = new Set<string>();
+	const items: AutocompleteItem[] = [];
+	for (const item of [...primary.items, ...secondary.items]) {
+		const key = `${item.value}\0${item.label}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		items.push(item);
+	}
+
+	return { items, prefix: primary.prefix };
+}
+
+function withoutSkillCommandSuggestions(
+	suggestions: { items: AutocompleteItem[]; prefix: string } | null,
+): { items: AutocompleteItem[]; prefix: string } | null {
+	if (!suggestions) return null;
+	const items = suggestions.items.filter(item => !item.value.startsWith("skill:"));
+	return items.length > 0 ? { ...suggestions, items } : null;
+}
+
 function getPromptActionPrefix(textBeforeCursor: string): string | null {
 	const hashIndex = textBeforeCursor.lastIndexOf("#");
 	if (hashIndex === -1) return null;
@@ -148,8 +176,14 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 			}
 		}
 
-		const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor);
-		if (skillCommandSuggestions) return skillCommandSuggestions;
+		const slashPrefix = getSlashTokenPrefix(textBeforeCursor);
+		if (slashPrefix) {
+			const baseSuggestions = withoutSkillCommandSuggestions(
+				await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol),
+			);
+			const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor);
+			return mergeAutocompleteSuggestions(baseSuggestions, skillCommandSuggestions);
+		}
 
 		if (!isSettingsInitialized() || settings.get("emojiAutocomplete")) {
 			const emojiSuggestions = getEmojiSuggestions(textBeforeCursor);
@@ -215,9 +249,11 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 		return this.#baseProvider.getInlineHint?.(lines, cursorLine, cursorCol) ?? null;
 	}
 	trySyncSlashCompletion(textBeforeCursor: string): { items: AutocompleteItem[]; prefix: string } | null {
+		const baseSuggestions = withoutSkillCommandSuggestions(
+			this.#baseProvider.trySyncSlashCompletion?.(textBeforeCursor) ?? null,
+		);
 		const skillCommandSuggestions = this.#getSkillCommandSuggestions(textBeforeCursor);
-		if (skillCommandSuggestions) return skillCommandSuggestions;
-		return this.#baseProvider.trySyncSlashCompletion?.(textBeforeCursor) ?? null;
+		return mergeAutocompleteSuggestions(baseSuggestions, skillCommandSuggestions);
 	}
 	trySyncInlineReplace(textBeforeCursor: string): { replaceLen: number; insert: string } | null {
 		if (isSettingsInitialized() && !settings.get("emojiAutocomplete")) return null;
@@ -233,17 +269,6 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 		const exactNonSkillCommand = this.#commands.some(
 			command => command.name === query && !command.name.startsWith("skill:"),
 		);
-		if (exactNonSkillCommand) {
-			const command = this.#commands.find(
-				candidate => candidate.name === query && !candidate.name.startsWith("skill:"),
-			);
-			if (command) {
-				return {
-					items: [{ value: command.name, label: command.name, description: command.description }],
-					prefix,
-				};
-			}
-		}
 		const items = this.#commands
 			.filter(command => command.name.startsWith("skill:"))
 			.map(command => {

package/src/session/agent-session.ts

@@ -167,6 +167,7 @@ import {
 import { deobfuscateSessionContext, type SecretObfuscator } from "../secrets/obfuscator";
 import { formatNoCredentialOnboardingError, formatNoModelOnboardingError } from "../setup/model-onboarding-guidance";
 import { isCanonicalGjcWorkflowSkill, syncSkillActiveState } from "../skill-state/active-state";
+import { assertDeepInterviewMutationAllowed } from "../skill-state/deep-interview-mutation-guard";
 import { invalidateHostMetadata } from "../ssh/connection-manager";
 import { resolveThinkingLevelForModel, toReasoningEffort } from "../thinking";
 import {
@@ -3273,6 +3274,35 @@ export class AgentSession {
 		}) as T;
 	}
 
+	/**
+	 * Wrap a tool with the deep-interview mutation guard. This guard is intentionally
+	 * outermost so active interviews reject product-code mutation before ACP permission
+	 * prompts or tool execution can run.
+	 */
+	#wrapToolForDeepInterviewMutationGuard<T extends AgentTool>(tool: T): T {
+		if (!["edit", "write", "ast_edit"].includes(tool.name)) return tool;
+		return new Proxy(tool, {
+			get: (target, prop) => {
+				if (prop !== "execute") return Reflect.get(target, prop, target);
+				return async (
+					toolCallId: string,
+					args: unknown,
+					signal: AbortSignal | undefined,
+					onUpdate: never,
+					ctx: never,
+				) => {
+					await assertDeepInterviewMutationAllowed({
+						cwd: this.sessionManager.getCwd(),
+						sessionId: this.sessionManager.getSessionId(),
+						tool: target,
+						args,
+					});
+					return await target.execute(toolCallId, args as never, signal, onUpdate, ctx);
+				};
+			},
+		}) as T;
+	}
+
 	async #applyActiveToolsByName(
 		toolNames: string[],
 		options?: { persistMCPSelection?: boolean; previousSelectedMCPToolNames?: string[] },
@@ -3284,7 +3314,7 @@ export class AgentSession {
 		for (const name of toolNames) {
 			const tool = this.#toolRegistry.get(name);
 			if (tool) {
-				tools.push(this.#wrapToolForAcpPermission(tool));
+				tools.push(this.#wrapToolForDeepInterviewMutationGuard(this.#wrapToolForAcpPermission(tool)));
 				validToolNames.push(name);
 			}
 		}

package/src/setup/model-onboarding-guidance.ts

@@ -7,14 +7,16 @@ export const MODEL_ONBOARDING_OAUTH_COMMAND = "/provider login [provider-id] or
 export function formatModelOnboardingGuidance(): string {
 	return [
 		"Model selection only shows configured providers.",
+		"Assignment targets are DEFAULT plus the GJC role agents: EXECUTOR, ARCHITECT, PLANNER, and CRITIC.",
+		"Legacy model-role aliases are compatibility-only and are not shown as assignment targets.",
 		`API-compatible providers: ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}).`,
 		`OAuth/subscription providers: ${MODEL_ONBOARDING_OAUTH_COMMAND}.`,
-		"Then run /model to select a configured model.",
+		"Then run /model to select a configured model or assign it to a target.",
 	].join("\n");
 }
 
 export function formatModelOnboardingInlineHint(): string {
-	return `Add API-compatible providers with ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}); OAuth/subscription with ${MODEL_ONBOARDING_OAUTH_COMMAND}; then run /model.`;
+	return `Add API-compatible providers with ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}); OAuth/subscription with ${MODEL_ONBOARDING_OAUTH_COMMAND}; then run /model for DEFAULT, EXECUTOR, ARCHITECT, PLANNER, and CRITIC.`;
 }
 
 export function formatNoModelOnboardingError(): string {
@@ -27,7 +29,7 @@ export function formatNoCredentialOnboardingError(providerId: string): string {
 		"",
 		`For API-compatible providers, configure credentials with ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}).`,
 		`For OAuth/subscription providers, use ${MODEL_ONBOARDING_OAUTH_COMMAND}.`,
-		"Then run /model to select a configured model.",
+		"Then run /model to select a configured model or assign it to DEFAULT, EXECUTOR, ARCHITECT, PLANNER, or CRITIC.",
 	].join("\n");
 }