@a-t-h-i/bot-lobby 0.6.47 → 0.6.49

package/src/lobby/session-questions.ts

@@ -0,0 +1,49 @@
+/**
+ * A background session's questions, asked wherever the user is. A session
+ * started "in a new session" runs headless, so every question it asks (its
+ * oracle's questionnaire, a pick, a line of text, a yes/no) reaches this
+ * window as an RPC dialog. Each one is put in this window's question queue,
+ * the same pop-up the user's own session asks in, named after the session it
+ * comes from, so nobody has to switch sessions to answer. The answer goes
+ * back to the session; a dialog answered some other way (or a session that
+ * ends) takes its question back out of the queue.
+ */
+import { readRelayRequest } from "../ask/relay.ts";
+import { readResult } from "../ask/web.ts";
+import { promptHub, type PromptHub } from "./prompt-hub.ts";
+import type { DialogAnswer, SessionDialog } from "./sessions.ts";
+
+export interface SessionQuestion {
+  /** The session's name, shown as who asks. */
+  from: string;
+  dialog: SessionDialog;
+  signal: AbortSignal;
+}
+
+/** Put a session's dialog to the user in the question pop-up; undefined when it was taken back first. */
+export async function askForSession({ from, dialog, signal }: SessionQuestion, hub: PromptHub = promptHub): Promise<DialogAnswer | undefined> {
+  const options = { signal };
+  const relayed = dialog.method === "editor" ? readRelayRequest(dialog.title, dialog.prefill) : undefined;
+  if (relayed) {
+    const outcome = await hub.ask("questionnaire", from, { questions: relayed }, options);
+    if (outcome.how === "cancelled") return undefined;
+    const result = outcome.how === "answered" ? readResult(outcome.value) : undefined;
+    return { value: JSON.stringify(result ?? { answers: [], cancelled: true }) };
+  }
+  if (dialog.method === "select") {
+    const outcome = await hub.ask("choose", from, { title: dialog.title, options: dialog.options ?? [] }, options);
+    return settled(outcome, (value) => (typeof value === "string" ? { value } : undefined));
+  }
+  if (dialog.method === "confirm") {
+    const outcome = await hub.ask("confirm", from, { question: dialog.title, ...(dialog.message ? { detail: dialog.message } : {}) }, options);
+    return settled(outcome, (value) => (typeof value === "boolean" ? { confirmed: value } : undefined));
+  }
+  const outcome = await hub.ask("text", from, { question: dialog.title, ...(dialog.placeholder ? { placeholder: dialog.placeholder } : {}) }, options);
+  return settled(outcome, (value) => (typeof value === "string" ? { value } : undefined));
+}
+
+function settled(outcome: { how: "answered" | "dismissed" | "cancelled"; value: unknown }, read: (value: unknown) => DialogAnswer | undefined): DialogAnswer | undefined {
+  if (outcome.how === "cancelled") return undefined;
+  if (outcome.how === "dismissed") return { cancelled: true };
+  return read(outcome.value) ?? { cancelled: true };
+}

package/src/lobby/sessions.ts

@@ -54,6 +54,11 @@ export interface SessionStart {
   message?: string;
   /** The task it was started to carry on (resumed from the Tasks screen). */
   taskId?: string;
+  /**
+   * Put a dialog to the user (this window's question pop-up); resolves with the answer, or undefined when the
+   * dialog was settled some other way first (`signal` aborts then).
+   */
+  ask?: (question: { from: string; dialog: SessionDialog; signal: AbortSignal }) => Promise<DialogAnswer | undefined>;
 }
 
 let counter = 0;
