codedeck 0.2.0 → 0.4.0

package/dist/plugin/hooks/session-name.mjs

@@ -0,0 +1,66 @@
+import { spawn } from "node:child_process";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { tmpdir } from "node:os";
+
+import { slugFromPrompt } from "./session-name-lib.mjs";
+
+const worker = fileURLToPath(new URL("./session-name-worker.mjs", import.meta.url));
+
+function writeFallback(sidecar, prompt) {
+  try {
+    writeFileSync(sidecar, slugFromPrompt(prompt), { encoding: "utf8", flag: "wx" });
+  } catch {}
+}
+
+let payload;
+try {
+  payload = JSON.parse(readFileSync(0, "utf8"));
+} catch {
+  process.exit(0);
+}
+
+if (
+  payload === null ||
+  typeof payload !== "object" ||
+  Array.isArray(payload) ||
+  typeof process.env.CODEDECK_SESSION_FILE !== "string" ||
+  process.env.CODEDECK_SESSION_FILE.length === 0 ||
+  typeof payload.session_id !== "string" ||
+  !/^[0-9a-fA-F-]{8,}$/.test(payload.session_id)
+) process.exit(0);
+
+const sessionFile = process.env.CODEDECK_SESSION_FILE;
+const sessionId = payload.session_id;
+const sidecar = `${sessionFile}.${sessionId}.name`;
+if (existsSync(sidecar)) process.exit(0);
+
+const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
+// The worker gets one temp directory it can validate; the sidecar path and the
+// prompt travel inside job.json rather than on argv, so the worker never opens a
+// path handed to it as a command-line argument.
+let jobDir;
+try {
+  jobDir = mkdtempSync(join(tmpdir(), "codedeck-session-name-"));
+  writeFileSync(join(jobDir, "job.json"), JSON.stringify({ sidecar, prompt }), {
+    encoding: "utf8",
+    flag: "wx",
+  });
+
+  const child = spawn(process.execPath, [worker, jobDir], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+  process.exit(0);
+} catch {
+  if (jobDir) rmSync(jobDir, { recursive: true, force: true });
+  writeFallback(sidecar, prompt);
+}

package/dist/plugin/hooks/session-name.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+# UserPromptSubmit already provides the JSON payload on stdin. Keep this entry
+# point small so the slow title generation can run after Claude receives it.
+set -u
+
+exec node "${CLAUDE_PLUGIN_ROOT}/hooks/session-name.mjs"

package/dist/plugin/pty-shim.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * Roda DENTRO do pty criado pelo `script`, entre ele e o harness.
+ *
+ * Existe por causa de dois buracos que o processo pai não consegue tapar de
+ * fora:
+ *
+ * - `script` só dimensiona o pty quando o stdin dele é um terminal. No nosso
+ *   desenho o stdin do `script` é um pipe (é por ali que a injeção do
+ *   `/rename` entra), então o pty nasce 0x0 e qualquer TUI fullscreen desenha
+ *   errado.
+ * - Node não expõe ioctl, então TIOCSWINSZ só é alcançável por um binário que
+ *   faça a chamada: `stty`, que herda o slave do pty no fd 0.
+ */
+import net from "node:net";
+import os from "node:os";
+import { accessSync, constants } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+
+// The command comes from `codedeck open`, one argv entry per argument, and is
+// run without a shell. The guard is there so a value that could only have been
+// mangled on the way in — a control character, an empty binary — stops here
+// rather than becoming a process.
+const SAFE_BINARY = /^[^\u0000-\u001f]+$/;
+const target = process.argv.slice(2);
+if (target.length === 0 || !SAFE_BINARY.test(target[0])) {
+  process.stderr.write("pty-shim: missing or unusable target command\n");
+  process.exit(64);
+}
+
+/**
+ * Named by absolute path rather than looked up on PATH: this runs with the
+ * environment of whoever opened the session, and a PATH entry they can write
+ * to would decide what "stty" means.
+ */
+const STTY = ["/bin/stty", "/usr/bin/stty"].find((candidate) => {
+  try {
+    accessSync(candidate, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+});
+
+// Applying the size on the slave is also what makes the kernel raise SIGWINCH
+// on the session's foreground group, so the TUI redraws without ever knowing
+// this shim exists.
+function applySize(rows, cols) {
+  if (STTY === undefined) return false;
+  if (!Number.isInteger(rows) || !Number.isInteger(cols) || rows <= 0 || cols <= 0) return false;
+  const done = spawnSync(STTY, ["rows", String(rows), "cols", String(cols)], {
+    stdio: ["inherit", "ignore", "ignore"],
+  });
+  return done.status === 0;
+}
+
+applySize(Number(process.env.CODEDECK_PTY_ROWS), Number(process.env.CODEDECK_PTY_COLS));
+
+const [binary, ...args] = target;
+const child = spawn(binary, args, { stdio: "inherit", shell: false });
+
+// Ctrl+C typed by the user reaches the whole foreground group, this shim
+// included. The harness owns that key (Claude Code draws its own interrupt),
+// so the shim stays alive and lets the child decide when to die.
+process.on("SIGINT", () => {});
+process.on("SIGTERM", () => {});
+
+let server;
+const control = process.env.CODEDECK_PTY_CONTROL;
+if (control) {
+  server = net.createServer((conn) => {
+    let buffer = "";
+    conn.setEncoding("utf8");
+    conn.on("data", (chunk) => {
+      buffer += chunk;
+      let index;
+      while ((index = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, index).trim();
+        buffer = buffer.slice(index + 1);
+        if (line.length === 0) continue;
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (message?.type === "resize") applySize(Number(message.rows), Number(message.cols));
+      }
+    });
+    conn.on("error", () => {});
+  });
+  server.on("error", () => {});
+  server.listen(control);
+}
+
+const closeServer = () => {
+  try {
+    server?.close();
+  } catch {}
+};
+
+child.on("error", (error) => {
+  closeServer();
+  process.stderr.write(`pty-shim: ${error.message}\n`);
+  process.exit(126);
+});
+
+// The exit status has to survive both layers so `codedeck open` still reports
+// what the harness actually did.
+child.on("exit", (code, signal) => {
+  closeServer();
+  if (signal) process.exit(128 + (os.constants.signals[signal] ?? 0));
+  process.exit(code ?? 0);
+});

package/dist/plugin/statusline.sh

@@ -2,11 +2,14 @@
 
 # Claude Code sends the status payload on stdin. Keep parsing in Node so this
 # plugin does not require jq or Python on the host.
+#
+# The JS below is single quoted, so it must not contain a single quote anywhere.
 set -u
 
 node --input-type=module -e '
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { readFileSync, writeSync } from "node:fs";
+import { basename } from "node:path";
 
 let payload;
 try {
@@ -14,6 +17,23 @@ try {
 } catch {
   process.exit(0);
 }
+if (payload === null || typeof payload !== "object") process.exit(0);
+
+/**
+ * Claude Code dims every status row before printing it, so the palette here is
+ * the bright end of the theme on purpose: a mid tone arrives on screen as grey.
+ * SGR survives, which is why these are raw escapes and not a library.
+ */
+const BLOOD = "\x1b[38;2;225;29;72m";
+const EMBER = "\x1b[38;2;251;146;60m";
+const TEXT = "\x1b[38;2;247;237;238m";
+const MUTED = "\x1b[38;2;163;139;143m";
+const GREEN = "\x1b[38;2;74;222;128m";
+const AMBER = "\x1b[38;2;251;191;36m";
+const RED = "\x1b[38;2;255;77;109m";
+const OFF = "\x1b[0m";
+
+const paint = (color, value) => color + value + OFF;
 
 const text = (value) => {
   if (typeof value !== "string") return undefined;
@@ -23,29 +43,55 @@ const text = (value) => {
 
 const firstText = (...values) => values.map(text).find(Boolean);
 
-const roleFrom = (value) => {
+/**
+ * A row is one line, so anything that could carry a newline is flattened before
+ * it reaches the terminal.
+ */
+const clean = (value) => value.replace(/[\t\r\n]/g, " ");
+
+const tail = (value) => {
   const candidate = text(value);
   if (!candidate) return undefined;
   const parts = candidate.split(/[·:]/).map((part) => part.trim()).filter(Boolean);
   return parts.at(-1) ?? candidate;
 };
 
-const role = roleFrom(
-  payload.agent?.name,
-  payload.agent?.role,
-  payload.role,
-  payload.session_role,
-) ?? roleFrom(
-  text(payload.session_name)?.match(/CodeDeck\s*·\s*(.+)$/i)?.[1],
-);
-const model = firstText(payload.model?.display_name, payload.model?.id, payload.model);
+/**
+ * `codedeck open` puts the role at the end of session_name, so the tail remains
+ * the source for ordinary sessions. agent.name is only a fallback.
+ */
+const role =
+  tail(text(payload.session_name)?.match(/CodeDeck\s*[·:]\s*(.+)$/i)?.[1]) ??
+  tail(payload.agent?.name) ??
+  tail(payload.session_name);
+
+const taskName = (() => {
+  const sessionFile = text(process.env.CODEDECK_SESSION_FILE);
+  const sessionId = payload.session_id;
+  if (
+    !sessionFile ||
+    typeof sessionId !== "string" ||
+    !/^[0-9a-fA-F-]{8,}$/.test(sessionId)
+  ) return undefined;
+
+  try {
+    const value = readFileSync(`${sessionFile}.${sessionId}.name`, "utf8")
+      .replace(/\s+/g, " ")
+      .trim()
+      .slice(0, 30);
+    return value || undefined;
+  } catch {
+    return undefined;
+  }
+})();
+
 const cwd = firstText(payload.workspace?.current_dir, payload.cwd) ?? process.cwd();
+const project = text(basename(cwd)) ?? (cwd === "/" ? "/" : undefined);
 
-let branch = firstText(
-  payload.worktree?.branch,
-  payload.workspace?.git_worktree,
-  payload.branch,
-);
+/**
+ * Claude supplies a branch for its own worktrees. Git fills the ordinary case.
+ */
+let branch = text(payload.worktree?.branch);
 if (!branch) {
   try {
     branch = text(execFileSync("git", ["-C", cwd, "branch", "--show-current"], {
@@ -57,12 +103,158 @@ if (!branch) {
   }
 }
 
-const clean = (value) => value?.replace(/[\t\r\n]/g, " ");
+/**
+ * Context is reported as remaining, not used. Colour keeps the existing bands.
+ */
+const contextField = () => {
+  const remaining = payload.context_window?.remaining_percentage;
+  if (typeof remaining !== "number" || !Number.isFinite(remaining)) return undefined;
+  const value = Math.max(0, Math.min(100, Math.round(remaining)));
+  const color = value <= 15 ? RED : value <= 35 ? AMBER : GREEN;
+  return paint(MUTED, "ctx ") + paint(color, value + "%");
+};
+
+const nonNegativeNumber = (value) =>
+  typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+
+const compactTokens = (value) => {
+  const total = Math.max(0, Math.round(value));
+  if (total < 1000) return String(total);
+  if (total >= 1_000_000) {
+    const millions = total / 1_000_000;
+    return millions.toFixed(millions < 10 ? 1 : 0).replace(/\.0$/, "") + "M";
+  }
+  const thousands = total / 1000;
+  const roundedThousands = Number(thousands.toFixed(thousands < 100 ? 1 : 0));
+  if (roundedThousands >= 1000) return "1M";
+  return String(roundedThousands).replace(/\.0$/, "") + "k";
+};
+
+/**
+ * Since Claude Code 2.1.132, these fields describe the latest context window,
+ * not cumulative session totals. The aggregate token field therefore stays
+ * worker-only instead of adding a repeated local window to the run total.
+ * Degraded mode may show this current local snapshot when it is available.
+ */
+const localTokens = () => {
+  const context = payload.context_window;
+  const totalInput = nonNegativeNumber(context?.total_input_tokens);
+  const totalOutput = nonNegativeNumber(context?.total_output_tokens);
+  if (totalInput !== undefined && totalOutput !== undefined) return totalInput + totalOutput;
+
+  const current = context?.current_usage;
+  const input = nonNegativeNumber(current?.input_tokens);
+  const output = nonNegativeNumber(current?.output_tokens);
+  const cacheCreation = nonNegativeNumber(current?.cache_creation_input_tokens);
+  const cacheRead = nonNegativeNumber(current?.cache_read_input_tokens);
+  if (
+    input !== undefined &&
+    output !== undefined &&
+    cacheCreation !== undefined &&
+    cacheRead !== undefined
+  ) return input + output + cacheCreation + cacheRead;
+  return undefined;
+};
+
+const COST_DISPLAY_THRESHOLD = 0.01;
+const COST_TEXT_THRESHOLD = 1;
+const COST_EMBER_THRESHOLD = 5;
+const COST_BLOOD_THRESHOLD = 10;
+
+const costColor = (total) =>
+  total < COST_TEXT_THRESHOLD ? MUTED :
+  total < COST_EMBER_THRESHOLD ? TEXT :
+  total < COST_BLOOD_THRESHOLD ? EMBER : BLOOD;
+
+const costAmount = (total, incomplete = false) => {
+  const value = total >= COST_DISPLAY_THRESHOLD ? "$" + total.toFixed(2) : "$";
+  const amount = paint(costColor(total), value);
+  return incomplete ? amount + paint(AMBER, "?") : amount;
+};
+
+const localCost = () => {
+  const total = payload.cost?.total_cost_usd;
+  return typeof total === "number" && Number.isFinite(total) ? total : undefined;
+};
+
+const getRunUsage = () => {
+  const runId = text(process.env.CODEDECK_RUN_ID);
+  if (!runId) return undefined;
+
+  try {
+    const output = execFileSync("codedeck", ["usage", runId, "--json"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1000,
+      maxBuffer: 1024 * 1024,
+    });
+    const usage = JSON.parse(output);
+    if (
+      usage === null ||
+      typeof usage !== "object" ||
+      usage.runId !== runId ||
+      typeof usage.inputTokens !== "number" ||
+      !Number.isFinite(usage.inputTokens) ||
+      typeof usage.outputTokens !== "number" ||
+      !Number.isFinite(usage.outputTokens) ||
+      typeof usage.cachedTokens !== "number" ||
+      !Number.isFinite(usage.cachedTokens) ||
+      typeof usage.costUsd !== "number" ||
+      !Number.isFinite(usage.costUsd) ||
+      typeof usage.sessionCount !== "number" ||
+      !Number.isFinite(usage.sessionCount) ||
+      typeof usage.activeSessionCount !== "number" ||
+      !Number.isFinite(usage.activeSessionCount) ||
+      typeof usage.costComplete !== "boolean" ||
+      typeof usage.sessionsWithoutCost !== "number" ||
+      !Number.isFinite(usage.sessionsWithoutCost)
+    ) return undefined;
+    return usage;
+  } catch {
+    return undefined;
+  }
+};
+
+const local = localCost();
+const runUsage = getRunUsage();
+const workerTokens = runUsage
+  ? runUsage.inputTokens + runUsage.outputTokens + runUsage.cachedTokens
+  : undefined;
+const tokenField = () => {
+  const total = workerTokens ?? (runUsage ? undefined : localTokens());
+  return total === undefined ? undefined : paint(MUTED, compactTokens(total) + " tok");
+};
+
+const runField = () => {
+  if (!runUsage) return undefined;
+  const total = (local ?? 0) + runUsage.costUsd;
+  const incomplete = !runUsage.costComplete;
+  if (!incomplete && total < COST_DISPLAY_THRESHOLD) return undefined;
+  return paint(MUTED, "run ") + costAmount(total, incomplete);
+};
+
+const localField = () => {
+  if (local === undefined || local < COST_DISPLAY_THRESHOLD) return undefined;
+  return costAmount(local);
+};
+
+const projectBranch = project && branch
+  ? paint(TEXT, clean(project)) + paint(MUTED, "/") + paint(BLOOD, clean(branch))
+  : project
+    ? paint(TEXT, clean(project))
+    : branch
+      ? paint(BLOOD, clean(branch))
+      : undefined;
+
 const fields = [
-  role && `role:${clean(role)}`,
-  model && `model:${clean(model)}`,
-  `branch:${clean(branch) ?? "(none)"}`,
+  taskName && paint(EMBER, clean(taskName)),
+  role && paint(EMBER, clean(role)),
+  projectBranch,
+  contextField(),
+  tokenField(),
+  runUsage ? runField() : localField(),
+  runUsage && paint(TEXT, String(Math.max(0, Math.round(runUsage.activeSessionCount))) + " agents"),
 ].filter(Boolean);
 
-process.stdout.write(fields.join(" · "));
-' 
+writeSync(1, fields.join(paint(MUTED, " · ")));
+'

package/dist/plugin/themes/codedeck-rage.json

@@ -0,0 +1,74 @@
+{
+  "$schema": "https://opencode.ai/theme.json",
+  "defs": {
+    "blood": "#E11D48",
+    "shimmer": "#C026D3",
+    "ember": "#FB923C",
+    "amber": "#FBBF24",
+    "remember": "#FACC15",
+    "green": "#4ADE80",
+    "red": "#FF4D6D",
+    "text": "#F7EDEE",
+    "muted": "#A38B8F",
+    "ink": "#140406",
+    "panel": "#1F0A0E",
+    "element": "#2A0710",
+    "rose": "#FDA4AF",
+    "pink": "#F472B6",
+    "blue": "#60A5FA",
+    "cyan": "#22D3EE",
+    "mint": "#34D399",
+    "purple": "#C084FC",
+    "deepGreen": "#14532D",
+    "deepRed": "#7F1D1D"
+  },
+  "theme": {
+    "primary": { "dark": "blood", "light": "blood" },
+    "secondary": { "dark": "rose", "light": "blood" },
+    "accent": { "dark": "shimmer", "light": "shimmer" },
+    "error": { "dark": "red", "light": "red" },
+    "warning": { "dark": "amber", "light": "amber" },
+    "success": { "dark": "green", "light": "green" },
+    "info": { "dark": "blue", "light": "blue" },
+    "text": { "dark": "text", "light": "ink" },
+    "textMuted": { "dark": "muted", "light": "muted" },
+    "background": { "dark": "ink", "light": "text" },
+    "backgroundPanel": { "dark": "panel", "light": "rose" },
+    "backgroundElement": { "dark": "element", "light": "rose" },
+    "border": { "dark": "blood", "light": "blood" },
+    "borderActive": { "dark": "ember", "light": "ember" },
+    "borderSubtle": { "dark": "muted", "light": "muted" },
+    "diffAdded": { "dark": "green", "light": "deepGreen" },
+    "diffRemoved": { "dark": "red", "light": "deepRed" },
+    "diffContext": { "dark": "muted", "light": "muted" },
+    "diffHunkHeader": { "dark": "cyan", "light": "blue" },
+    "diffHighlightAdded": { "dark": "green", "light": "deepGreen" },
+    "diffHighlightRemoved": { "dark": "red", "light": "deepRed" },
+    "diffAddedBg": { "dark": "deepGreen", "light": "green" },
+    "diffRemovedBg": { "dark": "deepRed", "light": "red" },
+    "diffContextBg": { "dark": "ink", "light": "text" },
+    "diffLineNumber": { "dark": "muted", "light": "muted" },
+    "diffAddedLineNumberBg": { "dark": "deepGreen", "light": "green" },
+    "diffRemovedLineNumberBg": { "dark": "deepRed", "light": "red" },
+    "markdownText": { "dark": "text", "light": "ink" },
+    "markdownHeading": { "dark": "blood", "light": "blood" },
+    "markdownLink": { "dark": "cyan", "light": "blue" },
+    "markdownLinkText": { "dark": "cyan", "light": "blue" },
+    "markdownCode": { "dark": "ember", "light": "ember" },
+    "markdownBlockQuote": { "dark": "muted", "light": "muted" },
+    "markdownEmph": { "dark": "rose", "light": "blood" },
+    "markdownStrong": { "dark": "text", "light": "ink" },
+    "markdownHorizontalRule": { "dark": "blood", "light": "blood" },
+    "markdownListItem": { "dark": "ember", "light": "ember" },
+    "markdownCodeBlock": { "dark": "element", "light": "rose" },
+    "syntaxComment": { "dark": "muted", "light": "muted" },
+    "syntaxKeyword": { "dark": "blood", "light": "blood" },
+    "syntaxFunction": { "dark": "blue", "light": "blue" },
+    "syntaxVariable": { "dark": "cyan", "light": "blue" },
+    "syntaxString": { "dark": "green", "light": "deepGreen" },
+    "syntaxNumber": { "dark": "ember", "light": "ember" },
+    "syntaxType": { "dark": "purple", "light": "shimmer" },
+    "syntaxOperator": { "dark": "pink", "light": "blood" },
+    "syntaxPunctuation": { "dark": "muted", "light": "muted" }
+  }
+}

package/dist/plugin/themes/codedeck-ultra.json

@@ -1,47 +1,55 @@
 {
-  "name": "CodeDeck Ultra",
+  "name": "CodeDeck Rage",
   "base": "dark",
   "overrides": {
-    "claude": "#8BE9FD",
-    "claudeShimmer": "#C4F1FF",
-    "text": "#F8FAFC",
-    "inverseText": "#0B1020",
-    "inactive": "#94A3B8",
-    "inactiveShimmer": "#CBD5E1",
-    "subtle": "#475569",
-    "suggestion": "#67E8F9",
-    "permission": "#A78BFA",
-    "permissionShimmer": "#C4B5FD",
+    "claude": "#E11D48",
+    "claudeShimmer": "#C026D3",
+    "claudeBlue_FOR_SYSTEM_SPINNER": "#E11D48",
+    "claudeBlueShimmer_FOR_SYSTEM_SPINNER": "#C026D3",
+    "autoAcceptShimmer": "#FCA5A5",
+    "clawd_body": "#881337",
+    "clawd_background": "#140406",
+    "background": "#140406",
+    "composerSidebarBackground": "#1F0A0E",
+    "professionalBlue": "#F43F5E",
+    "text": "#F7EDEE",
+    "inverseText": "#140406",
+    "inactive": "#A38B8F",
+    "inactiveShimmer": "#D6C2C5",
+    "subtle": "#EC6A5C",
+    "suggestion": "#FCA5A5",
+    "permission": "#FB923C",
+    "permissionShimmer": "#FED7AA",
     "remember": "#FACC15",
-    "success": "#34D399",
-    "error": "#FB7185",
+    "success": "#4ADE80",
+    "error": "#FF4D6D",
     "warning": "#FBBF24",
     "warningShimmer": "#FDE68A",
-    "merged": "#C084FC",
-    "promptBorder": "#22D3EE",
-    "promptBorderShimmer": "#67E8F9",
-    "planMode": "#60A5FA",
-    "autoAccept": "#34D399",
+    "merged": "#F43F5E",
+    "promptBorder": "#E11D48",
+    "promptBorderShimmer": "#C026D3",
+    "planMode": "#FDA4AF",
+    "autoAccept": "#4ADE80",
     "bashBorder": "#F59E0B",
-    "ide": "#C084FC",
-    "fastMode": "#F472B6",
-    "fastModeShimmer": "#F9A8D4",
-    "effortUltra": "#A78BFA",
+    "ide": "#F43F5E",
+    "fastMode": "#FF4D6D",
+    "fastModeShimmer": "#FFD1D8",
+    "effortUltra": "#FB7185",
     "diffAdded": "#14532D",
     "diffRemoved": "#7F1D1D",
     "diffAddedDimmed": "#166534",
     "diffRemovedDimmed": "#991B1B",
     "diffAddedWord": "#22C55E",
     "diffRemovedWord": "#EF4444",
-    "userMessageBackground": "#172554",
-    "userMessageBackgroundHover": "#1E3A8A",
+    "userMessageBackground": "#2A0710",
+    "userMessageBackgroundHover": "#4C0D1C",
     "bashMessageBackgroundColor": "#451A03",
-    "memoryBackgroundColor": "#27272A",
-    "selectionBg": "#334155",
-    "rate_limit_fill": "#22D3EE",
-    "rate_limit_empty": "#334155",
-    "briefLabelYou": "#67E8F9",
-    "briefLabelClaude": "#A78BFA",
+    "memoryBackgroundColor": "#291B1D",
+    "selectionBg": "#4C1D24",
+    "rate_limit_fill": "#E11D48",
+    "rate_limit_empty": "#3F1E24",
+    "briefLabelYou": "#FCA5A5",
+    "briefLabelClaude": "#E11D48",
     "red_FOR_SUBAGENTS_ONLY": "#FB7185",
     "blue_FOR_SUBAGENTS_ONLY": "#60A5FA",
     "green_FOR_SUBAGENTS_ONLY": "#34D399",
@@ -50,19 +58,19 @@
     "orange_FOR_SUBAGENTS_ONLY": "#FB923C",
     "pink_FOR_SUBAGENTS_ONLY": "#F472B6",
     "cyan_FOR_SUBAGENTS_ONLY": "#22D3EE",
-    "rainbow_red": "#EF4444",
-    "rainbow_red_shimmer": "#FCA5A5",
-    "rainbow_orange": "#F97316",
-    "rainbow_orange_shimmer": "#FDBA74",
-    "rainbow_yellow": "#EAB308",
-    "rainbow_yellow_shimmer": "#FDE047",
-    "rainbow_green": "#22C55E",
-    "rainbow_green_shimmer": "#86EFAC",
-    "rainbow_blue": "#3B82F6",
-    "rainbow_blue_shimmer": "#93C5FD",
-    "rainbow_indigo": "#6366F1",
-    "rainbow_indigo_shimmer": "#A5B4FC",
-    "rainbow_violet": "#8B5CF6",
-    "rainbow_violet_shimmer": "#C4B5FD"
+    "rainbow_red": "#7F1D1D",
+    "rainbow_red_shimmer": "#B91C1C",
+    "rainbow_orange": "#B91C1C",
+    "rainbow_orange_shimmer": "#E11D48",
+    "rainbow_yellow": "#E11D48",
+    "rainbow_yellow_shimmer": "#F43F5E",
+    "rainbow_green": "#F43F5E",
+    "rainbow_green_shimmer": "#FB7185",
+    "rainbow_blue": "#FB7185",
+    "rainbow_blue_shimmer": "#FB923C",
+    "rainbow_indigo": "#FB923C",
+    "rainbow_indigo_shimmer": "#FBBF24",
+    "rainbow_violet": "#FBBF24",
+    "rainbow_violet_shimmer": "#FDE68A"
   }
 }