@duckmind/dm-darwin-arm64 0.13.2 → 0.13.5

package/extensions/dm-subagents/skills.ts

@@ -6,7 +6,6 @@ import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { loadSkills, type Skill } from "@mariozechner/pi-coding-agent";
 
 export type SkillSource =
 	| "project"
@@ -86,6 +85,7 @@ function getPackageSkillPaths(packageRoot: string): string[] {
 			.filter((s: unknown) => typeof s === "string")
 			.map((s: string) => path.resolve(packageRoot, s));
 	} catch {
+		// Package scanning is opportunistic; ignore malformed/missing package metadata.
 		return [];
 	}
 }
@@ -98,6 +98,7 @@ function getGlobalNpmRoot(): string | null {
 		cachedGlobalNpmRoot = execSync("npm root -g", { encoding: "utf-8", timeout: 5000 }).trim();
 		return cachedGlobalNpmRoot;
 	} catch {
+		// Global npm root is optional in constrained environments.
 		cachedGlobalNpmRoot = ""; // Empty string means "tried but failed"
 		return null;
 	}
@@ -123,6 +124,7 @@ function collectPackageSkillPaths(cwd: string): string[] {
 		try {
 			entries = fs.readdirSync(dir, { withFileTypes: true });
 		} catch {
+			// Ignore unreadable package roots and continue scanning other roots.
 			continue;
 		}
 
@@ -136,6 +138,7 @@ function collectPackageSkillPaths(cwd: string): string[] {
 				try {
 					scopeEntries = fs.readdirSync(scopeDir, { withFileTypes: true });
 				} catch {
+					// Ignore unreadable scoped package directories and continue.
 					continue;
 				}
 				for (const scopeEntry of scopeEntries) {
@@ -178,7 +181,9 @@ function collectSettingsSkillPaths(cwd: string): string[] {
 				}
 				results.push(resolved);
 			}
-		} catch {}
+		} catch {
+			// Settings-provided skills are optional; ignore malformed or missing settings files.
+		}
 	}
 
 	return results;
@@ -196,21 +201,22 @@ function buildSkillPaths(cwd: string): string[] {
 	return [...new Set([...defaultSkillPaths, ...packagePaths, ...settingsPaths])];
 }
 