@@ -80,6 +85,9 @@ export class BackgroundSession {
   /** Dialogs the session waits on, oldest first. */
   readonly dialogs: SessionDialog[] = [];
   private readonly onDialog: NonNullable<SessionStart["onDialog"]>;
+  private readonly ask?: SessionStart["ask"];
+  /** The dialogs being asked in the question pop-up, to take back when they are settled another way. */
+  private readonly asking = new Map<string, AbortController>();
   private readonly proc: SessionProcess;
   private buffer = "";
   private stderr = "";
@@ -96,6 +104,7 @@ export class BackgroundSession {
     if (start.planId) this.planId = start.planId;
     if (start.taskId) this.taskId = start.taskId;
     this.onDialog = start.onDialog ?? (() => {});
+    if (start.ask) this.ask = start.ask;
     this.proc = proc;
     this.onChange = onChange;
     proc.stdout?.on("data", (chunk) => this.receive(String(chunk)));
@@ -121,6 +130,8 @@ export class BackgroundSession {
     this.exitCode = code;
     for (const dialog of this.dialogs) this.onDialog(dialog.id, false, this.sessionId);
     this.dialogs.length = 0;
+    for (const controller of this.asking.values()) controller.abort();
+    this.asking.clear();
     if (this.killTimer) clearTimeout(this.killTimer);
     this.feed.say("note", reason);
     for (const resolve of this.exitWaiters.splice(0)) resolve();
@@ -175,6 +186,8 @@ export class BackgroundSession {
     const index = this.dialogs.findIndex((dialog) => dialog.id === id);
     if (index < 0) return;
     this.dialogs.splice(index, 1);
+    this.asking.get(id)?.abort();
+    this.asking.delete(id);
     this.onDialog(id, false, this.sessionId);
     if (this.alive && this.proc.stdin) this.proc.stdin.write(`${JSON.stringify({ type: "extension_ui_response", id, ...answer })}\n`);
     this.onChange();
@@ -248,6 +261,21 @@ export class BackgroundSession {
     this.onChange();
   }
 
+  /** Ask the dialog in the question pop-up, wherever the user is; its answer goes back to the session. */
+  private putToUser(dialog: SessionDialog): void {
+    if (!this.ask) return;
+    const controller = new AbortController();
+    this.asking.set(dialog.id, controller);
+    this.ask({ from: this.name, dialog, signal: controller.signal }).then(
+      (answer) => {
+        if (this.asking.get(dialog.id) !== controller) return;
+        this.asking.delete(dialog.id);
+        if (answer) this.answer(dialog.id, answer);
+      },
+      () => this.asking.delete(dialog.id),
+    );
+  }
+
   private uiRequest(event: Record<string, unknown>): void {
     const id = String(event.id ?? "");
     const method = String(event.method ?? "");
@@ -262,6 +290,7 @@ export class BackgroundSession {
         ...(typeof event.prefill === "string" ? { prefill: event.prefill } : {}),
       });
       this.onDialog(id, true, this.sessionId);
+      this.putToUser(this.dialogs.at(-1)!);
       this.feed.log("LOBBY", `waiting for you: ${String(event.title ?? "a question").split("\n")[0]}`, "warning");
     } else if (method === "notify") {
       const level = event.notifyType === "error" ? "error" : event.notifyType === "warning" ? "warning" : "info";
@@ -299,6 +328,8 @@ export const launchPi = (args: string[], cwd: string, overrides: NodeJS.ProcessE
   const env: NodeJS.ProcessEnv = { ...process.env, PI_SKIP_VERSION_CHECK: "1" };
   delete env.BOT_LOBBY_SUBAGENT;
   delete env.BOT_LOBBY_WEB_PROJECT;
+  // It has no page of its own: its questions come to this window (see ask/web.ts).
+  env.BOT_LOBBY_BACKGROUND = "1";
   Object.assign(env, overrides);
   const proc: ChildProcess = spawn(invocation.command, invocation.args, { cwd, env, shell: false, detached: POSIX, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
   return proc as unknown as SessionProcess;

package/src/master/master.ts

@@ -60,7 +60,7 @@ export interface ScoutRequest {
 /** Model, thinking and time limit for one run, from settings. */
 function profileFields(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: AgentRequest["role"]) {
   const profile = profileFor(config, resolver, domain, role);
-  return { model: profile.model, mcpTools: profile.mcpTools, thinking: profile.thinking, timeoutMs: profile.timeoutMs, time: boundedAgentTime(profile.timeoutMs) };
+  return { model: profile.model, mcpTools: profile.mcpTools, ...(profile.autoCompact === false ? { autoCompact: false } : {}), thinking: profile.thinking, timeoutMs: profile.timeoutMs, time: boundedAgentTime(profile.timeoutMs) };
 }
 
 function scoutInstruction(request: ScoutRequest, domain: Domain): string {

package/src/master/research.ts

@@ -71,6 +71,7 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       context: researchContext(request),
       model: profile.model,
       mcpTools: profile.mcpTools,
+      ...(profile.autoCompact === false ? { autoCompact: false } : {}),
       thinking: profile.thinking,
       timeoutMs: profile.timeoutMs,
       ...(request.time ? { time: request.time } : {}),

package/src/pi/auto-compaction.ts

@@ -1,6 +1,31 @@
-import { compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, type ExtensionAPI, type TurnEndEvent } from "@earendil-works/pi-coding-agent";
+import { compact, CONFIG_DIR_NAME, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, type ExtensionAPI, type ExtensionContext, type TurnEndEvent } from "@earendil-works/pi-coding-agent";
 import { contextMarks, freshContextOn } from "./fresh-context.ts";
-import { isSubagentProcess } from "./quiet.ts";
+import { AUTO_COMPACT_ENV, isSubagentProcess } from "./quiet.ts";
+import { dataRoot, detectProjectRoot, loadConfig } from "../state/project.ts";
+import { describeShared, DIGEST_INSTRUCTION, parseDigest, shareDigest, type DigestItem } from "../knowledge/oracle-digest.ts";
+
+const CHECKPOINT = "Write a concise checkpoint with: Requirements and constraints; Decisions; Files changed; Verification and evidence; Failed approaches (do not repeat); Unfinished work and next action; Outstanding children and their assignments. Preserve concrete file references and distinguish verified facts from guesses. The parent remains responsible for integration and verification.";
+
+export interface AutoCompactionOptions {
+  /** Whether this agent compacts on its own: a subagent by its environment, the oracle by its settings. */
+  enabled?: () => boolean;
+  /** Where the oracle's shared knowledge goes; by default the project's knowledge files. */
+  share?: (items: DigestItem[], ctx: ExtensionContext) => string;
+}
+
+function enabledBySettings(): boolean {
+  if (isSubagentProcess()) return process.env[AUTO_COMPACT_ENV] !== "0";
+  try {
+    return loadConfig().master.autoCompact !== false;
+  } catch {
+    return true;
+  }
+}
+
+function shareWithAgents(items: DigestItem[], ctx: ExtensionContext): string {
+  const root = detectProjectRoot(ctx.cwd, CONFIG_DIR_NAME);
+  return describeShared(shareDigest(dataRoot(root, CONFIG_DIR_NAME), items));
+}
 
 export const CONTEXT_TARGET = 64_000;
 
@@ -8,13 +33,20 @@ export function compactionThreshold(window: number, reserve = DEFAULT_COMPACTION
   return Math.max(1, Math.min(CONTEXT_TARGET, Math.floor(window * 0.6), window - Math.min(reserve, Math.floor(window / 2))));
 }
 
-/** Compact at a settled tool boundary; ctx.compact() would abort the turn we need to continue. */
-export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compact = compact): void {
+/**
+ * Compact at a settled tool boundary; ctx.compact() would abort the turn we need to continue. Each agent's settings
+ * can turn it off. The oracle's checkpoint also lists what it learned that is worth keeping, tagged by agent, and
+ * that goes into the knowledge base: its own, and the designer's, backend's and QA's where it concerns them.
+ */
+export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compact = compact, options: AutoCompactionOptions = {}): void {
+  const enabled = options.enabled ?? enabledBySettings;
+  const share = options.share ?? shareWithAgents;
+  const oracle = !isSubagentProcess();
   let busy = false;
   let lastLeaf: string | null | undefined;
   pi.on("session_start", () => { busy = false; lastLeaf = undefined; });
   pi.on("turn_end", async (event: TurnEndEvent, ctx) => {
-    if (busy || !ctx.model) return;
+    if (busy || !ctx.model || !enabled()) return;
     const leaf = ctx.sessionManager.getLeafId();
     if (leaf === lastLeaf) return;
     const configured = pi.getSettings().compaction;
@@ -61,9 +93,18 @@ export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compa
       const headers = auth.headers ? Object.fromEntries(Object.entries(auth.headers).filter((entry): entry is [string, string] => entry[1] !== null)) : undefined;
       const retry = pi.getSettings().retry;
       const retryPolicy = { enabled: retry?.enabled ?? true, maxRetries: retry?.maxRetries ?? 3, baseDelayMs: retry?.baseDelayMs ?? 2_000, maxAgentDelayMs: retry?.maxAgentDelayMs };
-      const result = await summarize({ firstKeptEntryId, messagesToSummarize: messages, turnPrefixMessages: [], isSplitTurn: false, tokensBefore: estimate, previousSummary: previous?.type === "compaction" ? previous.summary : undefined, fileOps, settings: { enabled: true, reserveTokens: reserve, keepRecentTokens } }, auth.baseUrl ? { ...ctx.model, baseUrl: auth.baseUrl } : ctx.model, auth.apiKey, headers, "Write a concise checkpoint with: Requirements and constraints; Decisions; Files changed; Verification and evidence; Failed approaches (do not repeat); Unfinished work and next action; Outstanding children and their assignments. Preserve concrete file references and distinguish verified facts from guesses. The parent remains responsible for integration and verification.", ctx.signal, undefined, undefined, auth.env, retryPolicy);
+      const result = await summarize({ firstKeptEntryId, messagesToSummarize: messages, turnPrefixMessages: [], isSplitTurn: false, tokensBefore: estimate, previousSummary: previous?.type === "compaction" ? previous.summary : undefined, fileOps, settings: { enabled: true, reserveTokens: reserve, keepRecentTokens } }, auth.baseUrl ? { ...ctx.model, baseUrl: auth.baseUrl } : ctx.model, auth.apiKey, headers, oracle ? `${CHECKPOINT} ${DIGEST_INSTRUCTION}` : CHECKPOINT, ctx.signal, undefined, undefined, auth.env, retryPolicy);
       ctx.signal?.throwIfAborted();
       ctx.ui.notify("Agent context compacted", "info");
+      if (oracle) {
+        try {
+          const items = parseDigest(result.summary);
+          const shared = items.length ? share(items, ctx) : "";
+          if (shared) ctx.ui.notify(`Knowledge updated: ${shared}`, "info");
+        } catch (error) {
+          ctx.ui.notify(`Could not update knowledge: ${(error as Error).message}`, "warning");
+        }
+      }
       return { entries: [...event.entries, { type: "compaction" as const, summary: result.summary, firstKeptEntryId, usage: result.usage, details: result.details }] };
     } catch (error) {
       ctx.ui.notify(`Context compaction failed: ${(error as Error).message}`, "warning");

package/src/pi/quiet.ts

@@ -58,6 +58,9 @@ export function webToolsFor(active: string[], taskActive: boolean, hidden: reado
   return { active: [...active, ...back], hidden: [] };
 }
 
+/** Set to "0" in a subagent's environment when its settings turn auto-compaction off. */
+export const AUTO_COMPACT_ENV = "BOT_LOBBY_AUTO_COMPACT";
+
 /** True inside a bot-lobby subagent process (marked in `spawnPiProcess`). */
 export function isSubagentProcess(): boolean {
   return process.env.BOT_LOBBY_SUBAGENT === "1";

package/src/pi/tools.ts

@@ -132,8 +132,8 @@ export function workflowDeps(
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
     // Time spent waiting on the user is not the task's: its budget clock waits too.
     // The questions go to the web page, where a free-text answer may run to several lines.
-    ask: async (question) => (canAsk() ? whileAsking(() => askText(question)) : undefined),
-    choose: async (title, options) => (canAsk() ? whileAsking(() => askChoice(title, options)) : undefined),
+    ask: async (question) => (canAsk() ? whileAsking(() => askText(question, undefined, ctx)) : undefined),
+    choose: async (title, options) => (canAsk() ? whileAsking(() => askChoice(title, options, undefined, ctx)) : undefined),
     // An agent's own questions (the designer's), relayed as the questionnaire.
     ...(canAsk() ? { askQuestions: (questions: AskQuestion[], from: string, askSignal?: AbortSignal) => whileAsking(() => askUser(questions, ctx, askSignal, from)) } : {}),
     notify: (message, level = "info") => {

package/src/schemas/configuration.ts

@@ -31,6 +31,8 @@ export interface AgentModelConfig {
   mcpTools?: string[];
   /** Time limit per run; falls back to `workflow.agentTimeoutMs`. */
   timeoutMs?: number;
+  /** Compact this agent's context on its own as it fills (on unless false); the oracle's also updates the knowledge base. */
+  autoCompact?: boolean;
 }
 
 /** Scouts pick a model and a time limit only; their thinking is fixed at `SCOUT_THINKING`. */
@@ -40,6 +42,8 @@ export interface ScoutConfig {
   timeoutMs: number;
   /** Tool calls a scout may make: it is told to wrap up at 60% and refused more past this, so it reports with what it has; 0 = no limit. */
   maxToolCalls: number;
+  /** Compact a scout's context on its own as it fills (on unless false). */
+  autoCompact?: boolean;
 }
 
 /** Subagent kinds with their own settings entry. */
@@ -351,7 +355,7 @@ function normalizeAgent(base: AgentModelConfig, override: Partial<AgentModelConf
   const thinking = isThinkingLevel(merged.thinking) ? merged.thinking : base.thinking;
   const timeoutMs = positive(merged.timeoutMs) ?? base.timeoutMs;
   const mcpTools = normalizeMcpTools(merged.mcpTools);
-  return { model: merged.model, thinking, ...(mcpTools.length ? { mcpTools } : {}), ...(typeof merged.instructions === "string" ? { instructions: merged.instructions } : {}), ...(timeoutMs ? { timeoutMs } : {}) };
+  return { model: merged.model, thinking, ...(mcpTools.length ? { mcpTools } : {}), ...(typeof merged.instructions === "string" ? { instructions: merged.instructions } : {}), ...(timeoutMs ? { timeoutMs } : {}), ...(merged.autoCompact === false ? { autoCompact: false } : {}) };
 }
 
 /** Scouts keep a model and a time limit; any thinking value in the file is dropped. */
@@ -363,6 +367,7 @@ function normalizeScout(override: Partial<ScoutConfig> | undefined): ScoutConfig
     timeoutMs: positive(override?.timeoutMs) ?? base.timeoutMs,
     maxToolCalls: typeof override?.maxToolCalls === "number" && Number.isFinite(override.maxToolCalls) && override.maxToolCalls >= 0 ? Math.round(override.maxToolCalls) : base.maxToolCalls,
     ...(mcpTools.length ? { mcpTools } : {}),
+    ...(override?.autoCompact === false ? { autoCompact: false } : {}),
   };
 }
 
@@ -513,6 +518,13 @@ export interface AgentProfile {
   instructions?: string;
   /** Exact native MCP tool names this profile may call; empty grants none. */
   mcpTools?: string[];
+  /** False when its settings turn auto-compaction off. */
+  autoCompact?: boolean;
+}
+
+/** `{ autoCompact: false }` when an entry turns auto-compaction off, else nothing. */
+function compactField(entry: { autoCompact?: boolean }): { autoCompact?: false } {
+  return entry.autoCompact === false ? { autoCompact: false } : {};
 }
 
 /** The settings entry a domain/role run draws from. */
@@ -537,10 +549,10 @@ export function agentProfile(config: BotLobbyConfig, domain: Domain, role: Role)
   const instructions = config.agents[domain].instructions;
   const fallback = config.workflow.agentTimeoutMs;
   if (kind === "scout") {
-    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions, ...(config.scout.mcpTools?.length ? { mcpTools: config.scout.mcpTools } : {}) };
+    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions, ...(config.scout.mcpTools?.length ? { mcpTools: config.scout.mcpTools } : {}), ...compactField(config.scout) };
   }
   const entry = kind === "researcher" ? config.researcher : config.agents[kind];
-  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}) };
+  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
 }
 
 /** The settings entry of a lobby agent (quick fix or planner). */
@@ -549,19 +561,19 @@ export function lobbyAgentConfig(config: BotLobbyConfig, kind: LobbyAgentKind):
 }
 
 /** Profile for a lobby agent run, from settings alone; `model` is undefined while unset. */
-export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[] } {
+export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[]; autoCompact?: boolean } {
   const entry = lobbyAgentConfig(config, kind);
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}) };
+  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
 }
 
 /**
  * A planning panel seat's profile: the domain's (or the researcher's) model,
  * thinking and custom instructions, bounded by the planner's per-turn limit.
  */
-export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[] } {
+export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[]; autoCompact?: boolean } {
   const entry = member === "researcher" ? config.researcher : config.agents[member];
   const timeoutMs = config.planner.timeoutMs ?? config.workflow.agentTimeoutMs;
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}) };
+  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
 }
 
 /** Resolves the model, thinking and time limit one subagent run uses. */

