@duckmind/dm-linux-x64 0.64.2 → 0.65.2

package/README.md

@@ -3,3 +3,12 @@
 <strong>DuckMind (dm)</strong> is a <strong>minimal, fast AI coworker</strong> that runs in your terminal.
 No UI overhead. Just plan, run, and get things done.
 </p>
+
+## IDE integration
+
+Configure a trusted project's MCP client (including Cursor) to run `dm`
+with arguments `["lens-mcp", "--cwd=/absolute/path/to/project"]`.
+This exposes DM Lens code diagnostics and navigation over stdio; it does
+not replace the editor's native language server or require a model API key.
+Use an absolute path to the installed `dm` launcher when the IDE lacks your
+terminal PATH. Enable the server in the IDE before invoking its tools.

package/extensions/.dm-extensions.json

@@ -1,6 +1,6 @@
 {
   "status": "ok",
-  "prepared_at": "2026-09-04T16:25:23.069046+00:00",
+  "prepared_at": "2026-09-12T09:29:01.010336+00:00",
   "managed_entries": [
     {
       "id": "dm-context",
@@ -754,6 +754,7 @@
         "tool": "bun build --no-bundle",
         "mode": "module-preserving-transpile",
         "files": [
+          "extensions/extensions-manager.js",
           "extensions/skills-manager/components.js",
           "extensions/skills-manager/constants.js",
           "extensions/skills-manager/creation-fallback.js",
@@ -772,11 +773,11 @@
           "extensions/skills-manager/ui.js",
           "extensions/skills-manager.js"
         ],
-        "file_count": 17,
-        "before_bytes": 95706,
-        "after_bytes": 85484,
+        "file_count": 18,
+        "before_bytes": 110893,
+        "after_bytes": 99433,
         "runtime_specifier_rewrites": 0,
-        "runtime_filename_rewrites": 17,
+        "runtime_filename_rewrites": 18,
         "declaration_files_removed": 0
       }
     },
@@ -1428,8 +1429,8 @@
           "utils.js"
         ],
         "file_count": 81,
-        "before_bytes": 1438212,
-        "after_bytes": 1266049,
+        "before_bytes": 1439473,
+        "after_bytes": 1267119,
         "runtime_specifier_rewrites": 39,
         "runtime_filename_rewrites": 64,
         "declaration_files_removed": 12

package/extensions/dm-mcp-adapter/init.js

@@ -83,6 +83,13 @@ export function recordFailure(state, serverName, message) {
   notifyToolMetadataUpdated(state, serverName, "failure-backoff-started");
   publishMcpStatusSnapshot(state);
 }
+export function formatMcpConnectionFailure(message) {
+  const sanitized = sanitizeTerminalText(message);
+  if (/endpoint returned .*\(401\).*authentication may be required/i.test(sanitized)) {
+    return "Authentication may be required (HTTP 401). Check the server credentials or OAuth sign-in, then reconnect.";
+  }
+  return sanitized;
+}
 export function isTuiMode(ctx) {
   return ctx.hasUI && ctx.mode === "tui";
 }
@@ -311,8 +318,13 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
     if (error || !connection) {
       if (initialSignal?.aborted)
         continue;
-      if (error)
-        recordFailure(state, name, error);
+      const displayError = formatMcpConnectionFailure(error ?? "Unknown connection failure");
+      if (error) {
+        recordFailure(state, name, displayError);
+        if (displayError !== sanitizeTerminalText(error)) {
+          logger.debug("MCP: startup connection probe diagnostic", { server: name, diagnostic: sanitizeTerminalText(error) });
+        }
+      }
       if (transient) {
         const notice = `MCP: ${name} temporarily unavailable (HTTP 503); retry later`;
         logger.debug(`MCP: startup connect hit transient upstream outage for ${name}; will retry`);
@@ -322,11 +334,11 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
           console.error(notice);
         continue;
       }
-      const displayError = sanitizeTerminalText(error ?? "Unknown connection failure");
       if (ui) {
         ui.notify(`MCP: Failed to connect to ${name}: ${displayError}`, "error");
+      } else {
+        console.error(`MCP: Failed to connect to ${name}: ${displayError}`);
       }
-      console.error(`MCP: Failed to connect to ${name}: ${displayError}`);
       continue;
     }
     const { metadata, failedTools } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix, config.mcpServers, startupKnownMetadata, true);