-function inferSkillSource(sourceInfo: { source: string; scope: string }, filePath: string, cwd: string): SkillSource {
-	const { scope, source } = sourceInfo;
-
-	if (scope === "project" && source === "local") return "project";
-	if (scope === "user" && source === "local") return "user";
+function inferSkillSource(filePath: string, cwd: string): SkillSource {
+	const projectConfigRoot = path.resolve(cwd, CONFIG_DIR);
+	const projectSkillsRoot = path.resolve(cwd, CONFIG_DIR, "skills");
+	const projectPackagesRoot = path.resolve(cwd, CONFIG_DIR, "npm", "node_modules");
+	const projectAgentsRoot = path.resolve(cwd, ".agents");
+	const userSkillsRoot = path.resolve(AGENT_DIR, "skills");
+	const userPackagesRoot = path.resolve(AGENT_DIR, "npm", "node_modules");
+	const userAgentsRoot = path.resolve(os.homedir(), ".agents");
 
-	// Fallback: infer from file path when sourceInfo isn't specific enough
-	// (e.g. scope === "temporary" for skills loaded via explicit skillPaths)
-	const projectRoot = path.resolve(cwd, CONFIG_DIR);
-	const altProjectRoot = path.resolve(cwd, ".agents");
-	const isProjectScoped = isWithinPath(filePath, projectRoot) || isWithinPath(filePath, altProjectRoot);
-	if (isProjectScoped) return "project";
+	if (isWithinPath(filePath, projectPackagesRoot)) return "project-package";
+	if (isWithinPath(filePath, projectSkillsRoot) || isWithinPath(filePath, projectAgentsRoot)) return "project";
+	if (isWithinPath(filePath, projectConfigRoot)) return "project-settings";
 
-	const isUserScoped = isWithinPath(filePath, AGENT_DIR) || isWithinPath(filePath, path.join(os.homedir(), ".agents"));
-	if (isUserScoped) return "user";
+	if (isWithinPath(filePath, userPackagesRoot)) return "user-package";
+	if (isWithinPath(filePath, userSkillsRoot) || isWithinPath(filePath, userAgentsRoot)) return "user";
+	if (isWithinPath(filePath, AGENT_DIR)) return "user-settings";
 
 	const globalRoot = getGlobalNpmRoot();
 	if (globalRoot && isWithinPath(filePath, globalRoot)) return "user-package";
@@ -227,6 +233,99 @@ function chooseHigherPrioritySkill(existing: CachedSkillEntry | undefined, candi
 	return candidate.order < existing.order ? candidate : existing;
 }
 
+function maybeReadSkillDescription(filePath: string): string | undefined {
+	try {
+		const content = fs.readFileSync(filePath, "utf-8");
+		const normalized = content.replace(/\r\n/g, "\n");
+		if (!normalized.startsWith("---")) return undefined;
+
+		const endIndex = normalized.indexOf("\n---", 3);
+		if (endIndex === -1) return undefined;
+
+		const frontmatter = normalized.slice(3, endIndex).trim();
+		const match = frontmatter.match(/^description:\s*(.+)$/m);
+		if (!match) return undefined;
+		return match[1]?.trim().replace(/^['\"]|['\"]$/g, "");
+	} catch {
+		// Description parsing is best-effort metadata extraction.
+		return undefined;
+	}
+}
+
+function collectFilesystemSkills(cwd: string, skillPaths: string[]): CachedSkillEntry[] {
+	const entries: CachedSkillEntry[] = [];
+	const seen = new Set<string>();
+	let order = 0;
+
+	const pushEntry = (name: string, filePath: string) => {
+		const resolvedFile = path.resolve(filePath);
+		if (seen.has(resolvedFile)) return;
+		if (!fs.existsSync(resolvedFile)) return;
+		seen.add(resolvedFile);
+		entries.push({
+			name,
+			filePath: resolvedFile,
+			source: inferSkillSource(resolvedFile, cwd),
+			description: maybeReadSkillDescription(resolvedFile),
+			order: order++,
+		});
+	};
+
+	for (const skillPath of skillPaths) {
+		if (!fs.existsSync(skillPath)) continue;
+
+		let stat: fs.Stats;
+		try {
+			stat = fs.statSync(skillPath);
+		} catch {
+			// Ignore paths that disappear or become unreadable during discovery.
+			continue;
+		}
+
+		if (stat.isFile()) {
+			const fileName = path.basename(skillPath);
+			if (!fileName.toLowerCase().endsWith(".md")) continue;
+			const skillName = fileName.toLowerCase() === "skill.md"
+				? path.basename(path.dirname(skillPath))
+				: path.basename(fileName, path.extname(fileName));
+			pushEntry(skillName, skillPath);
+			continue;
+		}
+
+		if (!stat.isDirectory()) continue;
+
+		const rootSkillFile = path.join(skillPath, "SKILL.md");
+		if (fs.existsSync(rootSkillFile)) {
+			pushEntry(path.basename(skillPath), rootSkillFile);
+		}
+
+		let childEntries: fs.Dirent[];
+		try {
+			childEntries = fs.readdirSync(skillPath, { withFileTypes: true });
+		} catch {
+			// Ignore unreadable skill directories and continue scanning.
+			continue;
+		}
+
+		for (const child of childEntries) {
+			if (child.name.startsWith(".")) continue;
+			const childPath = path.join(skillPath, child.name);
+			if (child.isDirectory() || child.isSymbolicLink()) {
+				const nestedSkillPath = path.join(childPath, "SKILL.md");
+				if (fs.existsSync(nestedSkillPath)) {
+					pushEntry(child.name, nestedSkillPath);
+				}
+				continue;
+			}
+			if (child.isFile() && child.name.toLowerCase().endsWith(".md")) {
+				pushEntry(path.basename(child.name, path.extname(child.name)), childPath);
+			}
+		}
+	}
+
+	return entries;
+}
+
 function getCachedSkills(cwd: string): CachedSkillEntry[] {
 	const now = Date.now();
 	if (loadSkillsCache && loadSkillsCache.cwd === cwd && now - loadSkillsCache.timestamp < LOAD_SKILLS_CACHE_TTL_MS) {
@@ -234,18 +333,10 @@ function getCachedSkills(cwd: string): CachedSkillEntry[] {
 	}
 
 	const skillPaths = buildSkillPaths(cwd);
-	const loaded = loadSkills({ cwd, skillPaths, includeDefaults: false });
+	const loaded = collectFilesystemSkills(cwd, skillPaths);
 	const dedupedByName = new Map<string, CachedSkillEntry>();
 
-	for (let i = 0; i < loaded.skills.length; i++) {
-		const skill = loaded.skills[i] as Skill;
-		const entry: CachedSkillEntry = {
-			name: skill.name,
-			filePath: skill.filePath,
-			source: inferSkillSource(skill.sourceInfo, skill.filePath, cwd),
-			description: skill.description,
-			order: i,
-		};
+	for (const entry of loaded) {
 		const current = dedupedByName.get(entry.name);
 		dedupedByName.set(entry.name, chooseHigherPrioritySkill(current, entry));
 	}
@@ -294,6 +385,7 @@ export function readSkill(
 
 		return skill;
 	} catch {
+		// Treat unreadable skill files as unresolved so callers can surface as missing.
 		return undefined;
 	}
 }

package/extensions/dm-subagents/subagent-executor.ts

@@ -22,7 +22,7 @@ import {
 import { discoverAvailableSkills, normalizeSkillInput } from "./skills.ts";
 import { executeAsyncChain, executeAsyncSingle, isAsyncAvailable } from "./async-execution.ts";
 import { createForkContextResolver } from "./fork-context.ts";
-import { applyIntercomBridgeToAgent, resolveIntercomBridge } from "./intercom-bridge.ts";
+import { applyIntercomBridgeToAgent, resolveIntercomBridge, resolveIntercomSessionTarget } from "./intercom-bridge.ts";
 import { finalizeSingleOutput, injectSingleOutputInstruction, resolveSingleOutputPath } from "./single-output.ts";
 import { getSingleResultOutput, mapConcurrent } from "./utils.ts";
 import {
@@ -1117,11 +1117,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 		const parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
 		deps.state.currentSessionId = parentSessionFile ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 		const discoveredAgents = deps.discoverAgents(ctx.cwd, scope).agents;
-		let sessionName = deps.pi.getSessionName()?.trim();
-		if (!sessionName) {
-			sessionName = `session-${ctx.sessionManager.getSessionId().slice(0, 8)}`;
-			deps.pi.setSessionName(sessionName);
-		}
+		const sessionName = resolveIntercomSessionTarget(deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
 		const intercomBridge = resolveIntercomBridge({
 			config: deps.config.intercomBridge,
 			context: normalizedParams.context,

package/extensions/dm-subagents/subagent-runner.ts

@@ -53,6 +53,7 @@ interface SubagentRunConfig {
 	asyncDir: string;
 	sessionId?: string | null;
 	piPackageRoot?: string;
+	piArgv1?: string;
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
 }
@@ -156,12 +157,16 @@ function runPiStreaming(
 	outputFile: string,
 	env?: Record<string, string | undefined>,
 	piPackageRoot?: string,
+	piArgv1?: string,
 	maxSubagentDepth?: number,
 ): Promise<{ stdout: string; stderr: string; exitCode: number | null }> {
 	return new Promise((resolve) => {
 		const outputStream = fs.createWriteStream(outputFile, { flags: "w" });
 		const spawnEnv = { ...process.env, ...(env ?? {}), ...getSubagentDepthEnv(maxSubagentDepth) };
-		const spawnSpec = getPiSpawnCommand(args, piPackageRoot ? { piPackageRoot } : undefined);
+		const spawnSpec = getPiSpawnCommand(args, {
+			...(piPackageRoot ? { piPackageRoot } : {}),
+			...(piArgv1 ? { argv1: piArgv1 } : {}),
+		});
 		const child = spawn(spawnSpec.command, spawnSpec.args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: spawnEnv });
 		let stdout = "";
 		let stderr = "";
@@ -349,6 +354,7 @@ interface SingleStepContext {
 	flatStepCount: number;
 	outputFile: string;
 	piPackageRoot?: string;
+	piArgv1?: string;
 }
 
 /** Run a single pi agent step, returning output and metadata */
@@ -410,7 +416,7 @@ async function runSingleStep(
 			promptFileStem: step.agent,
 		});
 		const outputFile = index === 0 ? ctx.outputFile : `${ctx.outputFile}.attempt-${index + 1}`;
-		const run = await runPiStreaming(args, step.cwd ?? ctx.cwd, outputFile, env, ctx.piPackageRoot, step.maxSubagentDepth);
+		const run = await runPiStreaming(args, step.cwd ?? ctx.cwd, outputFile, env, ctx.piPackageRoot, ctx.piArgv1, step.maxSubagentDepth);
 		cleanupTempDir(tempDir);
 
 		const parsed = parseRunOutput(run.stdout);
@@ -768,6 +774,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 							flatIndex: fi, flatStepCount: flatSteps.length,
 							outputFile: path.join(asyncDir, `output-${fi}.log`),
 							piPackageRoot: config.piPackageRoot,
+							piArgv1: config.piArgv1,
 						});
 						if (task.sessionFile) {
 							latestSessionFile = task.sessionFile;
@@ -888,6 +895,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				flatIndex, flatStepCount: flatSteps.length,
 				outputFile: path.join(asyncDir, `output-${flatIndex}.log`),
 				piPackageRoot: config.piPackageRoot,
+				piArgv1: config.piArgv1,
 			});
 			if (seqStep.sessionFile) {
 				latestSessionFile = seqStep.sessionFile;

package/extensions/dm-subagents/worktree.ts

@@ -106,9 +106,11 @@ function resolveRepoState(cwd: string): RepoState {
 	}
 
 	const toplevel = runGitChecked(cwd, ["rev-parse", "--show-toplevel"]).trim();
-	const realCwd = fs.realpathSync(cwd);
-	const realToplevel = fs.realpathSync(toplevel);
-	const cwdRelative = path.relative(realToplevel, realCwd);
+	const rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim();
+	const normalizedPrefix = rawPrefix
+		? path.normalize(rawPrefix.replace(/[\\/]+$/, ""))
+		: "";
+	const cwdRelative = normalizedPrefix === "." ? "" : normalizedPrefix;
 
 	const status = runGitChecked(toplevel, ["status", "--porcelain"]);
 	if (status.trim().length > 0) {
@@ -124,6 +126,7 @@ function normalizeComparableCwd(cwd: string): string {
 	try {
 		return fs.realpathSync(resolved);
 	} catch {
+		// Use the unresolved absolute path when realpath resolution is unavailable.
 		return resolved;
 	}
 }
@@ -169,6 +172,7 @@ function linkNodeModulesIfPresent(toplevel: string, worktreePath: string): boole
 		fs.symlinkSync(nodeModulesPath, nodeModulesLinkPath);
 		return true;
 	} catch {
+		// Symlink creation is optional (e.g., unsupported filesystems on CI runners).
 		return false;
 	}
 }
@@ -344,8 +348,12 @@ function createSingleWorktree(
 			syntheticPaths,
 		};
 	} catch (error) {
-		try { runGitChecked(toplevel, ["worktree", "remove", "--force", worktreePath]); } catch {}
-		try { runGitChecked(toplevel, ["branch", "-D", branch]); } catch {}
+		try { runGitChecked(toplevel, ["worktree", "remove", "--force", worktreePath]); } catch {
+			// Best-effort rollback; preserve the original setup failure.
+		}
+		try { runGitChecked(toplevel, ["branch", "-D", branch]); } catch {
+			// Best-effort rollback; preserve the original setup failure.
+		}
 		throw error;
 	}
 }
@@ -453,12 +461,18 @@ function captureWorktreeDiff(
 function writeEmptyPatch(patchPath: string): void {
 	try {
 		fs.writeFileSync(patchPath, "", "utf-8");
-	} catch {}
+	} catch {
+		// Diff artifact writing is best-effort in error paths.
+	}
 }
 
 function cleanupSingleWorktree(repoCwd: string, worktree: WorktreeInfo): void {
-	try { runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]); } catch {}
-	try { runGitChecked(repoCwd, ["branch", "-D", worktree.branch]); } catch {}
+	try { runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]); } catch {
+		// Cleanup is best-effort to avoid masking caller errors.
+	}
+	try { runGitChecked(repoCwd, ["branch", "-D", worktree.branch]); } catch {
+		// Cleanup is best-effort to avoid masking caller errors.
+	}
 }
 
 function hasWorktreeChanges(diff: WorktreeDiff): boolean {
@@ -502,6 +516,7 @@ export function diffWorktrees(setup: WorktreeSetup, agents: string[], diffsDir:
 	try {
 		fs.mkdirSync(diffsDir, { recursive: true });
 	} catch {
+		// Returning no diffs is safer than failing the whole command on artifact-dir issues.
 		return [];
 	}
 
@@ -513,6 +528,7 @@ export function diffWorktrees(setup: WorktreeSetup, agents: string[], diffsDir:
 		try {
 			diffs.push(captureWorktreeDiff(setup, worktree, agent, patchPath));
 		} catch {
+			// Preserve execution flow; failed diff capture maps to an empty per-task patch.
 			writeEmptyPatch(patchPath);
 			diffs.push(emptyDiff(index, agent, worktree.branch, patchPath));
 		}
@@ -525,7 +541,9 @@ export function cleanupWorktrees(setup: WorktreeSetup): void {
 	for (let index = setup.worktrees.length - 1; index >= 0; index--) {
 		cleanupSingleWorktree(setup.cwd, setup.worktrees[index]!);
 	}
-	try { runGitChecked(setup.cwd, ["worktree", "prune"]); } catch {}
+	try { runGitChecked(setup.cwd, ["worktree", "prune"]); } catch {
+		// Pruning is best-effort cleanup.
+	}
 }
 
 export function formatWorktreeDiffSummary(diffs: WorktreeDiff[]): string {

package/extensions/dm-thinking-timer/README.md

@@ -4,4 +4,4 @@ Bundled DM extension that shows a live timer next to collapsed Thinking blocks.
 
 ## Bundled with dm
 
-No separate install step is required. Install `dm`, restart the TUI or run `/reload`, and the timer patch is available.
+No separate install step is required. Install `dm` and restart the TUI if the timer patch is not already active.

package/extensions/dm-ultrathink/src/naming.ts

@@ -45,6 +45,55 @@ type NamingTestOverrides = {
   generateMergeCommitMessage?: (args: GenerateMergeCommitMessageArgs) => Promise<GeneratedCommitMessage>;
 };
 
+type NamingModelChoice = {
+  label: string;
+  config: NamingModelConfig;
+};
+
+type DuckMindPresetAlias = "free" | "auto" | "lite" | "smart" | "deep";
+
+type DuckMindPreset = {
+  alias: DuckMindPresetAlias;
+  envKey: string;
+  fallbackModelId: string;
+  displayName: string;
+};
+
+const DUCKMIND_PROVIDER = "duckmind";
+const OPENROUTER_PROVIDER = "openrouter";
+const DUCKMIND_PRESETS: readonly DuckMindPreset[] = [
+  {
+    alias: "free",
+    envKey: "DM_FREE_MODEL",
+    fallbackModelId: "google/gemini-3.1-flash-lite-preview",
+    displayName: "DuckMind Free",
+  },
+  {
+    alias: "auto",
+    envKey: "DM_AUTO_MODEL",
+    fallbackModelId: "auto",
+    displayName: "DuckMind Auto",
+  },
+  {
+    alias: "lite",
+    envKey: "DM_LITE_MODEL",
+    fallbackModelId: "google/gemini-2.5-flash",
+    displayName: "DuckMind Lite",
+  },
+  {
+    alias: "smart",
+    envKey: "DM_SMART_MODEL",
+    fallbackModelId: "anthropic/claude-sonnet-4.5",
+    displayName: "DuckMind Smart",
+  },
+  {
+    alias: "deep",
+    envKey: "DM_DEEP_MODEL",
+    fallbackModelId: "openai/o3",
+    displayName: "DuckMind Deep",
+  },
+];
+
 let testOverrides: NamingTestOverrides | undefined;
 
 export function setNamingTestOverrides(overrides?: NamingTestOverrides): void {
@@ -102,8 +151,90 @@ function normalizeCommitMessage(message: GeneratedCommitMessage): GeneratedCommi
   return { subject, body };
 }
 
+function resolveDuckMindPresetModelId(envKey: string, fallbackModelId: string): string {
+  const override = process.env[envKey]?.trim();
+  return override ? override : fallbackModelId;
+}
+
+function pickOpenRouterModel(
+  models: Model<any>[],
+  actualModelId: string,
+  fallbackModelId: string,
+  displayName: string,
+): Model<any> | undefined {
+  if (models.length === 0) return undefined;
+
+  const exact = models.find((model) => model.id.toLowerCase() === actualModelId.toLowerCase());
+  if (exact) {
+    return exact;
+  }
+
+  const fallback =
+    models.find((model) => model.id.toLowerCase() === fallbackModelId.toLowerCase()) ?? models[0];
+  return {
+    ...fallback,
+    id: actualModelId,
+    name: displayName,
+  };
+}
+
+function buildDefaultNamingChoice(model: Model<any>): NamingModelChoice {
+  return {
+    label: `${model.provider}/${model.id}`,
+    config: {
+      provider: model.provider,
+      modelId: model.id,
+    },
+  };
+}
+
+function buildDuckMindNamingChoices(availableModels: Model<any>[]): NamingModelChoice[] {
+  const openrouterModels = availableModels.filter((model) => model.provider === OPENROUTER_PROVIDER);
+  return DUCKMIND_PRESETS.flatMap((preset) => {
+    const actualModelId = resolveDuckMindPresetModelId(preset.envKey, preset.fallbackModelId);
+    const model = pickOpenRouterModel(openrouterModels, actualModelId, preset.fallbackModelId, preset.displayName);
+    if (!model) {
+      return [];
+    }
+    return [
+      {
+        label: `${DUCKMIND_PROVIDER}/${preset.alias}`,
+        config: {
+          provider: DUCKMIND_PROVIDER,
+          modelId: preset.alias,
+        },
+      },
+    ];
+  });
+}
+
+function resolveDuckMindAliasModel(availableModels: Model<any>[], config: NamingModelConfig): Model<any> | undefined {
+  const normalizedProvider = config.provider.trim().toLowerCase();
+  const normalizedModelId = config.modelId.trim().toLowerCase();
+  if (normalizedProvider !== DUCKMIND_PROVIDER && normalizedProvider !== OPENROUTER_PROVIDER) {
+    return undefined;
+  }
+
+  const preset = DUCKMIND_PRESETS.find(
+    (entry) => normalizedModelId === entry.alias || normalizedModelId === `@preset/${entry.alias}`,
+  );
+  if (!preset) {
+    return undefined;
+  }
+
+  const actualModelId = resolveDuckMindPresetModelId(preset.envKey, preset.fallbackModelId);
+  return pickOpenRouterModel(
+    availableModels.filter((model) => model.provider === OPENROUTER_PROVIDER),
+    actualModelId,
+    preset.fallbackModelId,
+    preset.displayName,
+  );
+}
+
 async function resolveNamingModel(ctx: ExtensionContext, config: NamingModelConfig): Promise<{ model: Model<any>; apiKey: string }> {
-  const model = ctx.modelRegistry.find(config.provider, config.modelId);
+  const model =
+    resolveDuckMindAliasModel(ctx.modelRegistry.getAvailable(), config) ??
+    ctx.modelRegistry.find(config.provider, config.modelId);
   if (!model) {
     throw new Error(`Ultrathink naming model ${config.provider}/${config.modelId} is not available in DM.`);
   }
@@ -149,14 +280,19 @@ function formatModelOption(model: Model<any>): string {
   return `${model.provider}/${model.id}`;
 }
 
-function parseModelOption(value: string): NamingModelConfig {
-  const slash = value.indexOf("/");
-  if (slash <= 0 || slash === value.length - 1) {
-    throw new Error(`Invalid model option: ${value}`);
+function resolveNamingChoice(selection: string, choices: NamingModelChoice[]): NamingModelConfig {
+  const choice = choices.find((entry) => entry.label === selection);
+  if (choice) {
+    return choice.config;
+  }
+
+  const slash = selection.indexOf("/");
+  if (slash <= 0 || slash === selection.length - 1) {
+    throw new Error(`Invalid model option: ${selection}`);
   }
   return {
-    provider: value.slice(0, slash),
-    modelId: value.slice(slash + 1),
+    provider: selection.slice(0, slash),
+    modelId: selection.slice(slash + 1),
   };
 }
 
@@ -181,20 +317,25 @@ export async function ensureNamingModel(
     .filter((model) => model.input.includes("text"))
     .sort((a, b) => formatModelOption(a).localeCompare(formatModelOption(b)));
 
-  if (availableModels.length === 0) {
+  const choices =
+    ctx.model?.provider === OPENROUTER_PROVIDER || ctx.model?.provider === DUCKMIND_PROVIDER
+      ? buildDuckMindNamingChoices(availableModels)
+      : availableModels.map(buildDefaultNamingChoice);
+
+  if (choices.length === 0) {
     throw new Error("Ultrathink could not find any available DM models to use for branch and commit naming.");
   }
 
   const selection = await ctx.ui.select(
     "Choose the small model Ultrathink should use for branch names and commit descriptions",
-    availableModels.map(formatModelOption),
+    choices.map((choice) => choice.label),
   );
 
   if (!selection) {
     return null;
   }
 
-  const namingModel = parseModelOption(selection);
+  const namingModel = resolveNamingChoice(selection, choices);
   await saveUltrathinkNamingConfig(namingModel);
   return namingModel;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckmind/dm-darwin-arm64",
-  "version": "0.13.2",
+  "version": "0.13.5",
   "description": "DuckMind (dm) binary payload for darwin arm64",
   "license": "MIT",
   "os": [