@gajae-code/coding-agent 0.4.2 → 0.4.3

package/dist/types/tools/browser/actions.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Structured browser action space.
+ *
+ * Adapts the SOTA computer-use / browser-use pattern: instead of authoring raw
+ * JavaScript for every interaction, the model emits a list of structured verbs
+ * (navigate / click / type / …) that reference elements by the numeric `id`
+ * returned from {@link Observation}. Each verb is compiled onto the existing
+ * in-tab `tab.*` helpers and executed through the same worker `run` path, so the
+ * worker protocol is unchanged and the raw-JS `run` escape hatch still works.
+ */
+export type BrowserActionVerb = "navigate" | "click" | "type" | "fill" | "select" | "press" | "scroll" | "back" | "wait" | "observe" | "extract" | "screenshot";
+export interface BrowserActionStep {
+    verb: BrowserActionVerb;
+    /** Element id from a prior `observe` (preferred for click/type). */
+    id?: number;
+    /** CSS / puppeteer selector when not addressing by `id`. */
+    selector?: string;
+    /** Text to type. */
+    text?: string;
+    /** Value for `fill`. */
+    value?: string;
+    /** Option value(s) for `select`. */
+    values?: string[];
+    /** URL for `navigate`. */
+    url?: string;
+    /** Key for `press` (e.g. "Enter"). */
+    key?: string;
+    /** Horizontal scroll delta. */
+    dx?: number;
+    /** Vertical scroll delta. */
+    dy?: number;
+    /** Sleep duration for `wait` when no selector is given. */
+    ms?: number;
+    /** Extract format. */
+    format?: "markdown" | "text" | "html";
+    /** Navigation wait condition for `navigate`. */
+    wait_until?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
+    /** Only return interactive/viewport elements for `observe`. */
+    viewport_only?: boolean;
+    include_all?: boolean;
+}
+/**
+ * Validate a single step's required fields. Returns an error string, or
+ * `undefined` when the step is well-formed.
+ */
+export declare function validateActionStep(step: BrowserActionStep, index: number): string | undefined;
+/** Validate the full step list. Throws on the first invalid step. */
+export declare function validateActionSteps(steps: readonly BrowserActionStep[]): void;
+/**
+ * Compile structured steps into a JS program for the in-tab `run` worker. Steps
+ * are embedded as parsed JSON (no string interpolation, so values cannot inject
+ * code) and dispatched by a fixed interpreter against the `tab` / `page` helpers.
+ */
+export declare function compileActionSteps(steps: readonly BrowserActionStep[]): string;

package/dist/types/tools/browser.d.ts

