@a-t-h-i/bot-lobby 0.6.45 → 0.6.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.45",
+  "version": "0.6.46",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/execution/task-cancellation.ts

@@ -0,0 +1,27 @@
+import { resolve } from "node:path";
+
+const executions = new Map<string, Set<AbortController>>();
+const key = (root: string, configDir: string, taskId: string) => JSON.stringify([resolve(root), configDir, taskId]);
+
+/** Scope an orchestration action and its workers/children to one project task. */
+export function taskExecution(root: string, configDir: string, taskId: string, parent?: AbortSignal) {
+  const id = key(root, configDir, taskId);
+  const controller = new AbortController();
+  const running = executions.get(id) ?? new Set<AbortController>();
+  running.add(controller);
+  executions.set(id, running);
+  return {
+    signal: parent ? AbortSignal.any([parent, controller.signal]) : controller.signal,
+    release: () => {
+      running.delete(controller);
+      if (!running.size) executions.delete(id);
+    },
+  };
+}
+
+/** Abort only this task's orchestration and the subprocesses inheriting its signal. */
+export function cancelTaskExecutions(root: string, configDir: string, taskId: string): void {
+  for (const controller of executions.get(key(root, configDir, taskId)) ?? []) {
+    controller.abort(new Error("Task abandoned by the user"));
+  }
+}

package/src/lobby/host.ts

@@ -173,6 +173,10 @@ export interface LobbyService {
    * background session. A notice, and the background session's key.
    */
   resumeTask?(taskId: string): Promise<{ notice: string; key?: string }>;
+  acceptTask?(taskId: string): Promise<{ notice: string }>;
+  forceCloseTask?(taskId: string, title: string): Promise<{ notice: string }>;
+  canForceCloseTask?(taskId: string): boolean;
+  resolveTaskApproval?(taskId: string, approvalId: string, decision: "approved" | "rejected", note?: string): Promise<{ notice: string }>;
   /** Leave a message for a session running in another terminal; it delivers it within seconds. Returns a notice. */
   sendToSession(sessionId: string, text: string): string;
   /** Sessions running in this project, other than this window's, from their heartbeats. */

package/src/lobby/prompts.ts

@@ -4,7 +4,7 @@
  * `node:*`): the web page imports this file directly.
  */
 