package/src/webui/palette-core.ts

@@ -178,7 +178,8 @@ export const DEFAULT_ID = "mist"
  * T3 Tools Inc., packages/shared/src/themePalettes.ts), their roles mapped onto
  * the shadcn variables: canvas is the background, surface the card, accent the
  * primary, accent surface the accent, error the destructive colour. Slate,
- * Sand, Rosewood, Aurora and Midnight are original complementary palettes.
+ * Sand, Rosewood, Aurora and Midnight, and Graphite, Lagoon, Dune, Plum, Moss and Crimson, are original
+ * complementary palettes.
  */
 export const PRESETS: readonly Palette[] = [
   { id: DEFAULT_ID, name: "Default" },
@@ -642,6 +643,282 @@ export const PRESETS: readonly Palette[] = [
       "chart-1": "#acbbed",
     },
   },
+  {
+    id: "graphite",
+    name: "Graphite",
+    light: {
+      "background": "#fafafa",
+      "foreground": "#222222",
+      "card": "#fefefe",
+      "card-foreground": "#222222",
+      "popover": "#fefefe",
+      "popover-foreground": "#222222",
+      "primary": "#333333",
+      "primary-foreground": "#fcfcfc",
+      "secondary": "#ebebeb",
+      "secondary-foreground": "#222222",
+      "muted": "#f0f0f0",
+      "muted-foreground": "#5d5d5d",
+      "accent": "#e8e8e8",
+      "accent-foreground": "#222222",
+      "destructive": "#d02b31",
+      "border": "#dedede",
+      "input": "#cecece",
+      "ring": "#333333",
+      "chart-1": "#333333",
+    },
+    dark: {
+      "background": "#121212",
+      "foreground": "#eeeeee",
+      "card": "#191919",
+      "card-foreground": "#eeeeee",
+      "popover": "#202020",
+      "popover-foreground": "#eeeeee",
+      "primary": "#e4e4e4",
+      "primary-foreground": "#121212",
+      "secondary": "#292929",
+      "secondary-foreground": "#eeeeee",
+      "muted": "#242424",
+      "muted-foreground": "#ababab",
+      "accent": "#333333",
+      "accent-foreground": "#eeeeee",
+      "destructive": "#f66c6d",
+      "border": "#333333",
+      "input": "#424242",
+      "ring": "#e4e4e4",
+      "chart-1": "#e4e4e4",
+    },
+  },
+  {
+    id: "lagoon",
+    name: "Lagoon",
+    light: {
+      "background": "#f3fcfd",
+      "foreground": "#0e2627",
+      "card": "#fbffff",
+      "card-foreground": "#0e2627",
+      "popover": "#fbffff",
+      "popover-foreground": "#0e2627",
+      "primary": "#007780",
+      "primary-foreground": "#fcfcfc",
+      "secondary": "#d5f2f3",
+      "secondary-foreground": "#0e2627",
+      "muted": "#e3f4f5",
+      "muted-foreground": "#456466",
+      "accent": "#c3f2f4",
+      "accent-foreground": "#0e2627",
+      "destructive": "#d02b31",
+      "border": "#cde3e4",
+      "input": "#b8d4d5",
+      "ring": "#007780",
+      "chart-1": "#007780",
+    },
+    dark: {
+      "background": "#041516",
+      "foreground": "#e8f1f1",
+      "card": "#091d1e",
+      "card-foreground": "#e8f1f1",
+      "popover": "#102425",
+      "popover-foreground": "#e8f1f1",
+      "primary": "#53c5cb",
+      "primary-foreground": "#041516",
+      "secondary": "#162d2f",
+      "secondary-foreground": "#e8f1f1",
+      "muted": "#152829",
+      "muted-foreground": "#9cafb0",
+      "accent": "#0c3a3c",
+      "accent-foreground": "#e8f1f1",
+      "destructive": "#f66c6d",
+      "border": "#203839",
+      "input": "#2f4749",
+      "ring": "#53c5cb",
+      "chart-1": "#53c5cb",
+    },
+  },
+  {
+    id: "dune",
+    name: "Dune",
+    light: {
+      "background": "#fef9f3",
+      "foreground": "#2b1f11",
+      "card": "#fffefb",
+      "card-foreground": "#2b1f11",
+      "popover": "#fffefb",
+      "popover-foreground": "#2b1f11",
+      "primary": "#9d6300",
+      "primary-foreground": "#fcfcfc",
+      "secondary": "#f9e8d6",
+      "secondary-foreground": "#2b1f11",
+      "muted": "#f8eee4",
+      "muted-foreground": "#6b5a48",
+      "accent": "#fde3c6",
+      "accent-foreground": "#2b1f11",
+      "destructive": "#d02b31",
+      "border": "#e9dccd",
+      "input": "#dbcbb9",
+      "ring": "#9d6300",
+      "chart-1": "#9d6300",
+    },
+    dark: {
+      "background": "#181006",
+      "foreground": "#f3ede8",
+      "card": "#21170c",
+      "card-foreground": "#f3ede8",
+      "popover": "#291e12",
+      "popover-foreground": "#f3ede8",
+      "primary": "#dba666",
+      "primary-foreground": "#181006",
+      "secondary": "#322618",
+      "secondary-foreground": "#f3ede8",
+      "muted": "#2c2217",
+      "muted-foreground": "#b4a99d",
+      "accent": "#422e16",
+      "accent-foreground": "#f3ede8",
+      "destructive": "#f66c6d",
+      "border": "#3d3022",
+      "input": "#4d4031",
+      "ring": "#dba666",
+      "chart-1": "#dba666",
+    },
+  },
+  {
+    id: "plum",
+    name: "Plum",
+    light: {
+      "background": "#fef8ff",
+      "foreground": "#291c2c",
+      "card": "#fffdff",
+      "card-foreground": "#291c2c",
+      "popover": "#fffdff",
+      "popover-foreground": "#291c2c",
+      "primary": "#9553a4",
+      "primary-foreground": "#fcfcfc",
+      "secondary": "#f6e4fa",
+      "secondary-foreground": "#291c2c",
+      "muted": "#f7ecf9",
+      "muted-foreground": "#68566d",
+      "accent": "#f9dcff",
+      "accent-foreground": "#291c2c",
+      "destructive": "#d02b31",
+      "border": "#e7d8ea",
+      "input": "#d8c7dc",
+      "ring": "#9553a4",
+      "chart-1": "#9553a4",
+    },
+    dark: {
+      "background": "#170d19",
+      "foreground": "#f2ecf3",
+      "card": "#201522",
+      "card-foreground": "#f2ecf3",
+      "popover": "#271c2a",
+      "popover-foreground": "#f2ecf3",
+      "primary": "#d398e0",
+      "primary-foreground": "#170d19",
+      "secondary": "#312334",
+      "secondary-foreground": "#f2ecf3",
+      "muted": "#2a202d",
+      "muted-foreground": "#b2a6b5",
+      "accent": "#3f2945",
+      "accent-foreground": "#f2ecf3",
+      "destructive": "#f66c6d",
+      "border": "#3b2d3e",
+      "input": "#4b3c4e",
+      "ring": "#d398e0",
+      "chart-1": "#d398e0",
+    },
+  },
+  {
+    id: "moss",
+    name: "Moss",
+    light: {
+      "background": "#f8fcf6",
+      "foreground": "#1c2517",
+      "card": "#fdfffc",
+      "card-foreground": "#1c2517",
+      "popover": "#fdfffc",
+      "popover-foreground": "#1c2517",
+      "primary": "#4a7333",
+      "primary-foreground": "#fcfcfc",
+      "secondary": "#e3f0dd",
+      "secondary-foreground": "#1c2517",
+      "muted": "#ebf3e8",
+      "muted-foreground": "#56624f",
+      "accent": "#dcefd2",
+      "accent-foreground": "#1c2517",
+      "destructive": "#d02b31",
+      "border": "#d8e2d3",
+      "input": "#c6d2c0",
+      "ring": "#4a7333",
+      "chart-1": "#4a7333",
+    },
+    dark: {
+      "background": "#0d140a",
+      "foreground": "#ecf0ea",
+      "card": "#151c11",
+      "card-foreground": "#ecf0ea",
+      "popover": "#1b2317",
+      "popover-foreground": "#ecf0ea",
+      "primary": "#97bf82",
+      "primary-foreground": "#0d140a",
+      "secondary": "#232c1e",
+      "secondary-foreground": "#ecf0ea",
+      "muted": "#1f271c",
+      "muted-foreground": "#a6aea1",
+      "accent": "#293821",
+      "accent-foreground": "#ecf0ea",
+      "destructive": "#f66c6d",
+      "border": "#2d3628",
+      "input": "#3c4637",
+      "ring": "#97bf82",
+      "chart-1": "#97bf82",
+    },
+  },
+  {
+    id: "crimson",
+    name: "Crimson",
+    light: {
+      "background": "#fff7f6",
+      "foreground": "#331919",
+      "card": "#fffcfc",
+      "card-foreground": "#331919",
+      "popover": "#fffcfc",
+      "popover-foreground": "#331919",
+      "primary": "#c13a46",
+      "primary-foreground": "#fcfcfc",
+      "secondary": "#ffe1df",
+      "secondary-foreground": "#331919",
+      "muted": "#ffeae9",
+      "muted-foreground": "#785252",
+      "accent": "#ffd7d5",
+      "accent-foreground": "#331919",
+      "destructive": "#d02b31",
+      "border": "#f4d6d5",
+      "input": "#e9c3c2",
+      "ring": "#c13a46",
+      "chart-1": "#c13a46",
+    },
+    dark: {
+      "background": "#1e0b0b",
+      "foreground": "#f8ebeb",
+      "card": "#281212",
+      "card-foreground": "#f8ebeb",
+      "popover": "#301919",
+      "popover-foreground": "#f8ebeb",
+      "primary": "#ff898b",
+      "primary-foreground": "#1e0b0b",
+      "secondary": "#3b2020",
+      "secondary-foreground": "#f8ebeb",
+      "muted": "#331d1d",
+      "muted-foreground": "#bea4a3",
+      "accent": "#502324",
+      "accent-foreground": "#f8ebeb",
+      "destructive": "#f66c6d",
+      "border": "#462a2a",
+      "input": "#573939",
+      "ring": "#ff898b",
+      "chart-1": "#ff898b",
+    },
+  },
 ]
 
 /** Colours for a preview swatch, per mode: the default's own values by hand, the rest from the theme. */