package/extensions/dm-mcp-adapter/proxy-modes.js

@@ -1,7 +1,7 @@
 import { UrlElicitationRequiredError } from "@modelcontextprotocol/client";
 import { createRequire } from "node:module";
 import { getServerPrefix, isServerDisabled, parseUiPromptHandoff } from "./types.js";
-import { lazyConnect, markKeepAliveAfterConnect, notifyToolMetadataUpdated, updateServerMetadata, updateMetadataCache, getFailureAgeSeconds, updateStatusBar, clearFailure, recordFailure } from "./init.js";
+import { clearFailure, formatMcpConnectionFailure, getFailureAgeSeconds, lazyConnect, markKeepAliveAfterConnect, notifyToolMetadataUpdated, recordFailure, updateMetadataCache, updateServerMetadata, updateStatusBar } from "./init.js";
 import { abortable, throwIfAborted } from "./abort.js";
 import { combineAbortSignals, isAbortError } from "./runtime-owner.js";
 import { buildToolMetadata, getToolNames, findToolByName, formatSchema } from "./tool-metadata.js";
@@ -17,6 +17,7 @@ import { paginate, rankSuggestions, rankToolMatches, resolveSearchKeywords } fro
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
 import { isServerInActiveFailureBackoff } from "./failure-backoff.js";
 import { getInputRequiredNeedsUiDetails } from "./errors.js";
+import { logger } from "./logger.js";
 const require = createRequire(import.meta.url);
 const MAX_REGEX_SEARCH_QUERY_LENGTH = 256;
 const INSTRUCTIONS_PREVIEW_LENGTH = 300;
@@ -812,7 +813,11 @@ export async function executeConnect(state, serverName, signal) {
     updateStatusBar(state);
     return executeList(state, serverName);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const message = formatMcpConnectionFailure(rawMessage);
+    if (message !== rawMessage) {
+      logger.debug("MCP: manual connection probe diagnostic", { server: serverName, diagnostic: rawMessage });
+    }
     if (!isAbortError(error, ownedSignal))
       recordFailure(state, serverName, message);
     updateStatusBar(state);
@@ -1134,7 +1139,11 @@ export async function executeCall(state, toolName, args, serverOverride, getPiTo
         };
       }
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      const message = formatMcpConnectionFailure(rawMessage);
+      if (message !== rawMessage) {
+        logger.debug("MCP: reconnect probe diagnostic", { server: serverName, diagnostic: rawMessage });
+      }
       if (!isAbortError(error, ownedSignal))
         recordFailure(state, serverName, message);
       updateStatusBar(state);

package/extensions/dm-skills-manager/extensions/extensions-manager.js