-export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "git", "knowledge", "metrics"] as const;
+export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "git", "knowledge"] as const;
 export type TabId = (typeof TAB_IDS)[number];
 
 export const TAB_LABELS: Record<TabId, string> = {
@@ -12,7 +12,6 @@ export const TAB_LABELS: Record<TabId, string> = {
   tasks: "Tasks",
   plan: "Plan",
   quickfix: "Quick fix",
-  metrics: "Metrics",
   git: "Git",
   knowledge: "Knowledge",
 };

package/src/lobby/service.ts

@@ -9,6 +9,8 @@ import { updateBlockingRequest } from "../state/blocking-requests.ts";
 import { randomUUID } from "node:crypto";
 import { loadTask, ownedTask, peekOwnedTask, peekTasks, saveTask } from "../state/persistence.ts";
 import { taskWork } from "../state/work-time.ts";
+import { transition } from "../state/task-state.ts";
+import { cancelTaskExecutions } from "../execution/task-cancellation.ts";
 import { refreshReview, deferReview } from "../delivery/review.ts";
 import { deliver, type DeliveryRequest } from "../delivery/operations.ts";
 import { deliveryStore, deliveryTask } from "../delivery/store.ts";
@@ -18,7 +20,7 @@ import { loadConfig, readDataRoots, saveConfig as writeConfig } from "../state/p
 import { knowledgeQuestion } from "./knowledge.ts";
 import { addPlanComment, editComment, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
-import { sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
+import { markInboxDelivered, sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
 import { livePresence } from "../state/presence.ts";
 import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listArchivedTasks, restoreTask as restoreTaskOnDisk } from "../state/archive.ts";
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
@@ -50,6 +52,9 @@ import type { LiveSession, LobbyService, SwitchTarget } from "./host.ts";
 import { pushNotice, type NoticeLevel } from "../webui/notices.ts";
 import type { Runtime } from "./runtime.ts";
 import { findLinters } from "../execution/lint.ts";
+import { handleResolveApproval, lastQaAsks, waiveLint, waiveQa } from "../workflow/workflow.ts";
+import { recordDecision } from "../master/decisions.ts";
+import { fail } from "../webui/api/index.ts";
 
 /** The state background callbacks report to; set while the lobby service runs. */
 let serviceState: Runtime | undefined;
@@ -384,6 +389,73 @@ async function resumeTask(state: Runtime, taskId: string): Promise<{ notice: str
   }
 }
 
+function mutableTask(state: Runtime, taskId: string): Task {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$/.test(taskId)) fail(400, "bad_request", "invalid task ID");
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task) fail(404, "not_found", "task not found in this project");
+  if (TERMINAL_STATES.includes(task.state)) fail(400, "bad_request", "task is terminal");
+  return task;
+}
+
+async function wakeTask(state: Runtime, task: Task, message: string): Promise<string> {
+  const inbox = sendToInbox(state.root, state.configDir, task.id, message, state.ctx.sessionManager.getSessionId());
+  const route = resumeRoute(task, taskDrivers(state));
+  if (route.kind === "stopped" || route.kind === "paused") return (await resumeTask(state, task.id)).notice;
+  if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) {
+    state.pi.sendUserMessage(message, state.ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+    markInboxDelivered(state.root, state.configDir, task.id, [inbox.id]);
+  } else {
+    const session = backgroundSessions().find((entry) => entry.alive && entry.projectRoot === state.root && entry.sessionId === task.ownerSessionId);
+    if (session) {
+      session.send(message);
+      markInboxDelivered(state.root, state.configDir, task.id, [inbox.id]);
+    }
+  }
+  return "the owning oracle has been notified";
+}
+
+function canForceCloseTask(state: Runtime, taskId: string): boolean {
+  const task = loadTask(state.root, state.configDir, taskId);
+  return Boolean(task && !TERMINAL_STATES.includes(task.state) && (!task.ownerSessionId || task.ownerSessionId === state.ctx.sessionManager.getSessionId()));
+}
+
+async function forceCloseTask(state: Runtime, taskId: string, title: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (title !== task.title) fail(400, "bad_request", "the title must match exactly");
+  if (!canForceCloseTask(state, taskId)) fail(400, "bad_request", "cancel this task in its owning session; remote cancellation is unavailable");
+  recordDecision(task, "The user force-closed the task from the Tasks screen; work abandoned, code and worktree retained.");
+  transition(task, "abandoned");
+  saveTask(state.root, state.configDir, task);
+  cancelTaskExecutions(state.root, state.configDir, task.id);
+  if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) state.ctx.abort();
+  lobbyTopics.bump("tasks");
+  return { notice: `${task.id} abandoned; code, worktree and history retained` };
+}
+
+async function acceptTask(state: Runtime, taskId: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (!["implementing", "reviewing", "blocked"].includes(task.state)) fail(400, "bad_request", "there is no work to accept yet");
+  const asks = lastQaAsks(task);
+  if (task.qaVerdict !== "pass" && !task.qaWaiver) waiveQa(task, asks, "from the Tasks screen");
+  if (task.lint?.state === "failing") waiveLint(task, "from the Tasks screen");
+  recordDecision(task, "The user accepted the work as it is from the Tasks screen; the oracle was asked to complete it.");
+  saveTask(state.root, state.configDir, task);
+  lobbyTopics.bump("tasks");
+  const wake = await wakeTask(state, task, `The user accepted ${task.id}'s work as it is. Call orchestrate action=complete now with a short summary naming outstanding QA/lint asks: ${asks.join("; ") || "none recorded"}. Read the persisted gate waivers first. Do not merge automatically.`);
+  return { notice: `${task.id} accepted as it is; ${wake}` };
+}
+
+async function resolveTaskApproval(state: Runtime, taskId: string, approvalId: string, decision: "approved" | "rejected", note?: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (!task.approvals.some((entry) => entry.id === approvalId && entry.status === "pending")) fail(409, "conflict", "approval is no longer pending");
+  let message: string;
+  try { message = handleResolveApproval(task, { action: "resolve_approval", approvalId, decision, note }); }
+  catch (error) { return fail(400, "bad_request", (error as Error).message); }
+  saveTask(state.root, state.configDir, task);
+  lobbyTopics.bump("tasks");
+  return { notice: `${message}; ${await wakeTask(state, task, message)}` };
+}
+
 /** Leave a message for a task another terminal's session drives; its owner passes it to the oracle. */
 function sendToTask(state: Runtime, taskId: string, text: string): string {
   const task = loadTask(state.root, state.configDir, taskId);
@@ -826,6 +898,10 @@ export function createLobbyService(state: Runtime): LobbyService {
     setAuto: (taskId, on) => switchAuto(state, taskId, on),
     sendToTask: (taskId, text) => sendToTask(state, taskId, text),
     resumeTask: (taskId) => resumeTask(state, taskId),
+    acceptTask: (taskId) => acceptTask(state, taskId),
+    forceCloseTask: (taskId, title) => forceCloseTask(state, taskId, title),
+    canForceCloseTask: (taskId) => canForceCloseTask(state, taskId),
+    resolveTaskApproval: (taskId, approvalId, decision, note) => resolveTaskApproval(state, taskId, approvalId, decision, note),
     sendToSession: (sessionId, text) => sendToSession(state, sessionId, text),
     liveSessions: () => liveSessions(state),
     switchTo: (target) => switchTo(state, target),

package/src/state/persistence.ts

@@ -89,13 +89,38 @@ export function readTaskArtifact(
 
 export function saveTask(root: string, configDir: string, task: Task): void {
   const latest = loadTask(root, configDir, task.id);
-  if (latest) mergePhaseTiming(task, timingBaselines.get(task), latest);
+  // Abandonment is final: an in-flight action must not overwrite its audit or resurrect it.
+  if (latest?.state === "abandoned") {
+    Object.assign(task, latest);
+    return;
+  }
+  if (latest) {
+    preserveUserInterventions(task, latest);
+    mergePhaseTiming(task, timingBaselines.get(task), latest);
+  }
   const path = join(taskDir(dataRoot(root, configDir), task.id), "state.json");
   forgetCached(path);
   writeFileEnsured(path, JSON.stringify(task, null, 2));
   rememberTiming(task);
 }
 
+/** Explicit user waivers and resolved approvals must survive an in-flight worker's snapshot. */
+function preserveUserInterventions(task: Task, latest: Task): void {
+  const newlyWaived = !task.qaWaiver && latest.qaWaiver;
+  task.qaWaiver ??= latest.qaWaiver;
+  task.lintWaiver ??= latest.lintWaiver;
+  if (newlyWaived && !TERMINAL_STATES.includes(task.state)) {
+    task.blockers = [];
+    if (["implementing", "blocked"].includes(task.state)) task.state = "reviewing";
+  }
+  for (const approval of task.approvals) {
+    const resolved = latest.approvals.find((entry) => entry.id === approval.id && entry.status !== "pending");
+    if (approval.status === "pending" && resolved) Object.assign(approval, resolved);
+  }
+  const keys = new Set(task.decisions.map((entry) => JSON.stringify(entry)));
+  task.decisions.push(...latest.decisions.filter((entry) => !keys.has(JSON.stringify(entry))));
+}
+
 /** Read a task state: the bot-lobby copy wins, else the newest pre-rename copy. */
 export function loadTask(root: string, configDir: string, taskId: string): Task | undefined {
   for (const dr of readDataRoots(root, configDir)) {

package/src/webui/api/index.ts

@@ -15,8 +15,7 @@ import { lobbyAbort, lobbyHistory, lobbySend, lobbySnapshot } from "./lobby.ts";
 import { promptsAnswer, promptsDismiss, promptsList } from "./prompts.ts";
 import { plannerAnswer, plannerCommentLine, plannerGet, plannerNew, plannerRetry, plannerSend, plannerEditMessage, plannerToggleSeat, plannerSave, plannerPrevious, plannerPreviousArchive, plannerPreviousDelete, plannerPreviousGet, plannerPreviousOpen } from "./planner.ts";
 import { quickfixCancel, quickfixList, quickfixMovedToTask, quickfixRunAnyway, quickfixSubmit } from "./quickfix.ts";
-import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksResume, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver } from "./tasks.ts";
-import { metricsGet } from "./metrics.ts";
+import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksResume, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver, tasksAccept, tasksForceClose, tasksResolveApproval } from "./tasks.ts";
 import { knowledgeAdd, knowledgeAsk, knowledgeComment, knowledgeEdit, knowledgeFiles, knowledgeOpen, knowledgeRemove, knowledgeReplaceFile, knowledgeUnnote } from "./knowledge.ts";
 import { plansDiscard, plansGet, plansStart } from "./plans.ts";
 import { gitCancelReview, gitJev, gitPull, gitPulls, gitReview } from "./git.ts";
@@ -131,6 +130,18 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksResume(body as { taskId: string }, ctx),
   };
+  routes["tasks.accept"] = {
+    schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
+    run: (body, ctx) => tasksAccept(body as { taskId: string }, ctx),
+  };
+  routes["tasks.forceClose"] = {
+    schema: Type.Object({ taskId: TaskId, title: Type.String({ maxLength: 20_000 }) }, { additionalProperties: false }),
+    run: (body, ctx) => tasksForceClose(body as { taskId: string; title: string }, ctx),
+  };
+  routes["tasks.resolveApproval"] = {
+    schema: Type.Object({ taskId: TaskId, approvalId: TaskId, decision: Type.Union([Type.Literal("approved"), Type.Literal("rejected")]), note: Type.Optional(NoticeText) }, { additionalProperties: false }),
+    run: (body, ctx) => tasksResolveApproval(body as Parameters<typeof tasksResolveApproval>[0], ctx),
+  };
   routes["tasks.deliveryReview"] = {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksDeliveryReview(body as { taskId: string }, ctx),
@@ -268,10 +279,6 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ id: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => quickfixMovedToTask(body as { id: string }, ctx),
   };
-  routes["metrics.get"] = {
-    schema: Type.Object({ groupBy: Type.Union([Type.Literal("model"), Type.Literal("model-kind")]), query: Type.Optional(Type.String({ maxLength: 500 })), from: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })), to: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })), timeZone: Type.Optional(Type.String({ maxLength: 100 })) }, { additionalProperties: false }),
-    run: (body, ctx) => metricsGet(body as Parameters<typeof metricsGet>[0], ctx),
-  };
   routes["knowledge.files"] = { schema: Empty, run: (_body, ctx) => knowledgeFiles(ctx) };
   routes["knowledge.ask"] = {
     schema: Type.Object({ text: NoticeText, attachments: Attachments }, { additionalProperties: false }),

package/src/webui/api/tasks.ts

@@ -282,17 +282,52 @@ export function tasksOpen(body: { taskId: string }, ctx: ApiContext): { sessionI
   return { notice: "The task's owning session has ended or is unavailable. No replacement session was created." };
 }
 
+/** Interventions only apply to an active task in this project, never an archive. */
+function interventionTask(taskId: string, ctx: ApiContext): Task {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$/.test(taskId)) fail(400, "bad_request", "invalid task ID");
+  const task = ctx.service.tasks().find((entry) => entry.id === taskId);
+  if (!task) fail(404, "not_found", "task not found in this project");
+  if (TERMINAL_STATES.includes(task.state)) fail(400, "bad_request", "this task is already finished");
+  return task;
+}
+
+function acceptable(task: Task): boolean {
+  return ["implementing", "reviewing", "blocked"].includes(task.state);
+}
+
+export async function tasksAccept(body: { taskId: string }, ctx: ApiContext): Promise<{ notice: string }> {
+  const task = interventionTask(body.taskId, ctx);
+  if (!acceptable(task)) fail(400, "bad_request", "only implementing, reviewing or blocked tasks can be accepted");
+  if (!ctx.service.acceptTask) fail(400, "bad_request", "accepting tasks is unavailable");
+  return ctx.service.acceptTask(body.taskId);
+}
+
+export async function tasksForceClose(body: { taskId: string; title: string }, ctx: ApiContext): Promise<{ notice: string }> {
+  const task = interventionTask(body.taskId, ctx);
+  if (body.title !== task.title) fail(400, "bad_request", "the title must match exactly");
+  if (!ctx.service.forceCloseTask) fail(400, "bad_request", "force closing tasks is unavailable");
+  return ctx.service.forceCloseTask(body.taskId, body.title);
+}
+
+export async function tasksResolveApproval(body: { taskId: string; approvalId: string; decision: "approved" | "rejected"; note?: string }, ctx: ApiContext): Promise<{ notice: string }> {
+  const task = interventionTask(body.taskId, ctx);
+  if (!pendingApprovals(task).some((approval) => approval.id === body.approvalId)) fail(409, "conflict", "approval is no longer pending; refresh the task");
+  if (!ctx.service.resolveTaskApproval) fail(400, "bad_request", "resolving task approvals is unavailable");
+  return ctx.service.resolveTaskApproval(body.taskId, body.approvalId, body.decision, body.note);
+}
+
 /** How many recent runs the detail lists (the terminal's count). */
 const DETAIL_RUNS = 6;
 
 /** The terminal's "Waiting on" approvals: `kind` plus `for <domain>: <detail>`. */
 function waitingOf(task: Task): TaskDetail["waiting"] {
-  return pendingApprovals(task).map((approval) => ({ kind: approval.kind, detail: `for ${approval.domain}: ${approval.detail}` }));
+  return pendingApprovals(task).map((approval) => ({ id: approval.id, domain: approval.domain, kind: approval.kind, detail: `for ${approval.domain}: ${approval.detail}` }));
 }
 
 /** One task read whole: request, plan or proposal, step checklist, waits and recent runs. */
 export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail {
-  const task = [...ctx.service.tasks(), ...ctx.service.archivedTasks()].find((entry) => entry.id === body.taskId);
+  const active = ctx.service.tasks().find((entry) => entry.id === body.taskId);
+  const task = active ?? ctx.service.archivedTasks().find((entry) => entry.id === body.taskId);
   if (!task) fail(404, "not_found", `no task ${body.taskId}`);
   const found = task as Task;
   const request = taskRequest(found);
@@ -301,6 +336,8 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
   const clock = clockOf(found, work);
   const details = found.plan ? planDetails(found.plan) : undefined;
   return {
+    canAccept: Boolean(active && ctx.service.acceptTask) && acceptable(found),
+    canForceClose: Boolean(active && ctx.service.forceCloseTask) && !TERMINAL_STATES.includes(found.state) && (ctx.service.canForceCloseTask?.(found.id) ?? true),
     timing: projectPhaseTiming(found, new Date(now).toISOString()),
     ...(clock ? { work: clock } : {}),
     ...(found.delivery ? { delivery: found.delivery } : {}),

package/src/webui/palette-core.ts

@@ -174,10 +174,11 @@ export const DEFAULT_ID = "mist"
 
 /**
  * The themes that come with the page. The first is the page's own colours and
- * sets nothing; the rest are T3 Code's built-in themes (MIT, Copyright (c) 2026
+ * sets nothing; Blossom through Iris are T3 Code's built-in themes (MIT, Copyright (c) 2026
  * 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.
+ * primary, accent surface the accent, error the destructive colour. Slate,
+ * Sand, Rosewood, Aurora and Midnight are original complementary palettes.
  */
 export const PRESETS: readonly Palette[] = [
   { id: DEFAULT_ID, name: "Default" },
@@ -411,6 +412,236 @@ export const PRESETS: readonly Palette[] = [
       "chart-1": "oklch(0.671712 0.169136 293.929)",
     },
   },
+  {
+    id: "slate",
+    name: "Slate",
+    light: {
+      "background": "#f5f7fa",
+      "foreground": "#202b3b",
+      "card": "#ffffff",
+      "card-foreground": "#202b3b",
+      "popover": "#ffffff",
+      "popover-foreground": "#202b3b",
+      "primary": "#465b78",
+      "primary-foreground": "#ffffff",
+      "secondary": "#e7ecf2",
+      "secondary-foreground": "#202b3b",
+      "muted": "#edf1f6",
+      "muted-foreground": "#526177",
+      "accent": "#e0e7ef",
+      "accent-foreground": "#202b3b",
+      "destructive": "#a52a34",
+      "border": "#cad3df",
+      "input": "#b9c5d4",
+      "ring": "#465b78",
+      "chart-1": "#465b78",
+    },
+    dark: {
+      "background": "#141b26",
+      "foreground": "#e8edf5",
+      "card": "#1c2533",
+      "card-foreground": "#e8edf5",
+      "popover": "#202b3b",
+      "popover-foreground": "#e8edf5",
+      "primary": "#adc0dc",
+      "primary-foreground": "#141b26",
+      "secondary": "#2a3648",
+      "secondary-foreground": "#e8edf5",
+      "muted": "#243043",
+      "muted-foreground": "#afbdd0",
+      "accent": "#33445d",
+      "accent-foreground": "#e8edf5",
+      "destructive": "#fb8990",
+      "border": "#43536a",
+      "input": "#53647d",
+      "ring": "#adc0dc",
+      "chart-1": "#adc0dc",
+    },
+  },
+  {
+    id: "sand",
+    name: "Sand",
+    light: {
+      "background": "#faf7f1",
+      "foreground": "#352b22",
+      "card": "#fffdf8",
+      "card-foreground": "#352b22",
+      "popover": "#fffdf8",
+      "popover-foreground": "#352b22",
+      "primary": "#765536",
+      "primary-foreground": "#ffffff",
+      "secondary": "#eee6da",
+      "secondary-foreground": "#352b22",
+      "muted": "#f2ece2",
+      "muted-foreground": "#6c5b49",
+      "accent": "#e9ddcb",
+      "accent-foreground": "#352b22",
+      "destructive": "#a52a34",
+      "border": "#d9cbb8",
+      "input": "#c9b79e",
+      "ring": "#765536",
+      "chart-1": "#765536",
+    },
+    dark: {
+      "background": "#211c17",
+      "foreground": "#f4ece0",
+      "card": "#2c251e",
+      "card-foreground": "#f4ece0",
+      "popover": "#352c23",
+      "popover-foreground": "#f4ece0",
+      "primary": "#dcbc92",
+      "primary-foreground": "#211c17",
+      "secondary": "#3c3227",
+      "secondary-foreground": "#f4ece0",
+      "muted": "#352d24",
+      "muted-foreground": "#c9b9a5",
+      "accent": "#4a3b2b",
+      "accent-foreground": "#f4ece0",
+      "destructive": "#fb8990",
+      "border": "#64503e",
+      "input": "#79614b",
+      "ring": "#dcbc92",
+      "chart-1": "#dcbc92",
+    },
+  },
+  {
+    id: "rosewood",
+    name: "Rosewood",
+    light: {
+      "background": "#fbf6f5",
+      "foreground": "#3b262c",
+      "card": "#fffafa",
+      "card-foreground": "#3b262c",
+      "popover": "#fffafa",
+      "popover-foreground": "#3b262c",
+      "primary": "#854252",
+      "primary-foreground": "#ffffff",
+      "secondary": "#f0e2e5",
+      "secondary-foreground": "#3b262c",
+      "muted": "#f5eaec",
+      "muted-foreground": "#76525d",
+      "accent": "#edd6dd",
+      "accent-foreground": "#3b262c",
+      "destructive": "#a52a34",
+      "border": "#dfc5cc",
+      "input": "#d0afb9",
+      "ring": "#854252",
+      "chart-1": "#854252",
+    },
+    dark: {
+      "background": "#241a20",
+      "foreground": "#f6e8ed",
+      "card": "#30222a",
+      "card-foreground": "#f6e8ed",
+      "popover": "#3a2932",
+      "popover-foreground": "#f6e8ed",
+      "primary": "#e3a5b7",
+      "primary-foreground": "#241a20",
+      "secondary": "#442e38",
+      "secondary-foreground": "#f6e8ed",
+      "muted": "#3a2932",
+      "muted-foreground": "#d2b4c0",
+      "accent": "#553441",
+      "accent-foreground": "#f6e8ed",
+      "destructive": "#fb8990",
+      "border": "#70505d",
+      "input": "#856170",
+      "ring": "#e3a5b7",
+      "chart-1": "#e3a5b7",
+    },
+  },
+  {
+    id: "aurora",
+    name: "Aurora",
+    light: {
+      "background": "#f2faf8",
+      "foreground": "#193a37",
+      "card": "#fafffe",
+      "card-foreground": "#193a37",
+      "popover": "#fafffe",
+      "popover-foreground": "#193a37",
+      "primary": "#216c63",
+      "primary-foreground": "#ffffff",
+      "secondary": "#def0eb",
+      "secondary-foreground": "#193a37",
+      "muted": "#e6f2ef",
+      "muted-foreground": "#456c66",
+      "accent": "#eee5f6",
+      "accent-foreground": "#193a37",
+      "destructive": "#a52a34",
+      "border": "#bbd7d1",
+      "input": "#a7c8c0",
+      "ring": "#216c63",
+      "chart-1": "#216c63",
+    },
+    dark: {
+      "background": "#142321",
+      "foreground": "#e1f5ef",
+      "card": "#1d302d",
+      "card-foreground": "#e1f5ef",
+      "popover": "#253d38",
+      "popover-foreground": "#e1f5ef",
+      "primary": "#87d5c1",
+      "primary-foreground": "#142321",
+      "secondary": "#29443e",
+      "secondary-foreground": "#e1f5ef",
+      "muted": "#243c36",
+      "muted-foreground": "#a9cfc3",
+      "accent": "#3d3352",
+      "accent-foreground": "#e1f5ef",
+      "destructive": "#fb8990",
+      "border": "#466b60",
+      "input": "#568172",
+      "ring": "#87d5c1",
+      "chart-1": "#87d5c1",
+    },
+  },
+  {
+    id: "midnight",
+    name: "Midnight",
+    light: {
+      "background": "#f5f6fb",
+      "foreground": "#282e48",
+      "card": "#fcfcff",
+      "card-foreground": "#282e48",
+      "popover": "#fcfcff",
+      "popover-foreground": "#282e48",
+      "primary": "#4f5f96",
+      "primary-foreground": "#ffffff",
+      "secondary": "#e5e8f4",
+      "secondary-foreground": "#282e48",
+      "muted": "#eceef7",
+      "muted-foreground": "#565f7d",
+      "accent": "#dfe4f6",
+      "accent-foreground": "#282e48",
+      "destructive": "#a52a34",
+      "border": "#c7cee5",
+      "input": "#b4bfdc",
+      "ring": "#4f5f96",
+      "chart-1": "#4f5f96",
+    },
+    dark: {
+      "background": "#151a2b",
+      "foreground": "#e8ecfa",
+      "card": "#1f263b",
+      "card-foreground": "#e8ecfa",
+      "popover": "#29314a",
+      "popover-foreground": "#e8ecfa",
+      "primary": "#acbbed",
+      "primary-foreground": "#151a2b",
+      "secondary": "#303954",
+      "secondary-foreground": "#e8ecfa",
+      "muted": "#28314b",
+      "muted-foreground": "#b1bedf",
+      "accent": "#3a466a",
+      "accent-foreground": "#e8ecfa",
+      "destructive": "#fb8990",
+      "border": "#48577d",
+      "input": "#596990",
+      "ring": "#acbbed",
+      "chart-1": "#acbbed",
+    },
+  },
 ]
 
 /** Colours for a preview swatch, per mode: the default's own values by hand, the rest from the theme. */