@gajae-code/coding-agent 0.3.1 → 0.4.0

package/src/commands/harness.ts

@@ -9,20 +9,28 @@
  * until the RuntimeOwner (M3+) lands.
  */
 import { execFileSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { resolveGjcTmuxCommand, sanitizeTmuxToken } from "../gjc-runtime/tmux-common";
 import { classifyRecovery } from "../harness-control-plane/classifier";
 import { callEndpoint, EndpointUnreachableError } from "../harness-control-plane/control-endpoint";
-import { RuntimeOwner, resolveOwner } from "../harness-control-plane/owner";
+import { type ResolvedOwner, RuntimeOwner, resolveOwner } from "../harness-control-plane/owner";
+import { preserveDirtyWorktree } from "../harness-control-plane/preserve";
+import { buildReceipt, requiresVanishBeforeAction, type VanishEvidence } from "../harness-control-plane/receipts";
 import { GajaeCodeRpc } from "../harness-control-plane/rpc-adapter";
+import { classifyLeaseStatus, readLease } from "../harness-control-plane/session-lease";
 import { buildResponse, buildStateView } from "../harness-control-plane/state-machine";
 import {
+	canonicalWorkspacePath,
 	generateSessionId,
 	readEvents,
 	readSessionState,
+	rememberHarnessSessionRoot,
 	resolveHarnessRoot,
+	resolveHarnessSessionRoot,
 	sessionPaths,
+	writeReceiptImmutable,
 	writeSessionState,
 } from "../harness-control-plane/storage";
 import {
@@ -31,6 +39,7 @@ import {
 	type GitDelta,
 	type Harness as HarnessKind,
 	type Observation,
+	type RecoveryClassification,
 	type RetryBudget,
 	SESSION_SCHEMA_VERSION,
 	type SessionHandle,
@@ -120,8 +129,12 @@ function gitOutput(workspace: string, args: string[]): string | null {
 	}
 }
 
+function resolveInputWorkspace(input: Record<string, unknown>): string {
+	return canonicalWorkspacePath(typeof input.workspace === "string" ? input.workspace : process.cwd());
+}
+
 function buildPreflight(input: Record<string, unknown>): HarnessPreflight {
-	const workspace = typeof input.workspace === "string" ? input.workspace : process.cwd();
+	const workspace = resolveInputWorkspace(input);
 	const declaredBranch = typeof input.branch === "string" && input.branch.trim() ? input.branch.trim() : null;
 	const blockers: string[] = [];
 	const gitRoot = gitOutput(workspace, ["rev-parse", "--show-toplevel"]);
@@ -198,6 +211,7 @@ async function buildObservation(
 	const observedSignals = ["SessionStart"];
 	for (const event of events.slice(-200)) {
 		pushUnique(observedSignals, (event.evidence as { signal?: unknown } | undefined)?.signal);
+		if (event.kind === "prompt_accepted") pushUnique(observedSignals, "prompt-accepted");
 	}
 	const terminalEvent = completedTerminalEvent(events);
 	const lastEventAt = events.at(-1)?.createdAt;
@@ -215,6 +229,114 @@ async function buildObservation(
 		completedTerminalEvent: terminalEvent,
 	};
 }
+interface OwnerExitEvidence {
+	reason: string;
+	leaseStatus: string;
+	pid: number | null;
+	endpointPresent: boolean;
+	heartbeatAt: string | null;
+	expiresAt: string | null;
+	lastEventKind: string | null;
+	lastEventAt: string | null;
+	lastSignal: string | null;
+	promptAcceptedSeen: boolean;
+	completedSeen: boolean;
+}
+
+async function buildOwnerExitEvidence(root: string, state: SessionState): Promise<OwnerExitEvidence> {
+	const lease = await readLease(root, state.sessionId);
+	const leaseStatus = classifyLeaseStatus(lease);
+	const events = await readEvents(root, state.sessionId, 0);
+	const lastEvent = events.at(-1) ?? null;
+	let lastSignal: string | null = null;
+	let promptAcceptedSeen = false;
+	let completedSeen = false;
+	for (const event of events) {
+		const signal = (event.evidence as { signal?: unknown } | undefined)?.signal;
+		if (typeof signal === "string") lastSignal = signal;
+		if (event.kind === "prompt_accepted" || signal === "prompt-accepted") promptAcceptedSeen = true;
+		if (event.kind === "rpc_agent_completed" || signal === "completed") completedSeen = true;
+	}
+	let reason = "owner-not-live";
+	if (!lease) {
+		reason = promptAcceptedSeen && !completedSeen ? "owner-exited-after-prompt-acceptance" : "owner-lease-missing";
+	} else if (leaseStatus === "dead") {
+		reason = promptAcceptedSeen && !completedSeen ? "owner-exited-after-prompt-acceptance" : "owner-process-dead";
+	} else if (leaseStatus === "expiredAlive") {
+		reason = "owner-lease-expired";
+	} else if (leaseStatus === "epermAlive") {
+		reason = "owner-liveness-unknown-permission-denied";
+	} else {
+		reason = "owner-endpoint-unreachable";
+	}
+	return {
+		reason,
+		leaseStatus,
+		pid: lease?.pid ?? null,
+		endpointPresent: Boolean(lease?.endpoint?.path),
+		heartbeatAt: lease?.heartbeatAt ?? null,
+		expiresAt: lease?.expiresAt ?? null,
+		lastEventKind: lastEvent?.kind ?? null,
+		lastEventAt: lastEvent?.createdAt ?? null,
+		lastSignal,
+		promptAcceptedSeen,
+		completedSeen,
+	};
+}
+
+async function writeVanishReceiptForDecision(
+	root: string,
+	state: SessionState,
+	observation: Observation,
+	classification: RecoveryClassification,
+): Promise<string | null> {
+	if (!requiresVanishBeforeAction(classification)) return null;
+	const dirty = observation.gitDelta === "dirty" || observation.gitDelta === "unknown";
+	const preservation = dirty ? preserveDirtyWorktree(observation.cwd) : null;
+	const evidence: VanishEvidence = {
+		classification,
+		gitDelta: observation.gitDelta,
+		gitStatusPorcelain: preservation
+			? `tracked:${preservation.trackedDiffSha256};untracked:${preservation.untrackedManifest.length}`
+			: observation.observedSignals.join(","),
+		untrackedManifest: preservation?.untrackedManifest ?? [],
+		preservation: preservation?.stashRef ? "stash" : "snapshot",
+		stashRef: preservation?.stashRef ?? null,
+		snapshotComplete: preservation?.snapshotComplete ?? true,
+		forbiddenActions: dirty ? ["restart-clean", "delete", "reset"] : [],
+	};
+	const receipt = buildReceipt<VanishEvidence>({
+		receiptId: `vanish-${Date.now()}-${randomBytes(4).toString("hex")}`,
+		sessionId: state.sessionId,
+		family: "vanish",
+		source: "cli-recover",
+		subject: {
+			workspace: observation.cwd,
+			branch: observation.branch,
+			head: null,
+			commit: null,
+		},
+		evidence,
+	});
+	await writeReceiptImmutable(root, state.sessionId, "vanish", receipt.receiptId, receipt);
+	return receipt.receiptId;
+}
+
+function updateStateWithRestoredOwner(state: SessionState, leasePath: string, resolved: ResolvedOwner): void {
+	state.lifecycle = "observing";
+	state.blockers = state.blockers.filter(blocker => !isOwnerLivenessBlocker(blocker));
+	state.handle.processHandle = {
+		kind: "runtime-owner",
+		ownerId: resolved.lease?.ownerId ?? null,
+		pid: resolved.lease?.pid ?? null,
+	};
+	state.handle.ownerHandle = {
+		leasePath,
+		endpoint: resolved.socketPath,
+		heartbeatAt: resolved.lease?.heartbeatAt ?? null,
+	};
+	state.updatedAt = nowIso();
+}
 
 function isOwnerLivenessBlocker(blocker: string): boolean {
 	return blocker === "detached-owner-not-live" || blocker.startsWith("owner-vanished:");
@@ -327,9 +449,14 @@ export default class Harness extends Command {
 	async run(): Promise<void> {
 		const { args, flags } = await this.parse(Harness);
 		const verb = String(args.verb);
-		const root = resolveHarnessRoot();
+		let root = resolveHarnessRoot();
 		try {
 			const input = parseInput(flags.input);
+			const sessionId = flags.session ?? (typeof input.sessionId === "string" ? input.sessionId : undefined);
+			const expectedWorkspace = typeof input.workspace === "string" ? resolveInputWorkspace(input) : undefined;
+			if (verb !== "start" && sessionId) {
+				root = await resolveHarnessSessionRoot(root, sessionId, process.env, { expectedWorkspace });
+			}
 			switch (verb) {
 				case "start":
 					return await this.#start(root, input);
@@ -468,6 +595,9 @@ export default class Harness extends Command {
 		if (process.env.GJC_HARNESS_RPC_COMMAND) {
 			envAssignments.push(`GJC_HARNESS_RPC_COMMAND=${shellQuote(process.env.GJC_HARNESS_RPC_COMMAND)}`);
 		}
+		if (process.env.GJC_HARNESS_TEST_NODE_MODULES) {
+			envAssignments.push(`GJC_HARNESS_TEST_NODE_MODULES=${shellQuote(process.env.GJC_HARNESS_TEST_NODE_MODULES)}`);
+		}
 		const ownerCommand = this.#buildOwnerCommand(sessionId).map(shellQuote).join(" ");
 		const shellCommand = `exec env ${envAssignments.join(" ")} ${ownerCommand}`;
 		const created = Bun.spawnSync([tmuxCommand, "new-session", "-d", "-s", sessionName, "-c", cwd, shellCommand], {
@@ -498,7 +628,13 @@ export default class Harness extends Command {
 		const cmd = this.#buildOwnerCommand(sessionId);
 		const child = Bun.spawn(cmd, {
 			cwd,
-			env: { ...process.env, GJC_HARNESS_STATE_ROOT: root },
+			env: {
+				...process.env,
+				GJC_HARNESS_STATE_ROOT: root,
+				...(process.env.GJC_HARNESS_TEST_NODE_MODULES
+					? { GJC_HARNESS_TEST_NODE_MODULES: process.env.GJC_HARNESS_TEST_NODE_MODULES }
+					: {}),
+			},
 			stdout: "ignore",
 			stderr: "ignore",
 			stdin: "ignore",
@@ -540,7 +676,7 @@ export default class Harness extends Command {
 			process.exitCode = 1;
 			return;
 		}
-		const workspace = typeof input.workspace === "string" ? input.workspace : process.cwd();
+		const workspace = resolveInputWorkspace(input);
 		const sessionId = typeof input.sessionId === "string" ? input.sessionId : generateSessionId();
 		const eventsPath = `${root}/sessions/${sessionId}/events.jsonl`;
 		const leasePath = `${root}/sessions/${sessionId}/lease.json`;
@@ -573,6 +709,7 @@ export default class Harness extends Command {
 			updatedAt: startedAt,
 		};
 		await writeSessionState(root, state);
+		await rememberHarnessSessionRoot(root, sessionId);
 		let ownerLive = false;
 		let ownerRuntime: OwnerSpawnResult["runtime"] = "manual";
 		let ownerFallbackReason: string | null = null;
@@ -676,6 +813,10 @@ export default class Harness extends Command {
 		state = await reconcileCompletedOwnerExited(root, state, observation, completedTerminalEvent);
 		const vanishedOwnerBlock = needsVanishedOwnerBlock(state, observation, completedTerminalEvent);
 		state = await markVanishedOwnerBlocked(root, state, observation, completedTerminalEvent);
+		const ownerExit =
+			!ownerLive && (vanishedOwnerBlock || completedTerminalEvent)
+				? await buildOwnerExitEvidence(root, state)
+				: null;
 		writeJson(
 			buildResponse(state, ownerLive, {
 				observation: { ...observation, lifecycle: state.lifecycle },
@@ -686,6 +827,7 @@ export default class Harness extends Command {
 				...(completedTerminalEvent && !ownerLive
 					? { completedOwnerExited: true, terminalResult: completedTerminalEvent }
 					: {}),
+				...(ownerExit ? { ownerExit } : {}),
 			}),
 		);
 	}
@@ -767,7 +909,9 @@ export default class Harness extends Command {
 			buildResponse(state, ownerLiveFor(state), {
 				events,
 				cursor: nextCursor,
-				note: "tail-only; live producer (owner) lands in M3/M5",
+				note: "tail-only; events are preserved after owner exit",
+				ownerLive: ownerLiveFor(state),
+				ownerExit: ownerLiveFor(state) ? null : await buildOwnerExitEvidence(root, state),
 			}),
 		);
 	}
@@ -802,21 +946,62 @@ export default class Harness extends Command {
 	async #recoverWithoutOwner(root: string, sessionId: string, input: Record<string, unknown>): Promise<void> {
 		const budget = resolveRetryBudget(input);
 		let state = await loadState(root, sessionId);
+		const beforeExit = await buildOwnerExitEvidence(root, state);
 		const { observation, completedTerminalEvent } = await buildObservation(root, state, false);
 		state = await markVanishedOwnerBlocked(root, state, observation, completedTerminalEvent);
 		const decision = classifyRecovery({
 			observation: { ...observation, lifecycle: state.lifecycle },
 			retryBudget: budget,
 		});
+		const vanishReceiptId = await writeVanishReceiptForDecision(root, state, observation, decision.classification);
+		const restoredOwner =
+			decision.ownerRequired && beforeExit.endpointPresent
+				? await this.#spawnDetachedOwner(root, sessionId, state.handle.workspace)
+				: null;
+		if (restoredOwner?.live) {
+			const resolved = await resolveOwner(root, sessionId);
+			if (resolved.live && resolved.socketPath) {
+				updateStateWithRestoredOwner(state, state.handle.ownerHandle.leasePath, resolved);
+				if (restoredOwner.tmuxSessionName)
+					state.handle.viewportHandle.tmuxSessionName = restoredOwner.tmuxSessionName;
+				await writeSessionState(root, state);
+				writeJson(
+					buildResponse(state, true, {
+						pending: false,
+						restoredOwner: true,
+						decision,
+						observation: { ...observation, lifecycle: state.lifecycle, ownerLive: true },
+						ownerExit: beforeExit,
+						ownerRuntime: restoredOwner.runtime,
+						...(restoredOwner.fallbackReason ? { ownerFallbackReason: restoredOwner.fallbackReason } : {}),
+						...(vanishReceiptId ? { vanishReceiptId } : {}),
+					}),
+				);
+				return;
+			}
+		}
+		const afterExit = await buildOwnerExitEvidence(root, state);
 		writeJson(
 			buildResponse(
 				state,
 				false,
 				{
 					pending: false,
-					reason: "owner-not-live",
+					reason: afterExit.reason,
 					decision,
 					observation: { ...observation, lifecycle: state.lifecycle },
+					ownerExit: afterExit,
+					...(restoredOwner
+						? {
+								restoreAttempt: {
+									runtime: restoredOwner.runtime,
+									live: restoredOwner.live,
+									fallbackReason: restoredOwner.fallbackReason,
+									blockerReason: restoredOwner.blockerReason,
+								},
+							}
+						: {}),
+					...(vanishReceiptId ? { vanishReceiptId } : {}),
 				},
 				false,
 			),

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)",
 		}),
@@ -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/ultragoal.ts

@@ -6,13 +6,7 @@ import {
 	writeCurrentSessionGoalModeState,
 	writePendingGoalModeRequest,
 } from "../gjc-runtime/goal-mode-request";
-import {
-	buildUltragoalHudSummary,
-	getUltragoalStatus,
-	readUltragoalLedger,
-	runNativeUltragoalCommand,
-} from "../gjc-runtime/ultragoal-runtime";
-import { syncSkillActiveState } from "../skill-state/active-state";
+import { runNativeUltragoalCommand } from "../gjc-runtime/ultragoal-runtime";
 
 export default class Ultragoal extends Command {
 	static description = "Run native GJC Ultragoal workflow commands";
@@ -25,20 +19,6 @@ export default class Ultragoal extends Command {
 		if (result.stdout) process.stdout.write(result.stdout);
 		if (result.stderr) process.stderr.write(result.stderr);
 		process.exitCode = result.status;
-		try {
-			const summary = await getUltragoalStatus(process.cwd());
-			const ledger = await readUltragoalLedger(process.cwd());
-			await syncSkillActiveState({
-				cwd: process.cwd(),
-				skill: "ultragoal",
-				active: summary.exists && summary.status !== "complete",
-				phase: summary.status,
-				hud: buildUltragoalHudSummary(summary, ledger.at(-1)),
-				source: "gjc-ultragoal",
-			});
-		} catch {
-			// HUD sync is best-effort and must not change command semantics.
-		}
 		if (result.status !== 0 || !shouldActivateGoalMode) return;
 
 		const cwd = process.cwd();

package/src/config/model-equivalence.ts

@@ -42,7 +42,7 @@ interface ResolvedCanonicalModel {
 }
 
 const TRAILING_MARKER_PATTERN =
-	/[-:](?:thinking|customtools|high|low|medium|minimal|xhigh|free|cloud|exacto|nitro|original|optimized|nvfp4|fp8|fp4|bf16|int8|int4)$/i;
+	/[-:](?:thinking|customtools|high|low|medium|minimal|xhigh|max|free|cloud|exacto|nitro|original|optimized|nvfp4|fp8|fp4|bf16|int8|int4)$/i;
 const WRAPPER_PREFIXES = ["duo-chat-"] as const;
 
 let referenceDataCache: CanonicalReferenceData | undefined;

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);
+}