@@ -0,0 +1,332 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { CONFIG_DIR_NAME, getAgentDir } from "@duckmind/dm-coding-agent";
+const execFileAsync = promisify(execFile);
+export const DUCKMIND_EXTENSIONS_REMOTE = "https://github.com/DuckMind/extensions.git";
+const REMOTE_BRANCH = "main";
+const REGISTRY_FILE = ".duckmind-installed-extensions.json";
+const SKIPPED_COPY_ENTRIES = new Set([".git", ".m", "node_modules"]);
+function errorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.length > 220 ? `${message.slice(0, 219)}…` : message;
+}
+export function validateExtensionId(value) {
+  if (!/^dm-[a-z0-9][a-z0-9-]*$/.test(value)) {
+    throw new Error(`Invalid DM extension id: ${value}`);
+  }
+  return value;
+}
+function isWithin(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+export function extensionRootFor(scope, cwd, agentDir = getAgentDir()) {
+  return scope === "project" ? join(resolve(cwd), CONFIG_DIR_NAME, "extensions") : join(resolve(agentDir), "extensions");
+}
+function registryPath(extensionRoot) {
+  return join(extensionRoot, REGISTRY_FILE);
+}
+async function readRegistry(extensionRoot) {
+  try {
+    const value = JSON.parse(await fs.readFile(registryPath(extensionRoot), "utf8"));
+    if (typeof value === "object" && value !== null && value.version === 1 && typeof value.extensions === "object" && value.extensions !== null) {
+      return value;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw new Error(`Could not read extension registry: ${errorMessage(error)}`);
+    }
+  }
+  return { version: 1, extensions: {} };
+}
+async function writeRegistry(extensionRoot, registry) {
+  const staging = `${registryPath(extensionRoot)}.${randomUUID()}.tmp`;
+  await fs.writeFile(staging, `${JSON.stringify(registry, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  await fs.rename(staging, registryPath(extensionRoot));
+}
+async function readPackageManifest(packageDir) {
+  let manifest;
+  try {
+    manifest = JSON.parse(await fs.readFile(join(packageDir, "package.json"), "utf8"));
+  } catch (error) {
+    throw new Error(`Could not read package.json: ${errorMessage(error)}`);
+  }
+  const candidate = manifest;
+  if (typeof candidate.name !== "string")
+    throw new Error("package.json must declare a string name.");
+  const extensions = candidate.dm?.extensions;
+  if (!Array.isArray(extensions) || extensions.length === 0 || !extensions.every((entry) => typeof entry === "string")) {
+    throw new Error("package.json must declare a non-empty dm.extensions array.");
+  }
+  for (const entry of extensions) {
+    const target = resolve(packageDir, entry);
+    if (!isWithin(packageDir, target))
+      throw new Error(`Extension entry escapes its package: ${entry}`);
+    const stat = await fs.lstat(target).catch(() => {
+      return;
+    });
+    if (!stat?.isFile() || stat.isSymbolicLink())
+      throw new Error(`Extension entry is missing or unsafe: ${entry}`);
+  }
+  return { name: candidate.name, extensions };
+}
+async function copyDirectory(source, destination) {
+  const sourceStat = await fs.lstat(source);
+  if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink())
+    throw new Error("Extension source must be a real directory.");
+  await fs.mkdir(destination, { recursive: true, mode: 448 });
+  for (const entry of await fs.readdir(source, { withFileTypes: true })) {
+    if (SKIPPED_COPY_ENTRIES.has(entry.name))
+      continue;
+    const from = join(source, entry.name);
+    const to = join(destination, entry.name);
+    if (entry.isSymbolicLink())
+      throw new Error(`Extension source contains an unsupported symlink: ${entry.name}`);
+    if (entry.isDirectory()) {
+      await copyDirectory(from, to);
+    } else if (entry.isFile()) {
+      await fs.copyFile(from, to);
+      const mode = (await fs.stat(from)).mode & 511;
+      await fs.chmod(to, mode);
+    } else {
+      throw new Error(`Extension source contains an unsupported entry: ${entry.name}`);
+    }
+  }
+}
+export async function listInstalledExtensions(cwd, agentDir = getAgentDir()) {
+  const result = [];
+  for (const scope of ["global", "project"]) {
+    const root = extensionRootFor(scope, cwd, agentDir);
+    const registry = await readRegistry(root);
+    const entries = await fs.readdir(root, { withFileTypes: true }).catch((error) => {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    });
+    if (!entries)
+      continue;
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink() || !/^dm-/.test(entry.name))
+        continue;
+      try {
+        const manifest = await readPackageManifest(join(root, entry.name));
+        if (manifest.name !== entry.name)
+          continue;
+        const origin = registry.extensions[entry.name];
+        result.push({
+          id: entry.name,
+          scope,
+          path: join(root, entry.name),
+          source: origin?.source ?? "local",
+          revision: origin?.revision
+        });
+      } catch {}
+    }
+  }
+  return result.sort((left, right) => left.scope.localeCompare(right.scope) || left.id.localeCompare(right.id));
+}
+export async function installExtensionDirectory(sourceDirectory, extensionRoot, options) {
+  const source = resolve(sourceDirectory);
+  const manifest = await readPackageManifest(source);
+  const id = validateExtensionId(manifest.name);
+  if (options.expectedId && id !== options.expectedId) {
+    throw new Error(`Remote directory ${options.expectedId} declares ${id} instead.`);
+  }
+  const root = resolve(extensionRoot);
+  const destination = join(root, id);
+  if (!isWithin(root, destination))
+    throw new Error("Extension destination escapes its configured root.");
+  if (await fs.lstat(destination).catch(() => {
+    return;
+  })) {
+    throw new Error(`${id} is already installed at ${destination}. Remove it before importing a replacement.`);
+  }
+  await fs.mkdir(root, { recursive: true, mode: 448 });
+  const staging = join(root, `.${id}.install-${randomUUID()}`);
+  try {
+    await copyDirectory(source, staging);
+    const copied = await readPackageManifest(staging);
+    if (copied.name !== id)
+      throw new Error("Copied extension manifest changed unexpectedly.");
+    await fs.rename(staging, destination);
+    const registry = await readRegistry(root);
+    registry.extensions[id] = { source: options.source, revision: options.revision };
+    await writeRegistry(root, registry);
+  } catch (error) {
+    await fs.rm(staging, { recursive: true, force: true }).catch(() => {
+      return;
+    });
+    if (await fs.lstat(destination).catch(() => {
+      return;
+    })) {
+      await fs.rm(destination, { recursive: true, force: true }).catch(() => {
+        return;
+      });
+    }
+    throw error;
+  }
+  return { id, scope: options.scope, path: destination, source: options.source, revision: options.revision };
+}
+export async function removeInstalledExtension(extension, cwd, agentDir = getAgentDir()) {
+  const root = extensionRootFor(extension.scope, cwd, agentDir);
+  const target = resolve(extension.path);
+  if (!isWithin(root, target) || target === root || basename(target) !== extension.id) {
+    throw new Error("Refusing to remove an extension outside DM's managed extension roots.");
+  }
+  const stat = await fs.lstat(target).catch(() => {
+    return;
+  });
+  if (!stat?.isDirectory() || stat.isSymbolicLink())
+    throw new Error(`Installed extension is unavailable: ${extension.id}`);
+  await fs.rm(target, { recursive: true, force: false });
+  const registry = await readRegistry(root);
+  delete registry.extensions[extension.id];
+  await writeRegistry(root, registry);
+}
+async function withRemoteSnapshot(action) {
+  const workRoot = await fs.mkdtemp(join(tmpdir(), "dm-extensions-"));
+  const checkout = join(workRoot, "checkout");
+  try {
+    await execFileAsync("git", ["clone", "--depth", "1", "--branch", REMOTE_BRANCH, DUCKMIND_EXTENSIONS_REMOTE, checkout], {
+      timeout: 30000,
+      maxBuffer: 1024 * 1024
+    });
+    const { stdout } = await execFileAsync("git", ["-C", checkout, "rev-parse", "HEAD"], { timeout: 1e4 });
+    const revision = stdout.trim();
+    if (!/^[0-9a-f]{40}$/i.test(revision))
+      throw new Error("DuckMind extensions repository returned an invalid revision.");
+    return await action({ root: checkout, revision });
+  } finally {
+    await fs.rm(workRoot, { recursive: true, force: true }).catch(() => {
+      return;
+    });
+  }
+}
+async function chooseScope(ctx) {
+  const selected = await ctx.ui.select("Install extension for", [
+    "Global — available in every DM workspace",
+    "Project — available only in this workspace"
+  ]);
+  if (!selected)
+    return;
+  if (selected.startsWith("Project")) {
+    if (!ctx.isProjectTrusted()) {
+      ctx.ui.notify("Trust this project before writing .dm/extensions.", "warning");
+      return;
+    }
+    return "project";
+  }
+  return "global";
+}
+async function reloadAfterMutation(ctx, message) {
+  ctx.ui.notify(`${message} Reloading DM resources…`, "info");
+  await ctx.reload();
+}
+async function installRemoteExtension(ctx) {
+  await withRemoteSnapshot(async ({ root, revision }) => {
+    const candidates = (await fs.readdir(root, { withFileTypes: true })).filter((entry) => entry.isDirectory() && /^dm-/.test(entry.name)).map((entry) => entry.name).sort();
+    const id = await ctx.ui.select("Install from DuckMind extensions", candidates);
+    if (!id)
+      return;
+    const scope = await chooseScope(ctx);
+    if (!scope)
+      return;
+    const confirmed = await ctx.ui.confirm(`Install ${id}?`, `DM will copy ${id} from the reviewed DuckMind extensions repository at ${revision.slice(0, 12)} into ${scope} extensions.`);
+    if (!confirmed)
+      return;
+    const targetRoot = extensionRootFor(scope, ctx.cwd);
+    await installExtensionDirectory(join(root, id), targetRoot, { expectedId: id, scope, source: "duckmind", revision });
+    await reloadAfterMutation(ctx, `Installed ${id}.`);
+  });
+}
+async function installLocalExtension(ctx) {
+  const input = await ctx.ui.input("Local DM extension directory", "Path containing package.json with dm.extensions");
+  if (!input?.trim())
+    return;
+  const source = resolve(ctx.cwd, input.trim());
+  const manifest = await readPackageManifest(source);
+  const id = validateExtensionId(manifest.name);
+  const scope = await chooseScope(ctx);
+  if (!scope)
+    return;
+  const confirmed = await ctx.ui.confirm(`Install ${id}?`, `DM will copy the local directory into ${scope} extensions. Symlinks and node_modules are rejected.`);
+  if (!confirmed)
+    return;
+  await installExtensionDirectory(source, extensionRootFor(scope, ctx.cwd), { scope, source: "local" });
+  await reloadAfterMutation(ctx, `Installed ${id}.`);
+}
+async function removeLocalExtension(ctx) {
+  const installed = await listInstalledExtensions(ctx.cwd);
+  if (installed.length === 0) {
+    ctx.ui.notify("No locally installed DM extension packages were found.", "info");
+    return;
+  }
+  const labels = installed.map((extension) => `[${extension.scope}] ${extension.id} — ${extension.source}`);
+  const selected = await ctx.ui.select("Remove installed DM extension", labels);
+  if (!selected)
+    return;
+  const extension = installed[labels.indexOf(selected)];
+  if (!extension)
+    return;
+  if (extension.scope === "project" && !ctx.isProjectTrusted()) {
+    ctx.ui.notify("Trust this project before removing its .dm/extensions entry.", "warning");
+    return;
+  }
+  const confirmed = await ctx.ui.confirm(`Remove ${extension.id}?`, `This permanently deletes only ${extension.path}, beneath DM's ${extension.scope} extension root.`);
+  if (!confirmed)
+    return;
+  await removeInstalledExtension(extension, ctx.cwd);
+  await reloadAfterMutation(ctx, `Removed ${extension.id}.`);
+}
+async function showInstalledExtensions(ctx) {
+  const installed = await listInstalledExtensions(ctx.cwd);
+  if (installed.length === 0) {
+    ctx.ui.notify("No locally installed DM extension packages were found.", "info");
+    return;
+  }
+  await ctx.ui.select("Installed DM extensions", installed.map((extension) => `[${extension.scope}] ${extension.id} — ${extension.source}${extension.revision ? ` @ ${extension.revision.slice(0, 12)}` : ""}`));
+}
+export default function extensionsManager(dm) {
+  dm.registerCommand("extensions", {
+    description: "Install, inspect, or remove local DM extension packages.",
+    handler: async (args, ctx) => {
+      if (args.trim()) {
+        ctx.ui.notify("Use /extensions with no arguments to open the extension manager.", "warning");
+        return;
+      }
+      if (!ctx.hasUI) {
+        ctx.ui.notify("/extensions manager requires interactive mode.", "warning");
+        return;
+      }
+      try {
+        const action = await ctx.ui.select("DM Extensions", [
+          "Install from DuckMind extensions",
+          "Install a local extension directory",
+          "Remove an installed local extension",
+          "List installed local extensions"
+        ]);
+        switch (action) {
+          case "Install from DuckMind extensions":
+            await installRemoteExtension(ctx);
+            break;
+          case "Install a local extension directory":
+            await installLocalExtension(ctx);
+            break;
+          case "Remove an installed local extension":
+            await removeLocalExtension(ctx);
+            break;
+          case "List installed local extensions":
+            await showInstalledExtensions(ctx);
+            break;
+        }
+      } catch (error) {
+        ctx.ui.notify(`Extensions manager failed: ${errorMessage(error)}`, "error");
+      }
+    }
+  });
+}

package/extensions/dm-skills-manager/extensions/skills-manager.js

@@ -35,17 +35,17 @@ export default function skillsManager(pi) {
       ctx.ui.notify("Skills Manager enabled. Reloading...", "info");
       await ctx.reload();
     };
-    pi.registerCommand("skill", {
+    pi.registerCommand("skills", {
       description: "Skills manager recovery command.",
       handler: async (args, ctx) => {
         if (args.trim().toLowerCase() !== "enable") {
-          ctx.ui.notify("Skills Manager is disabled. Run /skill:enable, then /reload.", "warning");
+          ctx.ui.notify("Skills Manager is disabled. Run /skills:enable, then /reload.", "warning");
           return;
         }
         await enableRecovery(ctx);
       }
     });
-    pi.registerCommand("skill:enable", {
+    pi.registerCommand("skills:enable", {
       description: "Re-enable the skills manager",
       handler: async (_args, ctx) => enableRecovery(ctx)
     });
@@ -66,7 +66,7 @@ export default function skillsManager(pi) {
     }
     return false;
   }
-  pi.registerCommand("skill", {
+  pi.registerCommand("skills", {
     description: "DM skills manager view. Native skills remain /skill:name.",
     handler: async (args, ctx) => {
       const rawArgs = args.trim();
@@ -82,11 +82,11 @@ export default function skillsManager(pi) {
         return;
       }
       if (rawArgs) {
-        ctx.ui.notify("Use /skill:name for native skill invocation, or /skill with no arguments for the manager.", "warning");
+        ctx.ui.notify("Use /skill:name for native skill invocation, or /skills with no arguments for the manager.", "warning");
         return;
       }
       if (!ctx.hasUI) {
-        ctx.ui.notify("/skill manager requires interactive mode", "warning");
+        ctx.ui.notify("/skills manager requires interactive mode", "warning");
         return;
       }
       try {

package/extensions/dm-skills-manager/package.json

@@ -25,7 +25,7 @@
         {
           "key": "enabled",
           "label": "Enable skills manager",
-          "description": "Register the /skill manager view, startup skill-list hiding, and skills management UI. If disabled, /skill enable remains available as a recovery command. Native /skill:name commands stay controlled by DM's Skill commands setting.",
+          "description": "Register the /skills manager view, startup skill-list hiding, and skills management UI. If disabled, /skills enable remains available as a recovery command. Native /skill:name commands stay controlled by DM's Skill commands setting.",
           "type": "boolean",
           "default": true,
           "category": "General",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckmind/dm-linux-x64",
-  "version": "0.64.2",
+  "version": "0.65.2",
   "description": "DuckMind (dm) binary payload for linux x64",
   "license": "MIT",
   "os": [

package/theme/duckmind-classic.json

@@ -8,9 +8,9 @@
     "tertiaryBg": "#1a1a28",
     "elevatedBg": "#202030",
     "hoverBg": "#252535",
-    "textPrimary": "#e8e8f0",
+    "textPrimary": "#f4f4f8",
     "textSecondary": "#9090a8",
-    "textMuted": "#606078",
+    "textMuted": "#707084",
     "textDim": "#404050",
     "accentPrimary": "#667eea",
     "accentSecondary": "#764ba2",
@@ -34,17 +34,17 @@
     "muted": "textMuted",
     "dim": "textDim",
     "text": "textPrimary",
-    "thinkingText": "textSecondary",
+    "thinkingText": "textMuted",
     "selectedBg": "elevatedBg",
     "userMessageBg": "secondaryBg",
     "userMessageText": "textPrimary",
     "customMessageBg": "tertiaryBg",
     "customMessageText": "textPrimary",
-    "customMessageLabel": "accentPrimary",
+    "customMessageLabel": "purple",
     "toolPendingBg": "primaryBg",
     "toolSuccessBg": "secondaryBg",
     "toolErrorBg": "secondaryBg",
-    "toolTitle": "accentPrimary",
+    "toolTitle": "cyan",
     "toolOutput": "textPrimary",
     "mdHeading": "textPrimary",
     "mdLink": "accentPrimary",
@@ -74,7 +74,7 @@
     "thinkingMedium": "accentPrimary",
     "thinkingHigh": "indigo",
     "thinkingXhigh": "pink",
-    "bashMode": "warning"
+    "bashMode": "info"
   },
   "export": {
     "pageBg": "deepBlue",