@gajae-code/coding-agent 0.3.0 → 0.3.2

package/src/commands/launch.ts

@@ -36,6 +36,12 @@ export default class Index extends Command {
 		plan: Flags.string({
 			description: "Plan model for architectural planning (or GJC_PLAN_MODEL env)",
 		}),
+		mpreset: Flags.string({
+			description: "Model profile preset to activate for this session",
+		}),
+		default: Flags.boolean({
+			description: "Persist --mpreset as the default model profile",
+		}),
 		provider: Flags.string({
 			description: "Provider to use (legacy; prefer --model)",
 		}),
@@ -52,8 +58,8 @@ export default class Index extends Command {
 			description: "Allow starting in ~ without auto-switching to a temp dir",
 		}),
 		mode: Flags.string({
-			description: "Output mode: text (default), json, rpc, or rpc-ui",
-			options: ["text", "json", "rpc", "acp", "rpc-ui"],
+			description: "Output mode: text (default), json, rpc, acp, rpc-ui, or bridge",
+			options: ["text", "json", "rpc", "acp", "rpc-ui", "bridge"],
 		}),
 		print: Flags.boolean({
 			char: "p",
@@ -136,6 +142,8 @@ export default class Index extends Command {
 		`# Launch in a sibling git worktree\n  ${APP_NAME} --worktree`,
 		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
 		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
+		`# Activate a model profile for this session\n  ${APP_NAME} --mpreset codex-standard`,
+		`# Persist a model profile as the default\n  ${APP_NAME} --mpreset opencode-go-pro --default`,
 		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.gjc/agent/sessions/--path--/session.jsonl`,
 	];
 

package/src/commands/state.ts

@@ -9,9 +9,10 @@ export default class State extends Command {
 		'$ gjc state write --input \'{"state":{"interview_id":"abc"}}\' --mode deep-interview --json',
 		"$ gjc state clear --mode deep-interview",
 		"$ gjc state deep-interview read --json",
-		'$ gjc state ralplan write --input \'{"phase":"approval","active":true}\' --json',
+		'$ gjc state ralplan write --input \'{"phase":"planner","active":true}\' --json',
 		"$ gjc state team contract",
 		"$ gjc state deep-interview handoff --to ralplan --json",
+		"$ gjc state doctor --skill ralplan --json",
 	];
 
 	async run(): Promise<void> {

package/src/commands/team.ts

@@ -1,4 +1,5 @@
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { renderCliWriteReceipt } from "../gjc-runtime/cli-write-receipt";
 import { renderTeamStatusMarkdown } from "../gjc-runtime/state-renderer";
 import {
 	buildTeamHudSummary,
@@ -45,6 +46,23 @@ function formatTaskCounts(counts: Record<string, number>): string {
 		.join(" ");
 }
 
+function snapshotWriteReceipt(snapshot: GjcTeamSnapshot): Record<string, unknown> {
+	return {
+		ok: true,
+		team_name: snapshot.team_name,
+		phase: snapshot.phase,
+		state_dir: snapshot.state_dir,
+		tmux_session: snapshot.tmux_session,
+		tmux_target: snapshot.tmux_target,
+		worker_count: snapshot.workers.length,
+		task_counts: snapshot.task_counts,
+	};
+}
+
+function writeReceipt(value: Record<string, unknown>): void {
+	process.stdout.write(renderCliWriteReceipt(value));
+}
+
 function parseInputFlag(argv: string[]): Record<string, unknown> {
 	const index = argv.indexOf("--input");
 	if (index < 0) return {};
@@ -124,7 +142,7 @@ export default class Team extends Command {
 			const snapshot = await monitorGjcTeamSnapshot(teamName);
 			await syncTeamHud(snapshot);
 			if (json) {
-				writeJson(snapshot);
+				writeReceipt(snapshotWriteReceipt(snapshot));
 				return;
 			}
 			writeText([
@@ -141,7 +159,7 @@ export default class Team extends Command {
 			const snapshot = await shutdownGjcTeam(teamName);
 			await syncTeamHud(snapshot);
 			if (json) {
-				writeJson(snapshot);
+				writeReceipt(snapshotWriteReceipt(snapshot));
 				return;
 			}
 			writeText([`team: ${snapshot.team_name}`, `phase: ${snapshot.phase}`, `state: ${snapshot.state_dir}`]);
@@ -174,7 +192,7 @@ export default class Team extends Command {
 					// API operations without a resolvable snapshot leave HUD state unchanged.
 				}
 			}
-			writeJson(result);
+			writeReceipt(result as Record<string, unknown>);
 			return;
 		}
 
@@ -183,7 +201,7 @@ export default class Team extends Command {
 		const snapshot = await startGjcTeam({ ...options, dryRun });
 		await syncTeamHud(snapshot);
 		if (json) {
-			writeJson(snapshot);
+			writeReceipt(snapshotWriteReceipt(snapshot));
 			return;
 		}
 		writeText([

package/src/config/keybindings.ts

@@ -38,6 +38,7 @@ interface AppKeybindings {
 	"app.session.fork": true;
 	"app.session.resume": true;
 	"app.session.observe": true;
+	"app.jobs.open": true;
 	"app.session.togglePath": true;
 	"app.session.toggleSort": true;
 	"app.session.rename": true;
@@ -149,6 +150,11 @@ export const KEYBINDINGS = {
 		defaultKeys: "ctrl+s",
 		description: "Observe subagent sessions",
 	},
+
+	"app.jobs.open": {
+		defaultKeys: "alt+j",
+		description: "Open monitor/cron jobs overlay",
+	},
 	"app.session.togglePath": {
 		defaultKeys: "ctrl+p",
 		description: "Toggle session path display",

package/src/config/model-profile-activation.ts

@@ -0,0 +1,157 @@
+import type { ThinkingLevel } from "@gajae-code/agent-core";
+import type { Api, Model } from "@gajae-code/ai";
+import type { AgentSession } from "../session/agent-session";
+import {
+	aggregateModelProfileRequiredProviders,
+	formatAvailableProfileNames,
+	resolveProfileBindings,
+} from "./model-profiles";
+import { type GjcModelAssignmentTargetId, isAuthenticated, type ModelRegistry } from "./model-registry";
+import { resolveModelRoleValue } from "./model-resolver";
+import type { Settings } from "./settings";
+
+export interface PrepareModelProfileActivationOptions {
+	session: Pick<AgentSession, "model" | "thinkingLevel" | "sessionId">;
+	modelRegistry: Pick<
+		ModelRegistry,
+		| "getModelProfile"
+		| "getModelProfiles"
+		| "getAvailableModelProfileNames"
+		| "getApiKeyForProvider"
+		| "getAll"
+		| "resolveCanonicalModel"
+		| "getCanonicalVariants"
+		| "getCanonicalId"
+	>;
+	settings: Pick<Settings, "get">;
+	profileName: string;
+}
+
+export interface PreparedModelProfileActivation {
+	profileName: string;
+	session: Pick<AgentSession, "model" | "thinkingLevel" | "sessionId" | "setModelTemporary">;
+	settings: Pick<Settings, "get" | "override" | "set" | "flush">;
+	previousModel: Model<Api> | undefined;
+	previousThinkingLevel: ThinkingLevel | undefined;
+	previousAgentModelOverrides: Record<string, string>;
+	defaultModel: Model<Api> | undefined;
+	defaultThinkingLevel: ThinkingLevel | undefined;
+	agentModelOverrides: Record<string, string>;
+}
+
+export function formatModelProfileCredentialError(profileName: string, providers: readonly string[]): string {
+	return `Model profile "${profileName}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
+}
+
+export async function prepareModelProfileActivation(
+	options: PrepareModelProfileActivationOptions,
+): Promise<PreparedModelProfileActivation> {
+	const profile = options.modelRegistry.getModelProfile(options.profileName);
+	if (!profile) {
+		const available = formatAvailableProfileNames(options.modelRegistry.getModelProfiles());
+		throw new Error(`Unknown model profile "${options.profileName}". Available profiles: ${available}`);
+	}
+
+	const missingProviders: string[] = [];
+	for (const provider of aggregateModelProfileRequiredProviders(profile.requiredProviders, profile)) {
+		const apiKey = await options.modelRegistry.getApiKeyForProvider(provider, options.session.sessionId);
+		if (!isAuthenticated(apiKey)) {
+			missingProviders.push(provider);
+		}
+	}
+	if (missingProviders.length > 0) {
+		throw new Error(formatModelProfileCredentialError(options.profileName, missingProviders));
+	}
+
+	const availableModels = options.modelRegistry.getAll();
+	const bindings = resolveProfileBindings(profile);
+	const resolvedDefault = bindings.defaultSelector
+		? resolveModelRoleValue(bindings.defaultSelector, availableModels, {
+				settings: options.settings as Settings,
+				modelRegistry: options.modelRegistry,
+			})
+		: undefined;
+	if (bindings.defaultSelector && !resolvedDefault?.model) {
+		throw new Error(
+			`Model profile "${options.profileName}" default selector did not resolve: ${bindings.defaultSelector}`,
+		);
+	}
+
+	const agentModelOverrides: Record<string, string> = {};
+	for (const [role, selector] of Object.entries(bindings.agentModelOverrides) as [
+		GjcModelAssignmentTargetId,
+		string,
+	][]) {
+		const resolved = resolveModelRoleValue(selector, availableModels, {
+			settings: options.settings as Settings,
+			modelRegistry: options.modelRegistry,
+		});
+		if (!resolved.model) {
+			throw new Error(`Model profile "${options.profileName}" ${role} selector did not resolve: ${selector}`);
+		}
+		agentModelOverrides[role] = selector;
+	}
+
+	return {
+		profileName: options.profileName,
+		session: options.session as PreparedModelProfileActivation["session"],
+		settings: options.settings as PreparedModelProfileActivation["settings"],
+		previousModel: options.session.model,
+		previousThinkingLevel: options.session.thinkingLevel,
+		previousAgentModelOverrides: { ...options.settings.get("task.agentModelOverrides") },
+		defaultModel: resolvedDefault?.model,
+		defaultThinkingLevel: resolvedDefault?.thinkingLevel,
+		agentModelOverrides,
+	};
+}
+
+export async function applyPreparedModelProfileActivation(
+	prepared: PreparedModelProfileActivation,
+	options: { persistDefault?: boolean } = {},
+): Promise<void> {
+	const previousModel = prepared.previousModel;
+	const previousThinkingLevel = prepared.previousThinkingLevel;
+	const previousAgentModelOverrides = prepared.previousAgentModelOverrides;
+	const previousPersistedDefault = prepared.settings.get("modelProfile.default");
+	let modelChanged = false;
+	let overridesChanged = false;
+	let defaultChanged = false;
+
+	try {
+		if (prepared.defaultModel) {
+			await prepared.session.setModelTemporary(prepared.defaultModel, prepared.defaultThinkingLevel);
+			modelChanged = true;
+		}
+		if (Object.keys(prepared.agentModelOverrides).length > 0) {
+			prepared.settings.override("task.agentModelOverrides", {
+				...prepared.settings.get("task.agentModelOverrides"),
+				...prepared.agentModelOverrides,
+			});
+			overridesChanged = true;
+		}
+		if (options.persistDefault) {
+			prepared.settings.set("modelProfile.default", prepared.profileName);
+			defaultChanged = true;
+			await prepared.settings.flush();
+		}
+	} catch (error) {
+		if (defaultChanged) {
+			prepared.settings.set("modelProfile.default", previousPersistedDefault);
+		}
+		if (overridesChanged) {
+			prepared.settings.override("task.agentModelOverrides", previousAgentModelOverrides);
+		}
+		if (modelChanged && previousModel) {
+			await prepared.session.setModelTemporary(previousModel, previousThinkingLevel);
+		}
+		throw error;
+	}
+}
+
+export async function activateModelProfile(
+	options: PrepareModelProfileActivationOptions,
+	applyOptions: { persistDefault?: boolean } = {},
+): Promise<void> {
+	const prepared = await prepareModelProfileActivation(options);
+	await applyPreparedModelProfileActivation(prepared, applyOptions);
+}

package/src/config/model-profiles.ts

@@ -0,0 +1,155 @@
+import type { GjcModelAssignmentTargetId } from "./model-registry";
+import type { ModelsConfig } from "./models-config-schema";
+
+export type ModelProfileRole = GjcModelAssignmentTargetId;
+
+export interface ModelProfileDefinition {
+	name: string;
+	requiredProviders: string[];
+	modelMapping: Partial<Record<ModelProfileRole, string>>;
+	source: "builtin" | "user";
+}
+
+export interface ResolvedProfileBinding {
+	defaultSelector?: string;
+	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default">, string>>;
+}
+
+function parseModelSelectorProvider(selector: string): string | undefined {
+	const slashIdx = selector.indexOf("/");
+	if (slashIdx <= 0) return undefined;
+	return selector.slice(0, slashIdx);
+}
+
+export function deriveModelProfileMappedProviders(definition: Pick<ModelProfileDefinition, "modelMapping">): string[] {
+	const providers = new Set<string>();
+	for (const selector of Object.values(definition.modelMapping)) {
+		if (!selector) continue;
+		const provider = parseModelSelectorProvider(selector);
+		if (provider) providers.add(provider);
+	}
+	return [...providers].sort((a, b) => a.localeCompare(b));
+}
+
+export function aggregateModelProfileRequiredProviders(
+	requiredProviders: readonly string[],
+	definition: Pick<ModelProfileDefinition, "modelMapping">,
+): string[] {
+	const providers = new Set(requiredProviders);
+	for (const provider of deriveModelProfileMappedProviders(definition)) {
+		providers.add(provider);
+	}
+	return [...providers];
+}
+
+const profile = (
+	name: string,
+	requiredProviders: string[],
+	modelMapping: Record<ModelProfileRole, string>,
+): ModelProfileDefinition => ({
+	name,
+	requiredProviders: aggregateModelProfileRequiredProviders(requiredProviders, { modelMapping }),
+	modelMapping,
+	source: "builtin",
+});
+
+export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
+	profile("opencode-go-eco", ["opencode-go"], {
+		default: "opencode-go/deepseek-v4-flash",
+		executor: "opencode-go/qwen3.5-plus",
+		architect: "opencode-go/glm-5",
+		planner: "opencode-go/minimax-m2.5",
+		critic: "opencode-go/kimi-k2.5",
+	}),
+	profile("opencode-go-standard", ["opencode-go"], {
+		default: "opencode-go/kimi-k2.6",
+		executor: "opencode-go/qwen3.6-plus",
+		architect: "opencode-go/glm-5.1",
+		planner: "opencode-go/minimax-m2.7",
+		critic: "opencode-go/deepseek-v4-pro",
+	}),
+	profile("opencode-go-pro", ["opencode-go"], {
+		default: "opencode-go/qwen3.7-max",
+		executor: "opencode-go/kimi-k2.6",
+		architect: "opencode-go/deepseek-v4-pro:high",
+		planner: "opencode-go/glm-5.1:high",
+		critic: "opencode-go/minimax-m2.7:high",
+	}),
+	profile("codex-eco", ["openai-codex"], {
+		default: "openai-codex/gpt-5.4-mini",
+		executor: "openai-codex/gpt-5.4-nano",
+		architect: "openai-codex/gpt-5.4-mini",
+		planner: "openai-codex/gpt-5.4-mini",
+		critic: "openai-codex/gpt-5.4-mini",
+	}),
+	profile("codex-standard", ["openai-codex"], {
+		default: "openai-codex/gpt-5.4:medium",
+		executor: "openai-codex/gpt-5.4:low",
+		architect: "openai-codex/gpt-5.4:xhigh",
+		planner: "openai-codex/gpt-5.4:medium",
+		critic: "openai-codex/gpt-5.4:high",
+	}),
+	profile("codex-pro", ["openai-codex"], {
+		default: "openai-codex/gpt-5.5",
+		executor: "openai-codex/gpt-5.2-codex",
+		architect: "openai-codex/gpt-5.1-codex-max:high",
+		planner: "openai-codex/gpt-5.5:high",
+		critic: "openai-codex/gpt-5.3-codex-spark:high",
+	}),
+	profile("opencode-go-codex-eco", ["opencode-go", "openai-codex"], {
+		default: "opencode-go/deepseek-v4-flash",
+		executor: "opencode-go/qwen3.5-plus",
+		architect: "openai-codex/gpt-5.4-mini",
+		planner: "openai-codex/gpt-5.4-mini",
+		critic: "openai-codex/gpt-5.4-mini",
+	}),
+	profile("opencode-go-codex-standard", ["opencode-go", "openai-codex"], {
+		default: "opencode-go/kimi-k2.6",
+		executor: "opencode-go/qwen3.6-plus",
+		architect: "openai-codex/gpt-5.4",
+		planner: "openai-codex/gpt-5.4",
+		critic: "openai-codex/gpt-5.4",
+	}),
+	profile("opencode-go-codex-pro", ["opencode-go", "openai-codex"], {
+		default: "opencode-go/qwen3.7-max",
+		executor: "opencode-go/kimi-k2.6",
+		architect: "openai-codex/gpt-5.1-codex-max:high",
+		planner: "openai-codex/gpt-5.5:high",
+		critic: "openai-codex/gpt-5.3-codex-spark:high",
+	}),
+];
+
+export function mergeModelProfiles(userProfiles?: ModelsConfig["profiles"]): Map<string, ModelProfileDefinition> {
+	const profiles = new Map<string, ModelProfileDefinition>();
+	for (const definition of BUILTIN_MODEL_PROFILES) {
+		profiles.set(definition.name, {
+			...definition,
+			requiredProviders: [...definition.requiredProviders],
+			modelMapping: { ...definition.modelMapping },
+		});
+	}
+	for (const [name, definition] of Object.entries(userProfiles ?? {})) {
+		const modelMapping = { ...definition.model_mapping };
+		profiles.set(name, {
+			name,
+			requiredProviders: aggregateModelProfileRequiredProviders(definition.required_providers, { modelMapping }),
+			modelMapping,
+			source: "user",
+		});
+	}
+	return profiles;
+}
+
+export function resolveProfileBindings(definition: ModelProfileDefinition): ResolvedProfileBinding {
+	const { default: defaultSelector, executor, architect, planner, critic } = definition.modelMapping;
+	const agentModelOverrides: ResolvedProfileBinding["agentModelOverrides"] = {};
+	if (executor !== undefined) agentModelOverrides.executor = executor;
+	if (architect !== undefined) agentModelOverrides.architect = architect;
+	if (planner !== undefined) agentModelOverrides.planner = planner;
+	if (critic !== undefined) agentModelOverrides.critic = critic;
+	return { defaultSelector, agentModelOverrides };
+}
+
+export function formatAvailableProfileNames(profiles: ReadonlyMap<string, ModelProfileDefinition>): string {
+	return [...profiles.keys()].sort((a, b) => a.localeCompare(b)).join(", ");
+}

package/src/config/model-registry.ts

@@ -43,6 +43,7 @@ import {
 	formatCanonicalVariantSelector,
 	type ModelEquivalenceConfig,
 } from "./model-equivalence";
+import { type ModelProfileDefinition, mergeModelProfiles } from "./model-profiles";
 import {
 	type ModelOverride,
 	type ModelsConfig,
@@ -511,6 +512,7 @@ interface CustomModelsResult {
 	configuredProviders?: Set<string>;
 	equivalence?: ModelEquivalenceConfig;
 	modelBindings?: NonNullable<ModelsConfig["modelBindings"]>;
+	profiles?: ModelsConfig["profiles"];
 	error?: ConfigError;
 	found: boolean;
 }
@@ -954,6 +956,7 @@ export class ModelRegistry {
 	#modelOverrides: Map<string, Map<string, ModelOverride>> = new Map();
 	#equivalenceConfig: ModelEquivalenceConfig | undefined;
 	#configuredModelBindings: NonNullable<ModelsConfig["modelBindings"]> | undefined;
+	#modelProfiles: Map<string, ModelProfileDefinition> = mergeModelProfiles();
 	#modelBindingsTargetSettings: Settings | undefined;
 	#appliedModelBindingRoles = new Set<string>();
 	#appliedAgentModelBindingOverrides = new Set<string>();
@@ -1093,6 +1096,7 @@ export class ModelRegistry {
 			configuredProviders = new Set(),
 			equivalence,
 			modelBindings,
+			profiles,
 			error: configError,
 		} = this.#loadCustomModels();
 		this.#configError = configError;
@@ -1103,6 +1107,7 @@ export class ModelRegistry {
 		this.#modelOverrides = modelOverrides;
 		this.#equivalenceConfig = equivalence;
 		this.#configuredModelBindings = modelBindings;
+		this.#modelProfiles = mergeModelProfiles(profiles);
 
 		this.#addImplicitDiscoverableProviders(configuredProviders);
 		const builtInModels = this.#applyHardcodedModelPolicies(this.#loadBuiltInModels(overrides));
@@ -1343,6 +1348,7 @@ export class ModelRegistry {
 				discoverableProviders: [],
 				configuredProviders: new Set(),
 				error,
+				profiles: undefined,
 				found: true,
 			};
 		} else if (status === "not-found") {
@@ -1353,6 +1359,7 @@ export class ModelRegistry {
 				keylessProviders: new Set(),
 				discoverableProviders: [],
 				configuredProviders: new Set(),
+				profiles: undefined,
 				found: false,
 			};
 		}
@@ -1441,10 +1448,22 @@ export class ModelRegistry {
 			configuredProviders,
 			equivalence: value.equivalence,
 			modelBindings: value.modelBindings,
+			profiles: value.profiles,
 			found: true,
 		};
 	}
 
+	getModelProfiles(): Map<string, ModelProfileDefinition> {
+		return new Map(this.#modelProfiles);
+	}
+
+	getModelProfile(name: string): ModelProfileDefinition | undefined {
+		return this.#modelProfiles.get(name);
+	}
+
+	getAvailableModelProfileNames(): string[] {
+		return [...this.#modelProfiles.keys()].sort((a, b) => a.localeCompare(b));
+	}
 	applyConfiguredModelBindings(targetSettings: Settings): void {
 		this.#modelBindingsTargetSettings = targetSettings;
 		this.#applyConfiguredModelBindingsToTarget();

package/src/config/model-resolver.ts

@@ -764,6 +764,7 @@ export async function resolveModelOverrideWithAuthFallback(
 	parentActiveModelPattern: string | undefined,
 	modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">,
 	settings?: Settings,
+	sessionId?: string,
 ): Promise<{
 	model?: Model<Api>;
 	thinkingLevel?: ThinkingLevel;
@@ -775,7 +776,7 @@ export async function resolveModelOverrideWithAuthFallback(
 		return { ...primary, authFallbackUsed: false };
 	}
 
-	const primaryKey = await modelRegistry.getApiKey(primary.model);
+	const primaryKey = await modelRegistry.getApiKey(primary.model, sessionId);
 	if (primaryKey === kNoAuth || isAuthenticated(primaryKey)) {
 		return { ...primary, authFallbackUsed: false };
 	}
@@ -787,7 +788,7 @@ export async function resolveModelOverrideWithAuthFallback(
 	if (modelsAreEqual(fallback.model, primary.model)) {
 		return { ...primary, authFallbackUsed: false };
 	}
-	const fallbackKey = await modelRegistry.getApiKey(fallback.model);
+	const fallbackKey = await modelRegistry.getApiKey(fallback.model, sessionId);
 	if (!isAuthenticated(fallbackKey)) {
 		return { ...primary, authFallbackUsed: false };
 	}

package/src/config/models-config-schema.ts

@@ -76,6 +76,39 @@ const ModelBindingsSchema = z.object({
 	modelRoles: z.record(z.string(), z.string().min(1)).optional(),
 	agentModelOverrides: z.record(z.string(), z.string().min(1)).optional(),
 });
+export const ProfileRoleSchema = z.enum(["default", "executor", "architect", "planner", "critic"]);
+
+function isValidProfileModelSelector(value: string): boolean {
+	if (value.includes(",")) return false;
+	const slashIdx = value.indexOf("/");
+	if (slashIdx <= 0 || slashIdx === value.length - 1) return false;
+	const provider = value.slice(0, slashIdx);
+	const modelId = value.slice(slashIdx + 1);
+	if (!provider || !modelId) return false;
+	const parts = modelId.split(":");
+	if (parts.length > 2) return false;
+	const [base, suffix] = parts;
+	if (!base) return false;
+	return suffix === undefined || ["minimal", "low", "medium", "high", "xhigh"].includes(suffix);
+}
+
+export const ProfileModelSelectorSchema = z
+	.string()
+	.min(1)
+	.refine(value => isValidProfileModelSelector(value), {
+		message: "Expected provider/modelId with optional :effort suffix",
+	});
+
+export const ProfileModelMappingSchema = z.partialRecord(ProfileRoleSchema, ProfileModelSelectorSchema);
+
+export const ProfileDefinitionSchema = z
+	.object({
+		required_providers: z.array(z.string().min(1)).min(1),
+		model_mapping: ProfileModelMappingSchema,
+	})
+	.strict();
+
+export const ProfilesSchema = z.record(z.string().min(1), ProfileDefinitionSchema);
 
 const ModelDefinitionSchema = z
 	.object({
@@ -205,7 +238,10 @@ export const ModelsConfigSchema = z
 		providers: z.record(z.string(), ProviderConfigSchema).optional(),
 		modelBindings: ModelBindingsSchema.optional(),
 		equivalence: EquivalenceConfigSchema.optional(),
+		profiles: ProfilesSchema.optional(),
 	})
 	.strict();
 
 export type ModelsConfig = z.infer<typeof ModelsConfigSchema>;
+export type ModelProfileConfig = z.infer<typeof ProfileDefinitionSchema>;
+export type ModelProfilesConfig = z.infer<typeof ProfilesSchema>;

package/src/config/settings-schema.ts

@@ -74,6 +74,7 @@ export type StatusLineSegmentId =
 	| "git"
 	| "pr"
 	| "subagents"
+	| "jobs"
 	| "token_in"
 	| "token_out"
 	| "token_total"
@@ -313,6 +314,16 @@ export const SETTINGS_SCHEMA = {
 	disabledExtensions: { type: "array", default: DEFAULT_DISABLED_EXTENSIONS },
 
 	modelRoles: { type: "record", default: EMPTY_STRING_RECORD },
+	"modelProfile.default": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "model",
+			label: "Default Model Profile",
+			description: "Model profile applied automatically at startup",
+			options: "runtime",
+		},
+	},
 
 	modelTags: { type: "record", default: EMPTY_MODEL_TAGS_RECORD },
 
@@ -2352,11 +2363,12 @@ export const SETTINGS_SCHEMA = {
 
 	"task.maxConcurrency": {
 		type: "number",
-		default: 32,
+		default: 8,
 		ui: {
 			tab: "tasks",
 			label: "Max Concurrent Tasks",
-			description: "Concurrent limit for subagents",
+			description:
+				"Safer concurrent limit for subagents; higher fan-out still requires an explicit plan above 4 tasks.",
 			options: [
 				{ value: "0", label: "Unlimited" },
 				{ value: "1", label: "1 task" },
@@ -2408,7 +2420,8 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "tasks",
 			label: "Fork Context Max Tokens",
-			description: "Approximate token cap for fork-context seeds. 0 uses 25% of the target model context window.",
+			description:
+				"Approximate token cap for explicit full fork-context seeds. 0 uses 15% of the target model context window, with a 15k fallback when the window is unknown.",
 		},
 	},
 

package/src/dap/client.ts

@@ -1,4 +1,5 @@
 import { logger, ptree } from "@gajae-code/utils";
+import { formatCrashDiagnosticNotice, writeCrashReport } from "../debug/crash-diagnostics";
 import { NON_INTERACTIVE_ENV } from "../exec/non-interactive-env";
 import { ToolAbortError } from "../tools/tool-errors";
 import type {
@@ -532,15 +533,28 @@ export class DapClient {
 		}
 	}
 
-	#handleProcessExit(): void {
+	async #handleProcessExit(): Promise<void> {
 		if (this.#disposed) return;
 		this.#disposed = true;
 		const stderr = this.proc.peekStderr().trim();
 		const exitCode = this.proc.exitCode;
+		const crashNotice = formatCrashDiagnosticNotice(
+			await writeCrashReport(
+				{
+					kind: "dap",
+					command: [this.adapter.resolvedCommand, ...this.adapter.args],
+					exitCode,
+					stderr,
+					protocol: this.adapter.connectMode ?? "stdio",
+				},
+				{ cwd: this.cwd },
+			),
+		);
+		const diagnosticSuffix = crashNotice ? `\n${crashNotice}` : "";
 		const error = new Error(
 			stderr
-				? `DAP adapter exited (code ${exitCode}): ${stderr}`
-				: `DAP adapter exited unexpectedly (code ${exitCode})`,
+				? `DAP adapter exited (code ${exitCode}): ${stderr}${diagnosticSuffix}`
+				: `DAP adapter exited unexpectedly (code ${exitCode})${diagnosticSuffix}`,
 		);
 		this.#rejectPendingRequests(error);
 	}