@duckmind/dm-darwin-x64 0.13.2 → 0.13.6

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-x64",
-  "version": "0.13.2",
+  "version": "0.13.6",
   "description": "DuckMind (dm) binary payload for darwin x64",
   "license": "MIT",
   "os": [

package/theme/duckmind.json

@@ -1,72 +1,84 @@
 {
-  "$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "$schema": "https://duckmind.ai/theme-schema.json",
   "name": "duckmind",
   "vars": {
-    "primary": "#1e90ff",
-    "secondary": "#808080"
+    "deepBlue": "#0a0a10",
+    "primaryBg": "#0d0d14",
+    "secondaryBg": "#14141f",
+    "tertiaryBg": "#1a1a28",
+    "elevatedBg": "#202030",
+    "hoverBg": "#252535",
+    "textPrimary": "#e8e8f0",
+    "textSecondary": "#9090a8",
+    "textMuted": "#606078",
+    "textDim": "#404050",
+    "accentPrimary": "#667eea",
+    "accentSecondary": "#764ba2",
+    "success": "#4ade80",
+    "warning": "#fbbf24",
+    "error": "#f87171",
+    "info": "#60a5fa",
+    "indigo": "#818cf8",
+    "purple": "#a78bfa",
+    "cyan": "#67e8f9",
+    "pink": "#f472b6"
   },
   "colors": {
-    "accent": "#1e90ff",
-    "border": "#1e90ff",
-    "borderAccent": "#CCCCCC",
-    "borderMuted": "#808080",
-
-    "success": "#7fd88f",
-    "error": "#e06c75",
-    "warning": "#f5a742",
-
-    "muted": "#808080",
-    "dim": 240,
-
-    "text": "#eeeeee",
-    "thinkingText": "#808080",
-
-    "selectedBg": "#1a1a1a",
-    "userMessageBg": "#1a1a1a",
-    "userMessageText": "#eeeeee",
-
-    "customMessageBg": "#1a1a1a",
-    "customMessageText": "#eeeeee",
-    "customMessageLabel": "#1e90ff",
-
-    "toolPendingBg": "#1a1a1a",
-    "toolSuccessBg": "#1e2e1e",
-    "toolErrorBg": "#2e1e1e",
-    "toolTitle": "#1e90ff",
-    "toolOutput": "#eeeeee",
-
-    "mdHeading": "#56b6c2",
-    "mdLink": "#1e90ff",
-    "mdLinkUrl": "#56b6c2",
-    "mdCode": "#7fd88f",
-    "mdCodeBlock": "#eeeeee",
-    "mdCodeBlockBorder": "#808080",
-    "mdQuote": "#e5c07b",
-    "mdQuoteBorder": "#808080",
-    "mdHr": "#808080",
-    "mdListBullet": "#1e90ff",
-
-    "toolDiffAdded": "#b8db87",
-    "toolDiffRemoved": "#e26a75",
-    "toolDiffContext": "#808080",
-
-    "syntaxComment": "#808080",
-    "syntaxKeyword": "#56b6c2",
-    "syntaxFunction": "#1e90ff",
-    "syntaxVariable": "#e06c75",
-    "syntaxString": "#7fd88f",
-    "syntaxNumber": "#f5a742",
-    "syntaxType": "#e5c07b",
-    "syntaxOperator": "#56b6c2",
-    "syntaxPunctuation": "#eeeeee",
-
-    "thinkingOff": "#808080",
-    "thinkingMinimal": "#1e90ff",
-    "thinkingLow": "#56b6c2",
-    "thinkingMedium": "#56b6c2",
-    "thinkingHigh": "#e06c75",
-    "thinkingXhigh": "#ff0000",
-
-    "bashMode": "#f5a742"
+    "accent": "accentPrimary",
+    "border": "textDim",
+    "borderAccent": "accentPrimary",
+    "borderMuted": "textDim",
+    "success": "success",
+    "error": "error",
+    "warning": "warning",
+    "muted": "textMuted",
+    "dim": "textDim",
+    "text": "textPrimary",
+    "thinkingText": "textSecondary",
+    "selectedBg": "elevatedBg",
+    "userMessageBg": "secondaryBg",
+    "userMessageText": "textPrimary",
+    "customMessageBg": "tertiaryBg",
+    "customMessageText": "textPrimary",
+    "customMessageLabel": "accentPrimary",
+    "toolPendingBg": "primaryBg",
+    "toolSuccessBg": "secondaryBg",
+    "toolErrorBg": "secondaryBg",
+    "toolTitle": "accentPrimary",
+    "toolOutput": "textPrimary",
+    "mdHeading": "textPrimary",
+    "mdLink": "accentPrimary",
+    "mdLinkUrl": "textSecondary",
+    "mdCode": "cyan",
+    "mdCodeBlock": "textPrimary",
+    "mdCodeBlockBorder": "textDim",
+    "mdQuote": "textSecondary",
+    "mdQuoteBorder": "accentPrimary",
+    "mdHr": "textDim",
+    "mdListBullet": "cyan",
+    "toolDiffAdded": "success",
+    "toolDiffRemoved": "error",
+    "toolDiffContext": "textSecondary",
+    "syntaxComment": "textDim",
+    "syntaxKeyword": "indigo",
+    "syntaxFunction": "accentSecondary",
+    "syntaxVariable": "info",
+    "syntaxString": "success",
+    "syntaxNumber": "warning",
+    "syntaxType": "purple",
+    "syntaxOperator": "textSecondary",
+    "syntaxPunctuation": "textSecondary",
+    "thinkingOff": "textDim",
+    "thinkingMinimal": "textMuted",
+    "thinkingLow": "textSecondary",
+    "thinkingMedium": "accentPrimary",
+    "thinkingHigh": "accentSecondary",
+    "thinkingXhigh": "pink",
+    "bashMode": "warning"
+  },
+  "export": {
+    "pageBg": "deepBlue",
+    "cardBg": "secondaryBg",
+    "infoBg": "tertiaryBg"
   }
 }