@@ -8,6 +8,7 @@ export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } fro
 export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 declare const browserSchema: z.ZodObject<{
     action: z.ZodEnum<{
+        act: "act";
         close: "close";
         open: "open";
         run: "run";
@@ -36,6 +37,45 @@ declare const browserSchema: z.ZodObject<{
         dismiss: "dismiss";
     }>>;
     code: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        verb: z.ZodEnum<{
+            back: "back";
+            click: "click";
+            extract: "extract";
+            fill: "fill";
+            navigate: "navigate";
+            observe: "observe";
+            press: "press";
+            screenshot: "screenshot";
+            scroll: "scroll";
+            select: "select";
+            type: "type";
+            wait: "wait";
+        }>;
+        id: z.ZodOptional<z.ZodNumber>;
+        selector: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodString>;
+        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        url: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        dx: z.ZodOptional<z.ZodNumber>;
+        dy: z.ZodOptional<z.ZodNumber>;
+        ms: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodEnum<{
+            html: "html";
+            markdown: "markdown";
+            text: "text";
+        }>>;
+        wait_until: z.ZodOptional<z.ZodEnum<{
+            domcontentloaded: "domcontentloaded";
+            load: "load";
+            networkidle0: "networkidle0";
+            networkidle2: "networkidle2";
+        }>>;
+        viewport_only: z.ZodOptional<z.ZodBoolean>;
+        include_all: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
     timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     all: z.ZodOptional<z.ZodBoolean>;
     kill: z.ZodOptional<z.ZodBoolean>;
@@ -73,6 +113,7 @@ export declare class BrowserTool implements AgentTool<typeof browserSchema, Brow
     readonly summary = "Control a headless browser to navigate and interact with web pages";
     readonly parameters: z.ZodObject<{
         action: z.ZodEnum<{
+            act: "act";
             close: "close";
             open: "open";
             run: "run";
@@ -101,6 +142,45 @@ export declare class BrowserTool implements AgentTool<typeof browserSchema, Brow
             dismiss: "dismiss";
         }>>;
         code: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            verb: z.ZodEnum<{
+                back: "back";
+                click: "click";
+                extract: "extract";
+                fill: "fill";
+                navigate: "navigate";
+                observe: "observe";
+                press: "press";
+                screenshot: "screenshot";
+                scroll: "scroll";
+                select: "select";
+                type: "type";
+                wait: "wait";
+            }>;
+            id: z.ZodOptional<z.ZodNumber>;
+            selector: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodString>;
+            values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            url: z.ZodOptional<z.ZodString>;
+            key: z.ZodOptional<z.ZodString>;
+            dx: z.ZodOptional<z.ZodNumber>;
+            dy: z.ZodOptional<z.ZodNumber>;
+            ms: z.ZodOptional<z.ZodNumber>;
+            format: z.ZodOptional<z.ZodEnum<{
+                html: "html";
+                markdown: "markdown";
+                text: "text";
+            }>>;
+            wait_until: z.ZodOptional<z.ZodEnum<{
+                domcontentloaded: "domcontentloaded";
+                load: "load";
+                networkidle0: "networkidle0";
+                networkidle2: "networkidle2";
+            }>>;
+            viewport_only: z.ZodOptional<z.ZodBoolean>;
+            include_all: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
         timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         all: z.ZodOptional<z.ZodBoolean>;
         kill: z.ZodOptional<z.ZodBoolean>;

package/dist/types/tools/image-gen.d.ts

@@ -72,6 +72,7 @@ interface InlineImageData {
 }
 /** Set the preferred image provider from settings */
 export declare function setPreferredImageProvider(provider: ImageProvider | "auto"): void;
+export declare function isOpenAIHostedImageModel(model: Model | undefined): model is Model;
 export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;
 export declare function getImageGenTools(modelRegistry?: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
 export declare function getImageGenToolsWithRegistry(modelRegistry: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;

package/dist/types/tools/index.d.ts

@@ -8,7 +8,7 @@ import type { HindsightSessionState } from "../hindsight/state";
 import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
 import type { PlanModeState } from "../plan-mode/state";
 import type { AgentRegistry } from "../registry/agent-registry";
-import type { ForkContextSeed, ForkContextSeedOptions } from "../session/agent-session";
+import type { ForkContextSeed, ForkContextSeedOptions, PurgeQueuedCustomMessagesResult } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { ClientBridge } from "../session/client-bridge";
 import type { CustomMessage } from "../session/messages";
@@ -117,6 +117,8 @@ export interface ToolSession {
     /** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
     getAgentId?: () => string | null;
     /** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+    /** Purge undelivered queued custom messages matching the predicate. Returns counts. */
+    purgeQueuedCustomMessages?: (predicate: (message: CustomMessage) => boolean) => PurgeQueuedCustomMessagesResult;
     getToolByName?: (name: string) => AgentTool | undefined;
     /** Agent registry for IRC routing across live sessions. */
     agentRegistry?: AgentRegistry;

package/dist/types/tools/job.d.ts

@@ -19,7 +19,7 @@ interface JobSnapshot {
     resultText?: string;
     errorText?: string;
 }
-type CancelStatus = "cancelled" | "not_found" | "already_completed";
+type CancelStatus = "cancelled" | "not_found" | "already_completed" | "already_cancelled";
 export interface JobToolDetails {
     jobs: JobSnapshot[];
     cancelled?: {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.4.2",
+	"version": "0.4.3",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -50,12 +50,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.4.2",
-		"@gajae-code/agent-core": "0.4.2",
-		"@gajae-code/ai": "0.4.2",
-		"@gajae-code/natives": "0.4.2",
-		"@gajae-code/tui": "0.4.2",
-		"@gajae-code/utils": "0.4.2",
+		"@gajae-code/stats": "0.4.3",
+		"@gajae-code/agent-core": "0.4.3",
+		"@gajae-code/ai": "0.4.3",
+		"@gajae-code/natives": "0.4.3",
+		"@gajae-code/tui": "0.4.3",
+		"@gajae-code/utils": "0.4.3",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/async/job-manager.ts

@@ -6,6 +6,7 @@ const DELIVERY_RETRY_MAX_MS = 30_000;
 const DELIVERY_RETRY_JITTER_MS = 200;
 const DEFAULT_RETENTION_MS = 5 * 60 * 1000;
 const DEFAULT_MAX_RUNNING_JOBS = 15;
+const MONITOR_TOMBSTONE_TTL_MS = 5 * 60_000;
 
 export interface AsyncJob {
 	id: string;
@@ -120,6 +121,27 @@ export interface AsyncJobDeliveryState {
 	pendingJobIds: string[];
 }
 
+export interface AsyncJobLifecycleCleanup {
+	onCancel?: (job: AsyncJob) => void;
+	onTerminal?: (job: AsyncJob) => void;
+	onEvict?: (job: AsyncJob) => void;
+	/**
+	 * Idempotent residual cleanup invoked by a post-eviction tombstone purge
+	 * (e.g. a late `job cancel` after the job left the registry). Kept distinct
+	 * from the at-most-once lifecycle phases so a tombstone purge never has to
+	 * re-invoke a phase hook. Must be safe to call repeatedly.
+	 */
+	onTombstonePurge?: (job: AsyncJob) => void;
+}
+
+export interface MonitorTombstone {
+	jobId: string;
+	ownerId?: string;
+	status: AsyncJob["status"];
+	expiresAt: number;
+	purge: () => unknown;
+}
+
 export interface AsyncJobRegisterOptions {
 	id?: string;
 	/** Registry id of the agent that owns this job; used to scope cancelAll. */
@@ -127,6 +149,7 @@ export interface AsyncJobRegisterOptions {
 	/** Structured metadata for tool-specific control surfaces. */
 	metadata?: AsyncJobMetadata;
 	onProgress?: (text: string, details?: Record<string, unknown>) => void | Promise<void>;
+	lifecycle?: AsyncJobLifecycleCleanup;
 }
 
 /**
@@ -214,6 +237,9 @@ export class AsyncJobManager {
 	readonly #evictionTimers = new Map<string, NodeJS.Timeout>();
 	readonly #outputState = new Map<string, AsyncJobOutputState>();
 	readonly #ownerCleanups = new Map<string, Set<() => void>>();
+	readonly #lifecycles = new Map<string, AsyncJobLifecycleCleanup>();
+	readonly #lifecyclePhases = new Map<string, Set<"cancel" | "terminal" | "evict">>();
+	readonly #monitorTombstones = new Map<string, MonitorTombstone>();
 	readonly #outputRetentionBytes = DEFAULT_JOB_OUTPUT_RETENTION_BYTES;
 	readonly #onJobComplete: AsyncJobManagerOptions["onJobComplete"];
 	readonly #maxRunningJobs: number;
@@ -292,6 +318,7 @@ export class AsyncJobManager {
 			);
 		}
 
+		this.#expireMonitorTombstones();
 		const id = this.#resolveJobId(options?.id);
 		this.#suppressedDeliveries.delete(id);
 		const abortController = new AbortController();
@@ -308,6 +335,7 @@ export class AsyncJobManager {
 			ownerId: options?.ownerId,
 			metadata: options?.metadata,
 		};
+		if (options?.lifecycle) this.#lifecycles.set(id, options.lifecycle);
 
 		const reportProgress = async (text: string, details?: Record<string, unknown>): Promise<void> => {
 			if (!options?.onProgress) return;
@@ -325,8 +353,10 @@ export class AsyncJobManager {
 				const result = await run({ jobId: id, signal: abortController.signal, reportProgress });
 				const outcome: SubagentRunOutcome =
 					typeof result === "string" ? { kind: "completed", text: result } : result;
+
 				if (job.status === "cancelled") {
 					job.resultText = outcome.kind === "completed" ? outcome.text : outcome.note;
+					this.#runLifecycle(id, "terminal");
 					this.#scheduleEviction(id);
 					this.#markRecordTerminal(id, "cancelled");
 					this.#drainResumeQueue();
@@ -342,20 +372,24 @@ export class AsyncJobManager {
 					this.#drainResumeQueue();
 					return;
 				}
+
 				job.status = "completed";
 				job.resultText = outcome.text;
 				this.#enqueueDelivery(id, outcome.text);
+				this.#runLifecycle(id, "terminal");
 				this.#scheduleEviction(id);
 				this.#markRecordTerminal(id, "completed");
 				this.#drainResumeQueue();
 			} catch (error) {
 				if (job.status === "cancelled") {
 					job.errorText = error instanceof Error ? error.message : String(error);
+					this.#runLifecycle(id, "terminal");
 					this.#scheduleEviction(id);
 					this.#markRecordTerminal(id, "cancelled");
 					this.#drainResumeQueue();
 					return;
 				}
+				this.#runLifecycle(id, "terminal");
 				const errorText = error instanceof Error ? error.message : String(error);
 				job.status = "failed";
 				job.errorText = errorText;
@@ -381,6 +415,7 @@ export class AsyncJobManager {
 		if (!job) return false;
 		if (filter?.ownerId && job.ownerId !== filter.ownerId) return false;
 		if (job.status === "paused") {
+			this.#runLifecycle(id, "cancel");
 			// Paused jobs have no running promise to abort; transition directly.
 			// The session file is kept, so the record stays resumable by id.
 			job.status = "cancelled";
@@ -390,12 +425,76 @@ export class AsyncJobManager {
 			return true;
 		}
 		if (job.status !== "running") return false;
+		this.#runLifecycle(id, "cancel");
 		job.status = "cancelled";
 		job.abortController.abort();
-		this.#scheduleEviction(id);
 		return true;
 	}
 
+	#runLifecycle(jobId: string, phase: "cancel" | "terminal" | "evict"): void {
+		const fired = this.#lifecyclePhases.get(jobId) ?? new Set<"cancel" | "terminal" | "evict">();
+		if (fired.has(phase)) return;
+		fired.add(phase);
+		this.#lifecyclePhases.set(jobId, fired);
+		const lifecycle = this.#lifecycles.get(jobId);
+		const job = this.#jobs.get(jobId);
+		if (!lifecycle || !job) return;
+		try {
+			if (phase === "cancel") lifecycle.onCancel?.(job);
+			else if (phase === "terminal") lifecycle.onTerminal?.(job);
+			else lifecycle.onEvict?.(job);
+		} catch (error) {
+			logger.warn("Async job lifecycle cleanup failed", {
+				jobId,
+				phase,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	#expireMonitorTombstones(): void {
+		const now = Date.now();
+		for (const [jobId, tombstone] of this.#monitorTombstones) {
+			if (tombstone.expiresAt <= now) this.#monitorTombstones.delete(jobId);
+		}
+	}
+
+	#recordMonitorTombstone(jobId: string): void {
+		const job = this.#jobs.get(jobId);
+		if (!job?.metadata?.monitor) return;
+		const lifecycle = this.#lifecycles.get(jobId);
+		this.#monitorTombstones.set(jobId, {
+			jobId,
+			ownerId: job.ownerId,
+			status: job.status,
+			expiresAt: Date.now() + MONITOR_TOMBSTONE_TTL_MS,
+			purge: () => (lifecycle?.onTombstonePurge ?? lifecycle?.onEvict)?.(job),
+		});
+	}
+
+	getMonitorTombstone(jobId: string, filter?: AsyncJobFilter): MonitorTombstone | undefined {
+		this.#expireMonitorTombstones();
+		const tombstone = this.#monitorTombstones.get(jobId);
+		if (!tombstone) return undefined;
+		if (filter?.ownerId && tombstone.ownerId !== filter.ownerId) return undefined;
+		return tombstone;
+	}
+
+	purgeMonitorTombstone(jobId: string, filter?: AsyncJobFilter): { found: boolean; status?: AsyncJob["status"] } {
+		const tombstone = this.getMonitorTombstone(jobId, filter);
+		if (!tombstone) return { found: false };
+		this.#monitorTombstones.delete(jobId);
+		try {
+			tombstone.purge();
+		} catch (error) {
+			logger.warn("Monitor tombstone purge failed", {
+				jobId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+		return { found: true, status: tombstone.status };
+	}
+
 	// ── Subagent control plane (pause / resume / steer support) ──────────
 
 	/** Register or replace the canonical record for a subagent. */
@@ -836,6 +935,7 @@ export class AsyncJobManager {
 	 */
 	cancelAll(filter?: AsyncJobFilter): void {
 		for (const job of this.getRunningJobs(filter)) {
+			this.#runLifecycle(job.id, "cancel");
 			job.status = "cancelled";
 			job.abortController.abort();
 			this.#scheduleEviction(job.id);
@@ -898,6 +998,17 @@ export class AsyncJobManager {
 		// manager. Errors in cleanup callbacks are logged but never escalated.
 		this.runOwnerCleanups();
 		this.cancelAll();
+		for (const tombstone of this.#monitorTombstones.values()) {
+			try {
+				tombstone.purge();
+			} catch (error) {
+				logger.warn("Monitor tombstone purge failed during dispose", {
+					jobId: tombstone.jobId,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		}
+		this.#monitorTombstones.clear();
 		await this.waitForAll();
 		const drained = await this.drainDeliveries({ timeoutMs: options?.timeoutMs ?? 3_000 });
 		this.#clearEvictionTimers();
@@ -945,7 +1056,11 @@ export class AsyncJobManager {
 	#scheduleEviction(jobId: string): void {
 		this.#notifyChange();
 		if (this.#retentionMs <= 0) {
+			this.#recordMonitorTombstone(jobId);
+			this.#runLifecycle(jobId, "evict");
 			this.#jobs.delete(jobId);
+			this.#lifecycles.delete(jobId);
+			this.#lifecyclePhases.delete(jobId);
 			this.#suppressedDeliveries.delete(jobId);
 			this.#watchedJobs.delete(jobId);
 			this.#outputState.delete(jobId);
@@ -957,7 +1072,11 @@ export class AsyncJobManager {
 		}
 		const timer = setTimeout(() => {
 			this.#evictionTimers.delete(jobId);
+			this.#recordMonitorTombstone(jobId);
+			this.#runLifecycle(jobId, "evict");
 			this.#jobs.delete(jobId);
+			this.#lifecycles.delete(jobId);
+			this.#lifecyclePhases.delete(jobId);
 			this.#suppressedDeliveries.delete(jobId);
 			this.#watchedJobs.delete(jobId);
 			this.#outputState.delete(jobId);

package/src/commands/ultragoal.ts

@@ -1,6 +1,7 @@
 import { Command } from "@gajae-code/utils/cli";
 import {
 	GJC_SESSION_FILE_ENV,
+	GJC_SESSION_ID_ENV,
 	isUltragoalCreateGoalsInvocation,
 	readUltragoalGjcObjective,
 	writeCurrentSessionGoalModeState,
@@ -28,6 +29,11 @@ export default class Ultragoal extends Command {
 			sessionFile: process.env[GJC_SESSION_FILE_ENV],
 			objective,
 		});
-		await writePendingGoalModeRequest({ cwd, objective, goalsPath });
+		await writePendingGoalModeRequest({
+			cwd,
+			objective,
+			goalsPath,
+			sessionId: process.env[GJC_SESSION_ID_ENV],
+		});
 	}
 }

package/src/commit/agentic/index.ts

@@ -5,7 +5,7 @@ import { applyChangelogProposals } from "../../commit/changelog";
 import { detectChangelogBoundaries } from "../../commit/changelog/detect";
 import { parseUnreleasedSection } from "../../commit/changelog/parse";
 import { formatCommitMessage } from "../../commit/message";
-import { resolvePrimaryModel, resolveSmolModel } from "../../commit/model-selection";
+import { resolvePrimaryModel, resolveSecondaryCommitModel } from "../../commit/model-selection";
 import type { CommitCommandArgs, ConventionalAnalysis } from "../../commit/types";
 import { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
@@ -47,7 +47,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	const { model: primaryModel, apiKey: primaryApiKey } = primaryModelResult;
 	process.stdout.write(`  └─ ${primaryModel.name}\n`);
 
-	const { model: agentModel, thinkingLevel: agentThinkingLevel } = await resolveSmolModel(
+	const { model: agentModel, thinkingLevel: agentThinkingLevel } = await resolveSecondaryCommitModel(
 		settings,
 		modelRegistry,
 		primaryModel,

package/src/commit/model-selection.ts

@@ -1,14 +1,7 @@
 import type { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Api, Model } from "@gajae-code/ai";
-import { MODEL_ROLE_IDS } from "../config/model-registry";
-import {
-	type ModelLookupRegistry,
-	parseModelPattern,
-	resolveModelRoleValue,
-	resolveRoleSelection,
-} from "../config/model-resolver";
+import { type ModelLookupRegistry, resolveModelRoleValue, resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
-import MODEL_PRIO from "../priority.json" with { type: "json" };
 
 export interface ResolvedCommitModel {
 	model: Model<Api>;
@@ -29,7 +22,7 @@ export async function resolvePrimaryModel(
 	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
 	const resolved = override
 		? resolveModelRoleValue(override, available, { settings, matchPreferences, modelRegistry })
-		: resolveRoleSelection(["commit", "smol", ...MODEL_ROLE_IDS], settings, available, modelRegistry);
+		: resolveRoleSelection(["default"], settings, available, modelRegistry);
 	const model = resolved?.model;
 	if (!model) {
 		throw new Error("No model available for commit generation");
@@ -41,25 +34,17 @@ export async function resolvePrimaryModel(
 	return { model, apiKey, thinkingLevel: resolved?.thinkingLevel };
 }
 
-export async function resolveSmolModel(
+export async function resolveSecondaryCommitModel(
 	settings: Settings,
 	modelRegistry: CommitModelRegistry,
 	fallbackModel: Model<Api>,
 	fallbackApiKey: string,
 ): Promise<ResolvedCommitModel> {
 	const available = modelRegistry.getAvailable();
-	const resolvedSmol = resolveRoleSelection(["smol"], settings, available, modelRegistry);
-	if (resolvedSmol?.model) {
-		const apiKey = await modelRegistry.getApiKey(resolvedSmol.model);
-		if (apiKey) return { model: resolvedSmol.model, apiKey, thinkingLevel: resolvedSmol.thinkingLevel };
-	}
-
-	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
-	for (const pattern of MODEL_PRIO.smol) {
-		const candidate = parseModelPattern(pattern, available, matchPreferences, { modelRegistry }).model;
-		if (!candidate) continue;
-		const apiKey = await modelRegistry.getApiKey(candidate);
-		if (apiKey) return { model: candidate, apiKey };
+	const resolved = resolveRoleSelection(["default"], settings, available, modelRegistry);
+	if (resolved?.model) {
+		const apiKey = await modelRegistry.getApiKey(resolved.model);
+		if (apiKey) return { model: resolved.model, apiKey, thinkingLevel: resolved.thinkingLevel };
 	}
 
 	return { model: fallbackModel, apiKey: fallbackApiKey };

package/src/commit/pipeline.ts

@@ -18,7 +18,7 @@ import {
 import { runChangelogFlow } from "./changelog";
 import { runMapReduceAnalysis, shouldUseMapReduce } from "./map-reduce";
 import { formatCommitMessage } from "./message";
-import { resolvePrimaryModel, resolveSmolModel } from "./model-selection";
+import { resolvePrimaryModel, resolveSecondaryCommitModel } from "./model-selection";
 import summaryRetryPrompt from "./prompts/summary-retry.md" with { type: "text" };
 import typesDescriptionPrompt from "./prompts/types-description.md" with { type: "text" };
 import type { CommitCommandArgs, ConventionalAnalysis } from "./types";
@@ -56,7 +56,7 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		model: smolModel,
 		apiKey: smolApiKey,
 		thinkingLevel: smolThinkingLevel,
-	} = await resolveSmolModel(settings, modelRegistry, primaryModel, primaryApiKey);
+	} = await resolveSecondaryCommitModel(settings, modelRegistry, primaryModel, primaryApiKey);
 
 	let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 	if (stagedFiles.length === 0) {