@gajae-code/coding-agent 0.2.0 → 0.2.2

package/src/main.ts

@@ -46,6 +46,7 @@ import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
 import { resolveResumableSession, type SessionInfo, SessionManager } from "./session/session-manager";
 import { formatModelOnboardingGuidance } from "./setup/model-onboarding-guidance";
+import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { resolvePromptInput } from "./system-prompt";
 import type { LspStartupServerInfo } from "./tools";
 import { getChangelogPath, getNewEntries, parseChangelog } from "./utils/changelog";
@@ -295,7 +296,14 @@ async function runInteractiveMode(
 
 	for (const message of initialMessages) {
 		try {
-			await session.prompt(message);
+			let text = message;
+			const slashResult = await executeBuiltinSlashCommand(text, {
+				ctx: mode,
+				handleBackgroundCommand: () => mode.handleBackgroundCommand(),
+			});
+			if (slashResult === true) continue;
+			if (typeof slashResult === "string") text = slashResult;
+			await session.prompt(text);
 		} catch (error: unknown) {
 			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
 			mode.showError(errorMessage);
@@ -710,6 +718,7 @@ export async function runRootCommand(
 	if (parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui" || parsedArgs.mode === "acp") {
 		applyRpcDefaultSettingOverrides(settingsInstance);
 	}
+	modelRegistry.applyConfiguredModelBindings(settingsInstance);
 	if (parsedArgs.noPty || parsedArgs.mode === "rpc-ui") {
 		Bun.env.PI_NO_PTY = "1";
 	}

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

@@ -1,5 +1,5 @@
 import { ThinkingLevel } from "@gajae-code/agent-core";
-import { getSupportedEfforts, type Model, modelsAreEqual } from "@gajae-code/ai";
+import { clampThinkingLevelForModel, getSupportedEfforts, type Model, modelsAreEqual } from "@gajae-code/ai";
 import {
 	Container,
 	fuzzyFilter,
@@ -81,18 +81,36 @@ interface RoleAssignment {
 	thinkingLevel: ThinkingLevel;
 }
 
+export interface ModelAssignmentPreset {
+	id: "openai-codex";
+	label: string;
+	description: string;
+	assignments: Partial<Record<GjcModelAssignmentTargetId, ThinkingLevel>>;
+}
+
+export type ModelSelectorSelection =
+	| {
+			kind: "assignment";
+			model: Model;
+			role: GjcModelAssignmentTargetId | null;
+			thinkingLevel?: ThinkingLevel;
+			selector?: string;
+	  }
+	| {
+			kind: "preset";
+			model: Model;
+			selector: string;
+			preset: ModelAssignmentPreset;
+			assignments: Record<GjcModelAssignmentTargetId, ThinkingLevel>;
+	  };
+
 interface PendingThinkingChoice {
 	item: ModelItem | CanonicalModelItem;
 	role: GjcModelAssignmentTargetId | null;
 	levels: ThinkingLevel[];
 }
 
-type RoleSelectCallback = (
-	model: Model,
-	role: GjcModelAssignmentTargetId | null,
-	thinkingLevel?: ThinkingLevel,
-	selector?: string,
-) => void;
+type RoleSelectCallback = (selection: ModelSelectorSelection) => void;
 type CancelCallback = () => void;
 
 interface ProviderTabState {
@@ -107,6 +125,18 @@ const STATIC_PROVIDER_TABS: ProviderTabState[] = [
 	{ id: ALL_TAB, label: ALL_TAB },
 	{ id: CANONICAL_TAB, label: CANONICAL_TAB },
 ];
+const OPENAI_CODE_PROFILE_PRESET: ModelAssignmentPreset = {
+	id: "openai-codex",
+	label: "Apply OpenAI Codex role preset",
+	description: "Default medium, Executor low, Architect xhigh, Planner medium, Critic high",
+	assignments: {
+		default: ThinkingLevel.Medium,
+		executor: ThinkingLevel.Low,
+		architect: ThinkingLevel.XHigh,
+		planner: ThinkingLevel.Medium,
+		critic: ThinkingLevel.High,
+	},
+};
 
 function formatProviderTabLabel(providerId: string): string {
 	return providerId.replace(/[-_]+/g, " ").toUpperCase();
@@ -156,12 +186,7 @@ export class ModelSelectorComponent extends Container {
 		settings: Settings,
 		modelRegistry: ModelRegistry,
 		scopedModels: ReadonlyArray<ScopedModelItem>,
-		onSelect: (
-			model: Model,
-			role: GjcModelAssignmentTargetId | null,
-			thinkingLevel?: ThinkingLevel,
-			selector?: string,
-		) => void,
+		onSelect: RoleSelectCallback,
 		onCancel: () => void,
 		options?: { temporaryOnly?: boolean; initialSearchInput?: string },
 	) {
@@ -750,11 +775,13 @@ export class ModelSelectorComponent extends Container {
 		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 actionCount = this.#getActionCount(item.model);
+		for (let i = 0; i < actionCount; i++) {
 			const prefix = i === this.#selectedActionIndex ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
-			const label = `Set as ${target.tag ?? role.toUpperCase()} (${target.name})`;
+			const role = GJC_MODEL_ASSIGNMENT_TARGET_IDS[i];
+			const label = role
+				? `Set as ${GJC_MODEL_ASSIGNMENT_TARGETS[role].tag ?? role.toUpperCase()} (${GJC_MODEL_ASSIGNMENT_TARGETS[role].name})`
+				: `${OPENAI_CODE_PROFILE_PRESET.label} (${OPENAI_CODE_PROFILE_PRESET.description})`;
 			this.#listContainer.addChild(
 				new Text(`${prefix}${i === this.#selectedActionIndex ? theme.fg("accent", label) : label}`, 0, 0),
 			);
@@ -782,6 +809,9 @@ export class ModelSelectorComponent extends Container {
 	#getCurrentRoleThinkingLevel(role: string): ThinkingLevel {
 		return this.#roles[role]?.thinkingLevel ?? ThinkingLevel.Inherit;
 	}
+	#getActionCount(model: Model): number {
+		return GJC_MODEL_ASSIGNMENT_TARGET_IDS.length + (supportsOpenAICodexPreset(model) ? 1 : 0);
+	}
 
 	#getSelectedItem(): ModelItem | CanonicalModelItem | undefined {
 		return this.#isCanonicalTab()
@@ -853,25 +883,27 @@ export class ModelSelectorComponent extends Container {
 	}
 
 	#handleActionMenuInput(keyData: string): void {
+		const item = this.#pendingActionItem;
+		if (!item) return;
+		const actionCount = this.#getActionCount(item.model);
 		if (matchesKey(keyData, "up")) {
-			this.#selectedActionIndex =
-				this.#selectedActionIndex === 0
-					? GJC_MODEL_ASSIGNMENT_TARGET_IDS.length - 1
-					: this.#selectedActionIndex - 1;
+			this.#selectedActionIndex = this.#selectedActionIndex === 0 ? actionCount - 1 : this.#selectedActionIndex - 1;
 			this.#updateList();
 			return;
 		}
 		if (matchesKey(keyData, "down")) {
-			this.#selectedActionIndex = (this.#selectedActionIndex + 1) % GJC_MODEL_ASSIGNMENT_TARGET_IDS.length;
+			this.#selectedActionIndex = (this.#selectedActionIndex + 1) % actionCount;
 			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);
+			const role = GJC_MODEL_ASSIGNMENT_TARGET_IDS[this.#selectedActionIndex];
+			if (role) {
+				this.#handleSelect(item, role);
+			} else {
+				this.#handlePresetSelect(item, OPENAI_CODE_PROFILE_PRESET);
+			}
 			return;
 		}
 		if (getKeybindings().matches(keyData, "tui.select.cancel")) {
@@ -910,6 +942,18 @@ export class ModelSelectorComponent extends Container {
 			this.#updateList();
 		}
 	}
+	#handlePresetSelect(item: ModelItem | CanonicalModelItem, preset: ModelAssignmentPreset): void {
+		const selectorValue = item.selector;
+		const assignments = resolvePresetAssignments(item.model, preset);
+		for (const [role, thinkingLevel] of Object.entries(assignments) as [
+			GjcModelAssignmentTargetId,
+			ThinkingLevel,
+		][]) {
+			this.#roles[role] = { model: item.model, thinkingLevel };
+		}
+		this.#onSelectCallback({ kind: "preset", model: item.model, selector: selectorValue, preset, assignments });
+		this.#updateList();
+	}
 
 	#handleSelect(
 		item: ModelItem | CanonicalModelItem,
@@ -927,7 +971,13 @@ export class ModelSelectorComponent extends Container {
 
 		// For temporary role, don't save to settings - just notify caller
 		if (role === null) {
-			this.#onSelectCallback(item.model, null, itemThinkingLevel, item.selector);
+			this.#onSelectCallback({
+				kind: "assignment",
+				model: item.model,
+				role: null,
+				thinkingLevel: itemThinkingLevel,
+				selector: item.selector,
+			});
 			return;
 		}
 
@@ -939,7 +989,13 @@ export class ModelSelectorComponent extends Container {
 		this.#roles[role] = { model: item.model, thinkingLevel: selectedThinkingLevel };
 
 		// Notify caller (for updating agent state if needed)
-		this.#onSelectCallback(item.model, role, selectedThinkingLevel, selectorValue);
+		this.#onSelectCallback({
+			kind: "assignment",
+			model: item.model,
+			role,
+			thinkingLevel: selectedThinkingLevel,
+			selector: selectorValue,
+		});
 
 		// Update list to show new badges
 		this.#updateList();
@@ -954,6 +1010,31 @@ function requiresExplicitThinkingChoice(model: Model): boolean {
 	return model.reasoning === true && (model.provider === "openai" || model.provider === "openai-codex");
 }
 
+function supportsOpenAICodexPreset(model: Model): boolean {
+	return model.provider === "openai-codex" && model.reasoning === true;
+}
+
+function resolvePresetAssignments(
+	model: Model,
+	preset: ModelAssignmentPreset,
+): Record<GjcModelAssignmentTargetId, ThinkingLevel> {
+	const resolved = {} as Record<GjcModelAssignmentTargetId, ThinkingLevel>;
+	for (const [role, requestedLevel] of Object.entries(preset.assignments) as [
+		GjcModelAssignmentTargetId,
+		ThinkingLevel,
+	][]) {
+		const clampedLevel =
+			requestedLevel === ThinkingLevel.Off || requestedLevel === ThinkingLevel.Inherit
+				? requestedLevel
+				: clampThinkingLevelForModel(model, requestedLevel);
+		if (!clampedLevel) {
+			throw new Error(`Model ${model.provider}/${model.id} does not support ${requestedLevel} reasoning`);
+		}
+		resolved[role] = clampedLevel;
+	}
+	return resolved;
+}
+
 function getSelectableThinkingLevels(model: Model): ThinkingLevel[] {
 	const levels: ThinkingLevel[] = [ThinkingLevel.Off];
 	let efforts: readonly string[];

package/src/modes/components/skill-hud/render.ts

@@ -1,4 +1,5 @@
 import type { SkillActiveEntry, WorkflowHudChip } from "../../../skill-state/active-state";
+import { workflowReceiptStatus } from "../../../skill-state/workflow-state-contract";
 
 const ANSI_RESET_FG = "\x1b[39m";
 const ANSI_RESET_BOLD = "\x1b[22m";
@@ -60,6 +61,9 @@ function formatEntry(entry: SkillActiveEntry): string {
 		.map(formatChip)
 		.filter((chip): chip is string => Boolean(chip));
 	if (entry.stale === true) chips.unshift("warn:stale");
+	const receiptStatus = workflowReceiptStatus(entry.receipt);
+	if (receiptStatus === "stale") chips.unshift("warn:receipt=stale");
+	if (receiptStatus === "fresh") chips.push("receipt=fresh");
 	const summary = sanitizeHudPart(entry.hud?.summary);
 	return [base, summary, ...chips].filter(Boolean).join(" ");
 }

package/src/modes/components/status-line/segments.ts

@@ -110,10 +110,9 @@ const modelSegment: StatusLineSegment = {
 	},
 };
 
-function formatGoalBudget(current: number, budget?: number): string {
+function formatGoalUsage(current: number): string {
 	const used = formatNumber(current);
-	if (budget === undefined) return used;
-	return `${used}/${formatNumber(budget)}`;
+	return used;
 }
 
 function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: boolean }): RenderedSegment {
@@ -131,10 +130,6 @@ function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: b
 			icon = theme.symbol("status.success");
 			color = "success";
 			break;
-		case "budget-limited":
-			icon = theme.symbol("status.warning");
-			color = "warning";
-			break;
 		case "dropped":
 			icon = theme.symbol("status.aborted");
 			color = "dim";
@@ -144,9 +139,9 @@ function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: b
 	}
 
 	const parts: string[] = [withIcon(icon, "Goal")];
-	const showBudget = ctx.session.settings.get("goal.statusInFooter") === true;
-	if (showBudget && goal) {
-		parts.push(formatGoalBudget(goal.tokensUsed, goal.tokenBudget));
+	const showUsage = ctx.session.settings.get("goal.statusInFooter") === true;
+	if (showUsage && goal) {
+		parts.push(formatGoalUsage(goal.tokensUsed));
 	}
 	return { content: theme.fg(color, parts.join(" ")), visible: true };
 }
@@ -169,12 +164,6 @@ const modeSegment: StatusLineSegment = {
 			return renderGoalMode(ctx, goal);
 		}
 
-		const loop = ctx.loopMode;
-		if (loop?.enabled) {
-			const content = withIcon(theme.icon.loop, "Loop");
-			return { content: theme.fg("customMessageLabel", content), visible: true };
-		}
-
 		return { content: "", visible: false };
 	},
 };

package/src/modes/components/status-line/types.ts

@@ -24,9 +24,6 @@ export interface SegmentContext {
 		enabled: boolean;
 		paused: boolean;
 	} | null;
-	loopMode: {
-		enabled: boolean;
-	} | null;
 	goalMode: {
 		enabled: boolean;
 		paused: boolean;

package/src/modes/components/status-line.ts

@@ -155,7 +155,6 @@ export class StatusLineComponent implements Component {
 	#subagentCount: number = 0;
 	#sessionStartTime: number = Date.now();
 	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
-	#loopModeStatus: { enabled: boolean } | null = null;
 	#goalModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#skillHudEntries: SkillActiveEntry[] = [];
 	#skillHudLastFetch = 0;
@@ -229,10 +228,6 @@ export class StatusLineComponent implements Component {
 		this.#planModeStatus = status ?? null;
 	}
 
-	setLoopModeStatus(status: { enabled: boolean } | undefined): void {
-		this.#loopModeStatus = status ?? null;
-	}
-
 	setGoalModeStatus(status: { enabled: boolean; paused: boolean } | undefined): void {
 		this.#goalModeStatus = status ?? null;
 	}
@@ -611,7 +606,6 @@ export class StatusLineComponent implements Component {
 			width,
 			options: this.#resolveSettings().segmentOptions ?? {},
 			planMode: this.#planModeStatus,
-			loopMode: this.#loopModeStatus,
 			goalMode: this.#goalModeStatus,
 			usageStats,
 			contextPercent,

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

@@ -1248,7 +1248,31 @@ export class CommandController {
 			this.ctx.statusContainer.clear();
 			this.ctx.editor.onEscape = originalOnEscape;
 		}
-		this.ctx.ui.requestRender();
+	}
+
+	async handleContributionPrepCommand(customInstructions?: string): Promise<void> {
+		this.ctx.editor.setText("");
+		try {
+			const result = await this.ctx.session.prepareContributionPrep({ customInstructions, spawnWorker: true });
+			this.ctx.showStatus(
+				[
+					"Contribution prep artifacts written.",
+					`Manifest: ${result.manifestPath}`,
+					`Worker prompt: ${result.workerPromptPath}`,
+				].join("\n"),
+			);
+			this.ctx.chatContainer.addChild(
+				new Text(
+					`${theme.fg("accent", `${theme.status.success} Contribution prep ready`)}\nManifest: ${result.manifestPath}`,
+					1,
+					1,
+				),
+			);
+			this.ctx.ui.requestRender();
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.ctx.showError(`Contribution prep failed: ${message}`);
+		}
 	}
 }
 

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

@@ -51,15 +51,6 @@ export class InputController {
 					this.ctx.retryEscapeHandler,
 			);
 		this.ctx.editor.onEscape = () => {
-			if (this.ctx.loopModeEnabled) {
-				this.ctx.pauseLoop();
-				if (this.ctx.session.isStreaming) {
-					void this.#abortInteractive();
-				} else {
-					this.ctx.cancelPendingSubmission();
-				}
-				return;
-			}
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				return;
 			}
@@ -292,12 +283,6 @@ export class InputController {
 				}
 			}
 
-			// While loop mode is on, every user-typed prompt becomes the new loop
-			// prompt that auto-resubmits after each yield.
-			if (this.ctx.loopModeEnabled) {
-				this.ctx.loopPrompt = text;
-			}
-
 			// Queue input during compaction
 			if (this.ctx.session.isCompacting) {
 				if (this.ctx.pendingImages.length > 0) {

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

@@ -37,7 +37,7 @@ import { AgentDashboard } from "../components/agent-dashboard";
 import { AssistantMessageComponent } from "../components/assistant-message";
 import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
-import { ModelSelectorComponent } from "../components/model-selector";
+import { ModelSelectorComponent, type ModelSelectorSelection } from "../components/model-selector";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
 import {
@@ -431,8 +431,15 @@ export class SelectorController {
 				this.ctx.settings,
 				this.ctx.session.modelRegistry,
 				this.ctx.session.scopedModels,
-				async (model, role, thinkingLevel, selector) => {
+				async selection => {
 					try {
+						if (selection.kind === "preset") {
+							await this.#applyModelAssignmentPreset(selection);
+							done();
+							this.ctx.ui.requestRender();
+							return;
+						}
+						const { model, role, thinkingLevel, selector } = selection;
 						if (role === null) {
 							// Temporary: update agent state but don't persist to settings
 							await this.ctx.session.setModelTemporary(model, thinkingLevel);
@@ -483,6 +490,39 @@ export class SelectorController {
 		});
 	}
 
+	async #applyModelAssignmentPreset(selection: Extract<ModelSelectorSelection, { kind: "preset" }>): Promise<void> {
+		const { assignments, model, preset, selector } = selection;
+		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 defaultThinkingLevel = assignments.default;
+		await this.ctx.session.setModel(model, "default", {
+			selector,
+			thinkingLevel: defaultThinkingLevel,
+		});
+		if (defaultThinkingLevel && defaultThinkingLevel !== ThinkingLevel.Inherit) {
+			this.ctx.session.setThinkingLevel(defaultThinkingLevel);
+		}
+
+		const overrides = this.ctx.settings.get("task.agentModelOverrides");
+		const nextOverrides = { ...overrides };
+		for (const [targetRole, presetThinkingLevel] of Object.entries(assignments) as [
+			keyof Extract<ModelSelectorSelection, { kind: "preset" }>["assignments"],
+			ThinkingLevel,
+		][]) {
+			if (!targetRole || targetRole === "default") continue;
+			nextOverrides[targetRole] =
+				presetThinkingLevel === ThinkingLevel.Inherit ? selector : `${selector}:${presetThinkingLevel}`;
+		}
+		this.ctx.settings.set("task.agentModelOverrides", nextOverrides);
+		this.ctx.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
+		this.ctx.statusLine.invalidate();
+		this.ctx.updateEditorBorderColor();
+		this.ctx.showStatus(`${preset.label}: ${selector}`);
+	}
+
 	async showPluginSelector(mode: "install" | "uninstall" = "install"): Promise<void> {
 		const mgr = new MarketplaceManager({
 			marketplacesRegistryPath: getMarketplacesRegistryPath(),