@selesai/code 0.13.13 → 0.13.15

package/dist/skills/unlazy/tests/self-check.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+// self-check.mjs : structural checks on the skill's own scripts.
+//
+//   node tests/self-check.mjs
+//
+// Lives in a file rather than as an inline `node -e` in GATES.md on purpose: a
+// one-liner containing quotes, "^" or "!" is parsed differently by cmd.exe and
+// by sh, so an inline check can pass on one platform and report a phantom
+// failure on the other. A CHECK line should name a script, not embed one.
+//
+// Prints "self-check ok (N/N)" on success, which is what the gate matches.
+
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const SCRIPTS = [
+  "scripts/gate-check.mjs",
+  "scripts/gate-lint.mjs",
+  "scripts/dispatch-check.mjs",
+  "scripts/lib/gates.mjs",
+  "scripts/lib/dispatch.mjs",
+  "scripts/lib/check-supervisor.mjs",
+  "scripts/lib/process-tree.mjs",
+  "scripts/lib/regex-worker.mjs",
+  "tests/run-tests.mjs",
+  "tests/dispatch-tests.mjs",
+  "tests/hardening-tests.mjs",
+  "tests/stress-tests.mjs",
+  "tests/lint-tests.mjs",
+  "tests/contract-tests.mjs",
+  "tests/self-check.mjs",
+];
+
+const read = (p) => readFileSync(join(ROOT, p), "utf8");
+const checks = [];
+const check = (name, fn) => checks.push({ name, fn });
+
+check("zero non-stdlib imports", () => {
+  const bad = [];
+  for (const p of SCRIPTS) {
+    for (const m of read(p).matchAll(/^\s*import\s[^;]*?from\s+["']([^"']+)["']/gm)) {
+      const spec = m[1];
+      if (!spec.startsWith("node:") && !spec.startsWith(".")) bad.push(p + " -> " + spec);
+    }
+  }
+  return bad.length ? "non-stdlib import: " + bad.join(", ") : null;
+});
+
+check("one shared gate parser", () => {
+  // The v2.0 checker and hook each had their own GATE_RE and disagreed about a
+  // gate's id when it carried no "Gn:" prefix. Parsing now lives only in the lib.
+  // This file names GATE_RE to describe the rule, so it scans only scripts/.
+  const owners = SCRIPTS.filter(p => p.startsWith("scripts/") && read(p).includes("GATE_RE"));
+  return owners.length === 1 && owners[0] === "scripts/lib/gates.mjs"
+    ? null
+    : "GATE_RE should exist only in scripts/lib/gates.mjs, found in: " + owners.join(", ");
+});
+
+check("no index-arithmetic argument filtering", () => {
+  // The v2.0 arg filter dropped index tIdx+1, which is 0 when --timeout is
+  // absent, silently discarding the first file argument.
+  return read("scripts/gate-check.mjs").includes("i !== tIdx + 1")
+    ? "gate-check.mjs still filters arguments by index arithmetic"
+    : null;
+});
+
+check("gate files are written atomically", () => {
+  const src = read("scripts/gate-check.mjs");
+  if (!src.includes("writeAtomic")) return "gate-check.mjs does not write via writeAtomic";
+  if (!src.includes("withFileLock")) return "gate-check.mjs does not take a lock before writing";
+  return null;
+});
+
+check("checks wait for close and cap output", () => {
+  const src = read("scripts/gate-check.mjs");
+  if (!src.includes('child.once("close"')) return "gate runner does not settle on stdio close";
+  if (src.includes('child.once("exit"')) return "gate runner settles on exit before stdio close";
+  if (!src.includes("MAX_OUTPUT_BYTES")) return "gate runner has no explicit output cap";
+  return null;
+});
+
+check("approval identity binds execution semantics", () => {
+  const src = read("scripts/gate-check.mjs");
+  const required = [
+    "check:", "expect:", "cwd", "shell", "timeoutMs", "maxOutputBytes",
+    "regexTimeoutMs", "regexStartupTimeoutMs", "maxRegexWorkers", "platform", "path:",
+  ];
+  const missing = required.filter(token => !src.includes(token));
+  return missing.length ? "approval oracle missing source tokens: " + missing.join(", ") : null;
+});
+
+check("every local resource the skill names exists", () => {
+  const skill = read("SKILL.md");
+  const missing = [];
+  const named = new Set();
+  for (const m of skill.matchAll(/`((?:references|templates|scripts)\/[^`\s]+|SECURITY\.md)`/g)) named.add(m[1]);
+  for (const path of named) {
+    try { read(path); } catch { missing.push(path); }
+  }
+  return missing.length ? "SKILL.md names missing local resources: " + missing.join(", ") : null;
+});
+
+check("all executable sources retain the Node 16 floor", () => {
+  const bad = SCRIPTS.filter(p => /Node 1[89]\+/.test(read(p)));
+  return bad.length ? "newer runtime claim in: " + bad.join(", ") : null;
+});
+
+check("the PLAN template carries a revisioned contract denominator", () => {
+  const plan = read("templates/PLAN.md");
+  const required = [
+    "Current contract inventory", "Contract revision", "Required outcome or constraint",
+    "Owner", "Observing gate or manual review", "Disposition", "REMOVED_BY_USER",
+  ];
+  const missing = required.filter((token) => !plan.includes(token));
+  return missing.length ? "PLAN contract inventory missing: " + missing.join(", ") : null;
+});
+
+check("request reconciliation keeps the focused solo cheap path", () => {
+  const skill = read("SKILL.md");
+  if (!skill.toLowerCase().includes("re-read the current request")) return "SKILL.md lacks final request reread";
+  if (!skill.includes("a PLAN table is not required")) return "focused solo path was made needlessly orchestrated";
+  if (!read("references/orchestration.md").includes("review every current contract row")) {
+    return "orchestration guide lacks final contract reconciliation";
+  }
+  return null;
+});
+
+check("abandonment is terminal handoff rather than ALL MET", () => {
+  const checker = read("scripts/gate-check.mjs");
+  if (!checker.includes("HANDOFF REQUIRED") || !checker.includes("totalAbandoned === 0")) {
+    return "gate checker can still classify abandonment as completion";
+  }
+  return null;
+});
+
+let passed = 0;
+const failures = [];
+for (const c of checks) {
+  let problem;
+  try { problem = c.fn(); } catch (e) { problem = e.message; }
+  if (problem) { failures.push(c.name + ": " + problem); console.log("FAIL " + c.name + "\n     " + problem); }
+  else { passed++; console.log("ok   " + c.name); }
+}
+
+console.log("");
+if (failures.length) {
+  console.log("self-check FAILED (" + passed + "/" + checks.length + ")");
+  process.exit(1);
+}
+console.log("self-check ok (" + passed + "/" + checks.length + ")");

package/dist/skills/unlazy/tests/stress-tests.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+// Concurrency and mutation stress tests. Zero dependencies. Node 16+.
+
+import {
+  existsSync, linkSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync,
+  symlinkSync, writeFileSync,
+} from "node:fs";
+import { execFile, spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { claimLeases, releaseLeases, writeAtomic } from "../scripts/lib/gates.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const GATE_CHECK = join(HERE, "..", "scripts", "gate-check.mjs");
+const tests = [];
+const test = (name, fn) => tests.push({ name, fn });
+
+function sandbox() {
+  const dir = mkdtempSync(join(tmpdir(), "unlazy-stress-"));
+  return {
+    dir,
+    path(rel) { return join(dir, rel); },
+    write(rel, value) {
+      const path = join(dir, rel);
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, value);
+      return path;
+    },
+    read(rel) { return readFileSync(join(dir, rel), "utf8"); },
+    cleanup() { rmSync(dir, { recursive: true, force: true }); },
+  };
+}
+
+function run(script, args, options = {}) {
+  return new Promise((done) => {
+    const child = execFile(process.execPath, [script, ...args], {
+      cwd: options.cwd,
+      encoding: "utf8",
+      maxBuffer: 8 * 1024 * 1024,
+      env: { ...process.env, ...(options.env || {}) },
+      timeout: options.timeoutMs,
+    }, (error, stdout, stderr) => {
+      done({ code: error ? (typeof error.code === "number" ? error.code : 1) : 0, out: (stdout || "") + (stderr || "") });
+    });
+    if (options.stdin !== undefined) child.stdin.end(options.stdin);
+  });
+}
+
+const assert = (condition, message) => { if (!condition) throw new Error(message); };
+const has = (text, value) => assert(text.includes(value), "missing " + JSON.stringify(value) + "\n" + text);
+
+test("leases: 200 simultaneous conflicting claim pairs never both succeed", async () => {
+  const s = sandbox();
+  try {
+    for (let iteration = 0; iteration < 200; iteration++) {
+      const [left, right] = await Promise.all([
+        claimLeases(s.dir, { scope: "left", leaf: "leaf-left", globs: ["src/shared/**"] }),
+        claimLeases(s.dir, { scope: "right", leaf: "leaf-right", globs: ["src/shared/file.js"] }),
+      ]);
+      const successes = Number(left.ok) + Number(right.ok);
+      assert(successes === 1, "iteration " + iteration + " had " + successes + " successful claims");
+      await Promise.all([
+        releaseLeases(s.dir, { scope: "left" }),
+        releaseLeases(s.dir, { scope: "right" }),
+      ]);
+    }
+  } finally { s.cleanup(); }
+});
+
+test("leases: the same scope and leaf cannot be claimed by two workers", async () => {
+  const s = sandbox();
+  try {
+    const [left, right] = await Promise.all([
+      claimLeases(s.dir, { scope: "same", leaf: "leaf", globs: ["src/shared/**"] }),
+      claimLeases(s.dir, { scope: "same", leaf: "leaf", globs: ["src/shared/**"] }),
+    ]);
+    assert(Number(left.ok) + Number(right.ok) === 1,
+      "duplicate logical owners both claimed one lease: " + JSON.stringify({ left, right }));
+    const loser = left.ok ? right : left;
+    assert(loser.conflicts.length === 1, "losing duplicate claim did not report its conflict");
+    assert(loser.conflicts[0].with === "same/leaf", "duplicate conflict named the wrong owner");
+    const released = await releaseLeases(s.dir, { scope: "same", leaf: "leaf" });
+    assert(released === 1, "expected one exclusive lease to release, got " + released);
+  } finally { s.cleanup(); }
+});
+
+test("leases: an explicit release cleans orphaned leases after a scope directory is gone", async () => {
+  const s = sandbox();
+  try {
+    const claimed = await claimLeases(s.dir, { scope: "gone", leaf: "leaf-gone", globs: ["src/gone/**"] });
+    assert(claimed.ok, "fixture lease was not created");
+    const result = await run(GATE_CHECK, ["--scope", "gone", "--leaf", "leaf-gone", "--release"], { cwd: s.dir });
+    assert(result.code === 0, result.out);
+    has(result.out, "released 1 lease(s) for gone/leaf-gone");
+    const lockNames = readdirSync(s.path(".unlazy/locks"));
+    assert(!lockNames.some((name) => name.endsWith(".lease")), "orphan lease remained: " + lockNames.join(", "));
+
+    s.write(".unlazy/live/gates/leaf-live.md", "# malformed zero-gate ledger\n");
+    const liveClaim = await claimLeases(s.dir, { scope: "live", leaf: "leaf-live", globs: ["src/live/**"] });
+    assert(liveClaim.ok, "live fixture lease was not created");
+    const liveRelease = await run(GATE_CHECK, ["--scope", "live", "--leaf", "leaf-live", "--release"], { cwd: s.dir });
+    assert(liveRelease.code === 0, "malformed live ledger blocked release\n" + liveRelease.out);
+    has(liveRelease.out, "released 1 lease(s) for live/leaf-live");
+  } finally { s.cleanup(); }
+});
+
+test("atomic writer: predictable pre-created temp links are never followed", async () => {
+  if (process.platform === "win32") return;
+  const s = sandbox();
+  try {
+    s.write("victim.txt", "safe\n");
+    const target = s.path("state.json");
+    symlinkSync(s.path("victim.txt"), target + "." + process.pid + ".tmp");
+    writeAtomic(target, "new\n");
+    assert(s.read("victim.txt") === "safe\n", "predictable temp symlink was followed");
+    assert(s.read("state.json") === "new\n", "target was not written");
+  } finally { s.cleanup(); }
+});
+
+test("status log: an existing symlink is refused without touching its target", async () => {
+  if (process.platform === "win32") return;
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/GATES.md", "# Gates\n\n- [ ] G1: pending\n  EVIDENCE: pending\n");
+    s.write("victim.txt", "safe\n");
+    symlinkSync(s.path("victim.txt"), s.path(".unlazy/api/status.log"));
+    const result = await run(GATE_CHECK, ["--scope", "api", "--log", "attacker-controlled append"], { cwd: s.dir });
+    assert(result.code === 2, "symlinked status log should fail closed\n" + result.out);
+    has(result.out, "cannot append status");
+    assert(s.read("victim.txt") === "safe\n", "status append followed the symlink");
+  } finally { s.cleanup(); }
+});
+
+test("status log: an existing hard link is refused without touching its sibling", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/GATES.md", "# Gates\n\n- [ ] G1: pending\n  EVIDENCE: pending\n");
+    s.write("victim.txt", "safe\n");
+    linkSync(s.path("victim.txt"), s.path(".unlazy/api/status.log"));
+    const result = await run(GATE_CHECK, ["--scope", "api", "--log", "attacker-controlled append"], { cwd: s.dir });
+    assert(result.code === 2, "hard-linked status log should fail closed\n" + result.out);
+    has(result.out, "cannot append status");
+    assert(s.read("victim.txt") === "safe\n", "status append followed the hard link");
+  } finally { s.cleanup(); }
+});
+
+test("status log: a FIFO is rejected without blocking the logger", async () => {
+  if (process.platform === "win32") return;
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/GATES.md", "# Gates\n\n- [ ] G1: pending\n  EVIDENCE: pending\n");
+    const fifo = s.path(".unlazy/api/status.log");
+    const made = spawnSync("mkfifo", [fifo], { encoding: "utf8" });
+    assert(made.status === 0, "could not create FIFO fixture: " + made.stderr);
+    const started = Date.now();
+    const result = await run(GATE_CHECK, ["--scope", "api", "--log", "must not block"], {
+      cwd: s.dir,
+      timeoutMs: 2000,
+    });
+    assert(result.code === 2, "FIFO logger did not fail closed\n" + result.out);
+    assert(Date.now() - started < 1800, "FIFO validation waited for the outer timeout");
+    has(result.out, "cannot append status");
+  } finally { s.cleanup(); }
+});

package/dist/skills/web-design-guidelines/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: web-design-guidelines
+category: design
+description: Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".
+license: MIT
+metadata:
+  author: vercel
+  version: "1.0.0"
+  argument-hint: <file-or-pattern>
+---
+
+# Web Interface Guidelines
+
+Review files for compliance with Web Interface Guidelines.
+
+## How It Works
+
+1. Fetch the latest guidelines from the source URL below
+2. Read the specified files (or prompt user for files/pattern)
+3. Check against all rules in the fetched guidelines
+4. Output findings in the terse `file:line` format
+
+## Guidelines Source
+
+Fetch fresh guidelines before each review:
+
+```
+https://raw.githubusercontent.com/vercel-labs/web-interface-guidelines/main/command.md
+```
+
+Use WebFetch to retrieve the latest rules. The fetched content contains all the rules and output format instructions.
+
+## Usage
+
+When a user provides a file or pattern argument:
+1. Fetch guidelines from the source URL above
+2. Read the specified files
+3. Apply all rules from the fetched guidelines
+4. Output findings using the format specified in the guidelines
+
+If no files specified, ask the user which files to review.

package/dist/skills/workflow/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: workflow
+category: orchestration
+description: Delegate user work to Selesai subagents. When invoked, decompose the request into subtasks, choose the right child agent for each subtask, and coordinate them with workflowScript. Use when the user asks to use a workflow, asks to orchestrate or delegate a task, or invokes the workflow skill.
+---
+
+# Workflow via subagents
+
+This is a parent-only orchestration policy over `pi-subagents`. When this skill is invoked, the parent's job is to delegate the user's request to subagents, not to perform the implementation itself. Read `../pi-subagents/SKILL.md` and the matching references before launching children. Use `workflowScript` for every coordinated launch. Do not inject or follow this skill inside child subagents.
+
+## Delegation policy
+
+- The parent owns classification, scope, decisions, synthesis, and final acceptance.
+- Whenever the workflow skill is active, solve the user's request by delegating subtasks to subagents. The parent is a coordinator and reviewer, not the primary implementer.
+- Decompose every non-trivial request into narrow subtasks before launch. Read-only subtasks (scout, research, plan, review, validation) are also delegated; do not keep them in the parent just because they are cheap.
+- Keep **one writer per checkout/worktree**. Parallelize only read-only subtasks; a single mutation-capable worker should own writes per lane.
+- Give each child a narrow role-specific task, source seam, constraints, acceptance evidence, and expected output. Never send clone prompts.
+
+## Choosing subagents
+
+Read `../pi-subagents/SKILL.md` and its references to pick builtin/custom agents. Common mapping:
+
+| Subtask | Agent |
+| --- | --- |
+| Codebase recon / find seams | `scout` |
+| External/uncertain research | `researcher` |
+| Scoped implementation | `worker` or `delegate` |
+| Independent review | `reviewer` |
+| Material architecture/product tradeoffs | `oracle` or Council Mode |
+
+For material architecture/product tradeoffs, resolve them first with an `oracle` or Council Mode before implementation.
+
+## Coordinating with workflowScript
+
+Use `workflowScript` with top-level `await`, `runs.run` for ordered stages, and `runs.all` for independent fanout. Keep async work background by default.
+
+### Single bounded task
+
+```js
+const worker = await runs.run("implement", {
+  agent: "worker",
+  task: "Implement the requested change. Return changed files, checks run, residual risks, and decisions needing approval."
+});
+return worker.outputReference;
+```
+
+### Uncertain task
+
+```js
+const scout = await runs.run("scout", {
+  agent: "scout",
+  task: "Find the code seams, existing helpers, and constraints involved. Do not edit."
+});
+const worker = await runs.run("implement", {
+  agent: "worker",
+  reads: [scout.outputReference],
+  task: "Implement the requested change from the scout findings. Return changed files, checks run, residual risks, decisions needing approval."
+});
+const reviews = await runs.all([
+  { key: "correctness", agent: "reviewer", reads: [scout.outputReference, worker.outputReference], task: "Inspect the current diff for correctness and regressions. Do not edit." },
+  { key: "simplicity", agent: "reviewer", reads: [scout.outputReference, worker.outputReference], task: "Inspect the current diff for unnecessary complexity. Do not edit." }
+]);
+return { worker: worker.outputReference, reviews: reviews.map((result) => result.outputReference) };
+```
+
+### Parallel independent subtasks
+
+Parallelize read-only discovery, research, and review with `runs.all`. If independent mutation subtasks need parallel execution, read the multi-lane guidance in `pi-subagents`, give each worker a managed `worktree: true`, and plan an explicit integration step. Otherwise serialize workers.
+
+```js
+const findings = await runs.all([
+  { key: "subtask-a-scout", agent: "scout", task: "Investigate subtask A. Do not edit." },
+  { key: "subtask-b-scout", agent: "scout", task: "Investigate subtask B. Do not edit." }
+]);
+const worker = await runs.run("implement", {
+  agent: "worker",
+  reads: findings.map((result) => result.outputReference),
+  task: "Implement the independent subtasks sequentially in this checkout, with focused checks."
+});
+return worker.outputReference;
+```
+
+## Review and fix
+
+The parent synthesizes review findings and sends one scoped fix worker. Do not launch an unbounded fix loop. Classify findings:
+
+- **blocking/actionable in approved scope** → synthesize and send one fix worker;
+- **optional, speculative, or scope-expanding** → defer or ask the user;
+- **decision needed** → stop and escalate to the user.
+
+Re-review only after a material fix. Default cap: two review rounds; use three only for risky work.
+
+## Final acceptance
+
+The parent inspects the final diff and validation evidence before reporting completion. Treat child completion, tests, and receipts as evidence—not authority to make product, architecture, merge, or release decisions.

package/dist/themes/adventure.json

@@ -0,0 +1,84 @@
+{
+  "$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "adventure",
+  "vars": {
+    "bg": "#040404",
+    "fg": "#feffff",
+    "gray": "#685655",
+    "darkGray": "#131313",
+    "accent": "#5da602",
+    "accentDark": "#2b7400",
+    "accentMid": "#add280",
+    "secondary": "#417ab3",
+    "white": "#e3d5c7",
+    "panel": "#090909",
+    "panelAlt": "#0c0c0c",
+    "panelSuccess": "#0c0e0e",
+    "panelError": "#16120f",
+    "panelInfo": "#0e0e0e",
+    "success": "#96d7ef",
+    "error": "#ffb56f",
+    "warning": "#98b52c",
+    "diffAdded": "#d6eff8",
+    "diffRemoved": "#fedfc2",
+    "diffContext": "#e3e0e0"
+  },
+  "colors": {
+    "accent": "accent",
+    "border": "gray",
+    "borderAccent": "accent",
+    "borderMuted": "darkGray",
+    "success": "success",
+    "error": "error",
+    "warning": "warning",
+    "muted": "gray",
+    "dim": "gray",
+    "text": "",
+    "thinkingText": "gray",
+    "selectedBg": "panelInfo",
+    "userMessageBg": "panel",
+    "userMessageText": "",
+    "customMessageBg": "panelAlt",
+    "customMessageText": "",
+    "customMessageLabel": "accent",
+    "toolPendingBg": "panelAlt",
+    "toolSuccessBg": "panelSuccess",
+    "toolErrorBg": "panelError",
+    "toolTitle": "white",
+    "toolOutput": "fg",
+    "mdHeading": "white",
+    "mdLink": "secondary",
+    "mdLinkUrl": "gray",
+    "mdCode": "accent",
+    "mdCodeBlock": "fg",
+    "mdCodeBlockBorder": "accentDark",
+    "mdQuote": "gray",
+    "mdQuoteBorder": "gray",
+    "mdHr": "darkGray",
+    "mdListBullet": "accent",
+    "toolDiffAdded": "diffAdded",
+    "toolDiffRemoved": "diffRemoved",
+    "toolDiffContext": "diffContext",
+    "syntaxComment": "gray",
+    "syntaxKeyword": "accent",
+    "syntaxFunction": "secondary",
+    "syntaxVariable": "fg",
+    "syntaxString": "success",
+    "syntaxNumber": "warning",
+    "syntaxType": "white",
+    "syntaxOperator": "error",
+    "syntaxPunctuation": "gray",
+    "thinkingOff": "darkGray",
+    "thinkingMinimal": "gray",
+    "thinkingLow": "accentDark",
+    "thinkingMedium": "accentMid",
+    "thinkingHigh": "accent",
+    "thinkingXhigh": "white",
+    "bashMode": "accent"
+  },
+  "export": {
+    "pageBg": "#040404",
+    "cardBg": "#090909",
+    "infoBg": "#0e0e0e"
+  }
+}

package/dist/themes/adwaita-dark.json

@@ -0,0 +1,84 @@
+{
+  "$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "adwaita-dark",
+  "vars": {
+    "bg": "#1c1c20",
+    "fg": "#ffffff",
+    "gray": "#5d5c64",
+    "darkGray": "#2b2b2f",
+    "accent": "#f5c211",
+    "accentDark": "#c39000",
+    "accentMid": "#fae088",
+    "secondary": "#09b9db",
+    "white": "#f5f5f4",
+    "panel": "#212125",
+    "panelAlt": "#242428",
+    "panelSuccess": "#212529",
+    "panelError": "#2c2227",
+    "panelInfo": "#26262a",
+    "success": "#09b9db",
+    "error": "#ec333b",
+    "warning": "#f5c211",
+    "diffAdded": "#a1e4f1",
+    "diffRemoved": "#f7a9ac",
+    "diffContext": "#e1e1e3"
+  },
+  "colors": {
+    "accent": "accent",
+    "border": "gray",
+    "borderAccent": "accent",
+    "borderMuted": "darkGray",
+    "success": "success",
+    "error": "error",
+    "warning": "warning",
+    "muted": "gray",
+    "dim": "gray",
+    "text": "",
+    "thinkingText": "gray",
+    "selectedBg": "panelInfo",
+    "userMessageBg": "panel",
+    "userMessageText": "",
+    "customMessageBg": "panelAlt",
+    "customMessageText": "",
+    "customMessageLabel": "accent",
+    "toolPendingBg": "panelAlt",
+    "toolSuccessBg": "panelSuccess",
+    "toolErrorBg": "panelError",
+    "toolTitle": "white",
+    "toolOutput": "fg",
+    "mdHeading": "white",
+    "mdLink": "secondary",
+    "mdLinkUrl": "gray",
+    "mdCode": "accent",
+    "mdCodeBlock": "fg",
+    "mdCodeBlockBorder": "accentDark",
+    "mdQuote": "gray",
+    "mdQuoteBorder": "gray",
+    "mdHr": "darkGray",
+    "mdListBullet": "accent",
+    "toolDiffAdded": "diffAdded",
+    "toolDiffRemoved": "diffRemoved",
+    "toolDiffContext": "diffContext",
+    "syntaxComment": "gray",
+    "syntaxKeyword": "accent",
+    "syntaxFunction": "secondary",
+    "syntaxVariable": "fg",
+    "syntaxString": "success",
+    "syntaxNumber": "warning",
+    "syntaxType": "white",
+    "syntaxOperator": "error",
+    "syntaxPunctuation": "gray",
+    "thinkingOff": "darkGray",
+    "thinkingMinimal": "gray",
+    "thinkingLow": "accentDark",
+    "thinkingMedium": "accentMid",
+    "thinkingHigh": "accent",
+    "thinkingXhigh": "white",
+    "bashMode": "accent"
+  },
+  "export": {
+    "pageBg": "#1c1c20",
+    "cardBg": "#212125",
+    "infoBg": "#26262a"
+  }
+}