sensorium-mcp 3.1.2 → 3.1.3-board.10

package/dist/board/components/rateLimit.js

@@ -0,0 +1,32 @@
+/**
+ * rate_limited helpers — ✅ EDITABLE. Shared by Card tile, Lane badge and the
+ * card detail notice. Pure functions: card in, display strings out.
+ */
+
+export const PROVIDER_LABELS = {
+  claude: "Claude",
+  copilot: "Copilot",
+  codex: "Codex",
+  fable: "Fable",
+};
+
+/** Proactive usage limit marker for a queued card; reactive cards remain untouched. */
+export function proactiveLimitKind(card, limitedProviders) {
+  const provider = card.profile?.agentType;
+  return card.status === "backlog" && limitedProviders.includes(provider)
+    ? "usage_quota_exceeded"
+    : "";
+}
+
+/** Live countdown text derived from retryAt (null = unknown reset window). */
+export function retryLabel(card, now = Date.now()) {
+  if (!card.retryAt) return "retrying when limit resets";
+  const mins = Math.ceil((new Date(card.retryAt).getTime() - now) / 60000);
+  if (mins <= 0) return "retrying\u2026";
+  if (mins >= 60) return `retry in ~${Math.floor(mins / 60)}h ${mins % 60}m`;
+  return `retry in ~${mins}m`;
+}
+
+export function providerLabel(agentType) {
+  return PROVIDER_LABELS[agentType] || "";
+}

package/dist/board/components/rateLimit.test.ts

@@ -0,0 +1,16 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { proactiveLimitKind } from "./rateLimit.js";
+
+test("backlog card gets the proactive usage-quota chip only for a limited provider", () => {
+  const card = { status: "backlog", profile: { agentType: "codex" } };
+
+  assert.equal(proactiveLimitKind(card, ["codex"]), "usage_quota_exceeded");
+  assert.equal(proactiveLimitKind(card, ["claude"]), "");
+});
+
+test("proactive usage-quota chip does not replace reactive rate-limited rendering", () => {
+  const card = { status: "rate_limited", profile: { agentType: "codex" } };
+
+  assert.equal(proactiveLimitKind(card, ["codex"]), "");
+});

package/dist/board/components/time.js

@@ -0,0 +1,14 @@
+/** Minutes since an ISO timestamp (0 when absent/unparseable). */
+export function minsSince(iso) {
+  if (!iso) return 0;
+  const t = new Date(iso).getTime();
+  if (Number.isNaN(t)) return 0;
+  return Math.max(0, Math.round((Date.now() - t) / 60000));
+}
+
+export function humanMins(mins) {
+  if (mins < 60) return mins + "m";
+  const h = Math.floor(mins / 60);
+  if (h < 24) return h + "h " + (mins % 60) + "m";
+  return Math.floor(h / 24) + "d " + (h % 24) + "h";
+}

package/dist/board/config.js

@@ -0,0 +1,56 @@
+/**
+ * Board-front runtime config.  ❌ FROZEN SEAM — do NOT edit during UI iteration.
+ *
+ * MODE selects the data adapter downstream (see api/api.js):
+ *   'production' → real fetch to the board API through the Dev Tunnel.
+ *   'preview'    → mock adapter over fixtures (Claude Design sandbox), so EVERY
+ *                  screen renders with zero real network calls.
+ */
+
+/**
+ * Canonical card statuses — mirror of src/data/board/board-types.ts `CardStatus`
+ * plus the P2 `decision_needed` value the kanban reserves a column for now so the
+ * skeleton lane exists before the backend migration lands.
+ */
+export const CARD_STATUSES = ["backlog", "in_progress", "decision_needed", "blocked", "done"];
+
+/** Board poll cadence while the browser tab is visible (ms). */
+export const POLL_INTERVAL_MS = 5000;
+
+/**
+ * All API calls are same-origin, ROOT-RELATIVE (`/api/...`) — safe behind any
+ * reverse proxy / Cloudflare Tunnel. No host or port is ever hardcoded.
+ */
+export const API_BASE = "";
+
+function readOverride() {
+  try {
+    const q = new URLSearchParams(location.search);
+    const qMode = q.get("mode") ?? (q.has("preview") ? "preview" : null);
+    if (qMode === "preview" || qMode === "production") return qMode;
+    const stored = localStorage.getItem("BOARD_MODE");
+    if (stored === "preview" || stored === "production") return stored;
+  } catch {
+    /* sandbox without URL/localStorage — fall through to auto-detect */
+  }
+  return null;
+}
+
+/**
+ * Auto-detect the run mode.
+ *   1. explicit `?mode=` / `?preview` / localStorage override wins (the design
+ *      tool can force either without editing this file).
+ *   2. non-http(s) origin (file: / blob: / data:) → sandbox → preview.
+ *   3. http(s) served under `/board` by our server → production.
+ *   4. anything else (an artifact host serving at `/`) → preview.
+ */
+export function detectMode() {
+  const override = readOverride();
+  if (override) return override;
+  const proto = typeof location !== "undefined" ? location.protocol : "file:";
+  if (proto !== "http:" && proto !== "https:") return "preview";
+  const path = (typeof location !== "undefined" && location.pathname) || "/";
+  return path.startsWith("/board") ? "production" : "preview";
+}
+
+export const MODE = detectMode();

package/dist/board/index.html

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+    <meta name="color-scheme" content="dark" />
+    <meta name="theme-color" content="#15141d" />
+    <title>Dispatch — Agent Task Board</title>
+    <!-- ✅ styles/ is editable by Claude Design. -->
+    <link rel="stylesheet" href="./styles/tokens.css" />
+    <link rel="stylesheet" href="./styles/board.css" />
+  </head>
+  <body>
+    <div id="app"></div>
+    <!-- ❌ main.js is the frozen entry/router. -->
+    <script type="module" src="./main.js"></script>
+  </body>
+</html>

package/dist/board/main.js

@@ -0,0 +1,37 @@
+/**
+ * App entry + hash router.  ❌ FROZEN SEAM (entry/router wiring only).
+ *
+ * Provides a minimal reactive router to the app under the inject key 'router'.
+ * Views consume it via `inject('router')` and never import this file:
+ *   router.current = { name, params, path }   // name ∈ board|card|new|settings
+ *   router.navigate('/card/12')               // sets location.hash
+ *
+ * A hash router (not history routing) is deliberate: the same file set runs from
+ * file:// in the design sandbox AND under /board in production with no server-side
+ * route table for client paths.
+ */
+
+import { createApp, reactive } from "./vendor/vue.esm-browser.js";
+import App from "./views/App.js";
+
+function parseHash() {
+  const raw = (location.hash || "#/board").replace(/^#/, "");
+  const path = raw.split("?")[0];
+  const parts = path.split("/").filter(Boolean);
+  if (parts[0] === "card" && parts[1]) return { name: "card", params: { id: Number(parts[1]) }, path };
+  if (parts[0] === "new") return { name: "new", params: {}, path };
+  if (parts[0] === "settings") return { name: "settings", params: {}, path };
+  return { name: "board", params: {}, path: "/board" };
+}
+
+const router = reactive({ current: parseHash() });
+router.navigate = (to) => {
+  location.hash = to.startsWith("#") ? to : `#${to}`;
+};
+window.addEventListener("hashchange", () => {
+  router.current = parseHash();
+});
+
+const app = createApp(App);
+app.provide("router", router);
+app.mount("#app");

package/dist/board/mock/api.mock.js

@@ -0,0 +1,491 @@
+/**
+ * Preview data adapter.  ❌ FROZEN SEAM. Dynamically imported ONLY when
+ * MODE==='preview' (api/api.js) — no mock byte ships to production.
+ *
+ * An in-memory store over fixtures that implements the full BoardApi surface,
+ * including mutations, so create / move / stop / comment / archive / delete all
+ * work standalone in the design sandbox with ZERO real network calls.
+ *
+ * Extra design affordances (query string, preview only):
+ *   ?mock=empty  → the board renders its empty state.
+ *   ?mock=error  → list calls reject so the error state is visible.
+ *
+ * @typedef {import('../api/contract.js').BoardApi} BoardApi
+ */
+
+import { fixtures, dirTree } from "./fixtures.js";
+import { POLICY_SCHEMA, PRESETS } from "../schema/policy.js";
+
+const clone = (x) => JSON.parse(JSON.stringify(x));
+const OPERATOR_STATUS_TARGETS = ["backlog", "done"];
+const PROFILE_FIELDS = new Set([
+  "repository", "createBranch", "skills", "operatorReview", "openPr", "prDraft",
+  "verifyDone", "prProvider", "expertReview", "reviewAgentType", "workerSplit",
+  "agentType", "model", "memory", "worktree", "autonomy", "phases", "size",
+  "runTests", "build", "push", "ciCheck", "inline", "ttlMinutes",
+]);
+const PROFILE_ENUMS = {
+  prProvider: ["Auto", "GitHub", "Azure DevOps"],
+  reviewAgentType: ["claude", "copilot", "codex", "fable"],
+  workerSplit: ["single", "multi"], agentType: ["claude", "copilot", "codex", "fable"],
+  autonomy: ["Autonomous", "Checkpoints", "Collaborative"], size: ["operational", "code"],
+  ciCheck: ["none", "github", "azure"],
+};
+
+function httpError(status, message) {
+  const error = new Error(message);
+  error.status = status;
+  return error;
+}
+
+function validateProfile(profile) {
+  if (profile === null || typeof profile !== "object" || Array.isArray(profile)) return "profile must be a JSON object";
+  for (const key of Object.keys(profile)) if (!PROFILE_FIELDS.has(key)) return `unknown profile field '${key}'`;
+  for (const field of ["repository", "model"])
+    if (field in profile && typeof profile[field] !== "string") return `'${field}' must be a string`;
+  for (const field of ["createBranch", "operatorReview", "openPr", "prDraft", "verifyDone", "expertReview", "worktree", "runTests", "build", "push", "inline"])
+    if (field in profile && typeof profile[field] !== "boolean") return `'${field}' must be a boolean`;
+  if ("skills" in profile && (!Array.isArray(profile.skills) || !profile.skills.every((x) => typeof x === "string"))) return "'skills' must be an array of strings";
+  if ("memory" in profile) {
+    const memory = profile.memory;
+    if (memory === null || typeof memory !== "object" || Array.isArray(memory)) return "'memory' must be a JSON object";
+    if (Object.keys(memory).some((key) => !["mode", "threadId"].includes(key))) return "unknown memory field";
+    if (!["Ephemeral", "Existing thread"].includes(memory.mode)) return `Unknown memory mode '${String(memory.mode)}' — allowed: Ephemeral, Existing thread`;
+    if ("threadId" in memory && memory.threadId !== null && typeof memory.threadId !== "number") return "'memory.threadId' must be a number or null";
+    if (memory.mode === "Existing thread" && typeof memory.threadId !== "number") return "'memory.threadId' is required for Existing thread";
+  }
+  if ("phases" in profile) {
+    if (!Array.isArray(profile.phases)) return "'phases' must be an array";
+    for (const phase of profile.phases) {
+      if (phase === null || typeof phase !== "object" || Array.isArray(phase)) return "each phase must be a JSON object";
+      if (Object.keys(phase).some((key) => !["name", "review", "provider", "model"].includes(key))) return "unknown phase field";
+      if (["name", "review", "provider", "model"].some((key) => !(key in phase))) return "phase field is required";
+      if (typeof phase.name !== "string" || !phase.name.trim()) return "phase 'name' must be non-empty";
+      if (typeof phase.review !== "boolean") return "phase 'review' must be a boolean";
+      if (typeof phase.model !== "string") return "phase 'model' must be a string";
+      if (!["Inherit", "Claude", "Copilot", "Codex"].includes(phase.provider)) return `Unknown phase provider '${String(phase.provider)}' — allowed: Inherit, Claude, Copilot, Codex`;
+    }
+  }
+  if ("ttlMinutes" in profile && (typeof profile.ttlMinutes !== "number" || !Number.isFinite(profile.ttlMinutes))) return "'ttlMinutes' must be a number";
+  for (const [field, values] of Object.entries(PROFILE_ENUMS))
+    if (field in profile && (typeof profile[field] !== "string" || !values.includes(profile[field]))) return `Unknown ${field} '${String(profile[field])}' — allowed: ${values.join(", ")}`;
+  return null;
+}
+
+function parseRecurDelay(value) {
+  if (value === null || value === undefined || value === "") return null;
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(parsed)) return undefined;
+  return parsed >= 1 ? parsed : null;
+}
+
+/** Depth-first lookup of a node by absolute path in the preview dir tree. */
+function locateDir(nodes, path) {
+  for (const n of nodes || []) {
+    if (n.path === path) return n;
+    const hit = locateDir(n.children, path);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+/** Best-effort parent of an absolute path (null at a drive/volume root). */
+function parentDir(path) {
+  const trimmed = path.replace(/[\\/]+$/, "");
+  const cut = Math.max(trimmed.lastIndexOf("\\"), trimmed.lastIndexOf("/"));
+  if (cut <= 1) return null;
+  const parent = trimmed.slice(0, cut);
+  return /^[A-Za-z]:$/.test(parent) ? `${parent}\\` : parent;
+}
+
+/**
+ * Preview-only stand-in for the server's renderProfileDirectives: an HONEST but
+ * intentionally partial subset, enough that the compiled-policy panel visibly
+ * changes as the draft's profile changes offline. Not the full server renderer.
+ */
+function previewDirectives(profile) {
+  const d = [];
+  if (profile.repository) d.push(`Work in repository: ${profile.repository}.`);
+  d.push(
+    profile.createBranch
+      ? "Create a work branch before changing anything."
+      : "Do NOT create a new branch unless the current branch is unusable.",
+  );
+  if (profile.skills && profile.skills.length)
+    d.push(`Load these skills via get_skill first: ${profile.skills.join(", ")}.`);
+  if (profile.autonomy) d.push(`Autonomy: ${profile.autonomy}.`);
+  if (profile.phases && profile.phases.length)
+    d.push(
+      `Execute in ${profile.phases.length} ordered phase(s): ${profile.phases.map((p) => p.name).join(" → ")}.`,
+    );
+  d.push(
+    profile.runTests
+      ? "Run the relevant tests and make them pass."
+      : "Do not run test suites unless a change demands it.",
+  );
+  d.push(profile.push ? "Push your commits." : "Do NOT push.");
+  if (profile.openPr) {
+    const target =
+      profile.prProvider && profile.prProvider !== "Auto" ? profile.prProvider : "the repo remote";
+    d.push(
+      `Open a ${profile.prDraft === false ? "ready" : "draft"} pull request targeting ${target}.`,
+    );
+  } else {
+    d.push("Do NOT open a pull request.");
+  }
+  if (profile.verifyDone)
+    d.push("Independently verify the acceptance criteria before reporting DONE.");
+  return d;
+}
+
+const scenario = (() => {
+  try {
+    return new URLSearchParams(location.search).get("mock") || "default";
+  } catch {
+    return "default";
+  }
+})();
+
+const delay = (v) => new Promise((r) => setTimeout(() => r(v), 120));
+const nowIso = () => new Date().toISOString();
+
+function guardScenario() {
+  if (scenario === "error") throw httpError(500, "Simulated preview error (?mock=error)");
+}
+
+/** @returns {BoardApi} */
+export function createMockApi() {
+  const db = {
+    laneGroups: clone(fixtures.laneGroups),
+    cards: scenario === "empty" ? [] : clone(fixtures.cards),
+    comments: clone(fixtures.comments),
+    profiles: clone(fixtures.profiles),
+    seq: 1000,
+  };
+  const find = (id) => db.cards.find((c) => c.cardId === id);
+  const findLaneGroup = (id) => db.laneGroups.find((group) => group.groupId === id);
+  const findProfile = (idOrName) =>
+    db.profiles.find((profile) => profile.id === idOrName || profile.name === idOrName);
+  const resolveProfile = (input) => {
+    const profileError = input.profile === undefined ? null : validateProfile(input.profile);
+    if (profileError) throw httpError(400, profileError);
+    const requestedId = input.profileId || "default";
+    const namedProfile = findProfile(requestedId);
+    if (!namedProfile) throw httpError(400, `Unknown profile '${requestedId}'`);
+    return { id: namedProfile.id, profile: { ...namedProfile.profile, ...input.profile } };
+  };
+
+  return {
+    async listCards({ includeArchived = false } = {}) {
+      await delay();
+      guardScenario();
+      let cards = db.cards.filter((c) => (includeArchived ? true : !c.archivedAt));
+      return clone({ cards, limitedProviders: [] });
+    },
+
+    async getCard(id) {
+      await delay();
+      const card = find(id);
+      if (!card) throw httpError(404, `Card ${id} not found`);
+      return clone({ card, comments: db.comments[id] || [] });
+    },
+
+    async createCard(input) {
+      await delay();
+      if (!input.title || !input.title.trim()) throw httpError(400, "'title' is required");
+      if (input.laneGroupId != null && !findLaneGroup(input.laneGroupId)) {
+        const status = Number.isInteger(input.laneGroupId) ? 404 : 400;
+        throw httpError(status, `Lane group ${input.laneGroupId} not found`);
+      }
+      const recurDelayMin = parseRecurDelay(input.recurDelayMin);
+      if (recurDelayMin === undefined)
+        throw httpError(400, "'recurDelayMin' must be an integer ≥ 1 (or empty to disable)");
+      const resolvedProfile = resolveProfile(input);
+      const id = ++db.seq;
+      const card = {
+        cardId: id,
+        correlationId: input.correlationId || crypto.randomUUID(),
+        title: input.title.trim(),
+        description: input.description || "",
+        acceptance: input.acceptance || "",
+        profileId: resolvedProfile.id,
+        laneGroupId: input.laneGroupId ?? null,
+        priority: input.priority || 0,
+        status: "backlog",
+        profile: resolvedProfile.profile,
+        escalate: input.escalate === true,
+        recurDelayMin,
+        recurGroupId: null,
+        nextSpawnAt: null,
+        workerThreadId: null,
+        operatorReleasing: false,
+        blockedReason: null,
+        ask: null,
+        rateLimitProvider: null,
+        retryAt: null,
+        archivedAt: null,
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+        startedAt: null,
+        finishedAt: null,
+      };
+      db.cards.push(card);
+      return clone(card);
+    },
+
+    async previewBriefing(draft) {
+      await delay();
+      const { profile } = resolveProfile(draft);
+      const lines = [];
+      lines.push(`# Task Board card (preview): ${(draft.title || "").trim() || "(untitled)"}`);
+      lines.push(`Priority: ${draft.priority ?? 0}`);
+      lines.push("");
+      lines.push("## Description");
+      lines.push((draft.description || "").trim() || "(none — the title is the task)");
+      if ((draft.acceptance || "").trim()) {
+        lines.push("");
+        lines.push("## Acceptance criteria");
+        lines.push(draft.acceptance.trim());
+      }
+      lines.push("");
+      lines.push("## Standing orders (execution profile)");
+      for (const directive of previewDirectives(profile)) lines.push(`- ${directive}`);
+      return lines.join("\n");
+    },
+
+    async updateCard(id, patch) {
+      await delay();
+      const card = find(id);
+      if (!card) throw httpError(404, `Card ${id} not found`);
+      if (patch.laneGroupId != null && !findLaneGroup(patch.laneGroupId)) {
+        const status = Number.isInteger(patch.laneGroupId) ? 404 : 400;
+        throw httpError(status, `Lane group ${patch.laneGroupId} not found`);
+      }
+      if (patch.status && patch.status !== card.status && !OPERATOR_STATUS_TARGETS.includes(patch.status))
+        throw httpError(400, "Operator moves may only target backlog/done — in_progress and blocked are set by the board itself");
+      const recurDelayMin = "recurDelayMin" in patch ? parseRecurDelay(patch.recurDelayMin) : undefined;
+      if (recurDelayMin === undefined && "recurDelayMin" in patch)
+        throw httpError(400, "'recurDelayMin' must be an integer ≥ 1 (or empty to disable)");
+      const existingRecurDelayMin = card.recurDelayMin;
+      const wasNonRecurring = existingRecurDelayMin === null && card.recurGroupId === null;
+      const resolvedProfile = typeof patch.profileId === "string" ? resolveProfile(patch) : null;
+      const profileError = patch.profile === undefined ? null : validateProfile(patch.profile);
+      if (profileError) throw httpError(400, profileError);
+      if ("archivedAt" in patch) card.archivedAt = patch.archivedAt === null ? null : nowIso();
+      for (const k of [
+        "title",
+        "description",
+        "acceptance",
+        "laneGroupId",
+        "priority",
+        "escalate",
+        "status",
+      ]) {
+        if (k in patch && patch[k] !== undefined) card[k] = patch[k];
+      }
+      if (resolvedProfile) {
+        card.profileId = resolvedProfile.id;
+        card.profile = resolvedProfile.profile;
+      }
+      if (patch.profile !== undefined) card.profile = patch.profile;
+      if (recurDelayMin !== undefined) card.recurDelayMin = recurDelayMin;
+      if (recurDelayMin !== undefined && recurDelayMin === null) card.nextSpawnAt = null;
+      if (
+        recurDelayMin != null &&
+        wasNonRecurring
+      ) {
+        card.recurGroupId = card.cardId;
+      }
+      if (patch.status === "backlog") {
+        card.workerThreadId = null;
+        card.blockedReason = null;
+      } else if (patch.status === "done") {
+        card.finishedAt = nowIso();
+        card.workerThreadId = null;
+        card.blockedReason = null;
+        card.nextSpawnAt =
+          recurDelayMin === null || existingRecurDelayMin == null
+            ? null
+            : new Date(
+                new Date(card.finishedAt).getTime() + existingRecurDelayMin * 60_000,
+              ).toISOString();
+      }
+      card.updatedAt = nowIso();
+      return clone(card);
+    },
+
+    async deleteCard(id) {
+      await delay();
+      const i = db.cards.findIndex((c) => c.cardId === id);
+      if (i < 0) throw httpError(404, `Card ${id} not found`);
+      db.cards.splice(i, 1);
+      delete db.comments[id];
+    },
+
+    async stopCard(id) {
+      await delay();
+      const card = find(id);
+      if (!card) throw httpError(404, `Card ${id} not found`);
+      if (card.status !== "in_progress")
+        throw httpError(409, `Card ${id} is not running (status: ${card.status})`);
+      card.status = "blocked";
+      card.blockedReason = "Stopped by operator";
+      card.workerThreadId = null;
+      card.updatedAt = nowIso();
+      return clone(card);
+    },
+
+    async addComment(id, content) {
+      await delay();
+      const card = find(id);
+      const text = typeof content === "string" ? content.trim() : "";
+      if (!text) throw httpError(400, "'content' is required");
+      if (!card) throw httpError(404, `Card ${id} not found`);
+      const comment = {
+        id: ++db.seq,
+        cardId: id,
+        author: "operator",
+        content: text,
+        createdAt: nowIso(),
+      };
+      (db.comments[id] ||= []).push(comment);
+      return clone(comment);
+    },
+
+    async postDecision(id, answer) {
+      await delay();
+      const card = find(id);
+      if (!card) throw httpError(404, `Card ${id} not found`);
+      if (card.status !== "decision_needed")
+        throw httpError(409, `Card ${id} is not awaiting a decision`);
+      const content = String(answer).trim();
+      if (!content) throw httpError(400, "'answer' is required");
+      const comment = {
+        id: ++db.seq,
+        cardId: id,
+        author: "operator",
+        content: `Decision: ${content}`,
+        createdAt: nowIso(),
+      };
+      (db.comments[id] ||= []).push(comment);
+      // Mirrors the backend: the answer is recorded onto the retained ask and the
+      // card resumes to backlog (buildBacklogResumePatch) so the worker picks it up.
+      if (card.ask) card.ask = { ...card.ask, answer: content, answeredAt: nowIso() };
+      card.status = "backlog";
+      card.workerThreadId = null;
+      card.blockedReason = null;
+      card.nextSpawnAt = null;
+      card.updatedAt = nowIso();
+      return clone(card);
+    },
+
+    async listLaneGroups() {
+      await delay();
+      return clone(db.laneGroups);
+    },
+
+    async getProfiles() {
+      await delay();
+      return clone(db.profiles);
+    },
+
+    // Upsert a named profile by id into the same store getProfiles reads, so a
+    // saved profile is available offline and a re-save (same id) updates in place.
+    async saveProfile(input) {
+      await delay();
+      const id = String(input.id || "").trim();
+      const name = String(input.name || "").trim();
+      if (!id || !name) throw httpError(400, "non-empty 'id' and 'name' are required");
+      if (db.profiles.some((profile) => profile.id !== id && profile.name === name)) {
+        throw httpError(400, "A profile with this name already exists");
+      }
+      const saved = { id, name, profile: clone(input.profile || {}), builtin: false };
+      const index = db.profiles.findIndex((profile) => profile.id === id);
+      if (index === -1) db.profiles.push(saved);
+      else db.profiles[index] = saved;
+      return clone(saved);
+    },
+
+    async threadRunning(threadId) {
+      await delay();
+      // A worker referenced by an in_progress fixture card is "running".
+      return db.cards.some((c) => c.status === "in_progress" && c.workerThreadId === threadId);
+    },
+
+    async threadLogs(threadId, { view = "assistant", offset = 0, limit = 4000 } = {}) {
+      await delay();
+      const text = fixtures.threadLogs[view === "full" ? "full" : "assistant"];
+      const start = Math.max(0, Number(offset) || 0);
+      const size = Math.max(1, Number(limit) || 4000);
+      const end = Math.max(0, text.length - start);
+      const chunk = text.slice(Math.max(0, end - size), end);
+      const nextOffset = start + chunk.length;
+      return clone({
+        threadId,
+        text: chunk,
+        offset: start,
+        nextOffset,
+        hasMore: nextOffset < text.length,
+        totalLength: text.length,
+      });
+    },
+
+    // Card-builder "How" step schema + presets. Sourced from the EDITABLE
+    // design-layer file schema/policy.js so a designer can tune the controls and
+    // see them live in preview; production uses the matching board-policy endpoint.
+    async getPolicySchema() {
+      await delay();
+      return clone(POLICY_SCHEMA);
+    },
+
+    async getPresets() {
+      await delay();
+      return clone(PRESETS);
+    },
+
+    async createLaneGroup(name) {
+      await delay();
+      if (!name || !name.trim()) throw httpError(400, "'name' is required");
+      const laneGroup = { groupId: ++db.seq, name: name.trim(), position: 0, createdAt: nowIso() };
+      db.laneGroups.push(laneGroup);
+      return clone(laneGroup);
+    },
+
+    async updateLaneGroup(id, patch) {
+      await delay();
+      const name = typeof patch.name === "string" ? patch.name.trim() : "";
+      if (!name) throw httpError(400, "non-empty 'name' is required");
+      const laneGroup = db.laneGroups.find((group) => group.groupId === id);
+      if (!laneGroup) throw httpError(404, `Lane group ${id} not found`);
+      laneGroup.name = name;
+      return clone(laneGroup);
+    },
+
+    async deleteLaneGroup(id) {
+      await delay();
+      if (!findLaneGroup(id)) throw httpError(404, `Lane group ${id} not found`);
+      const used = db.cards.filter((card) => card.laneGroupId === id).length;
+      if (used) throw httpError(409, `Lane group has ${used} card(s) — move or delete them first`);
+      const i = db.laneGroups.findIndex((group) => group.groupId === id);
+      db.laneGroups.splice(i, 1);
+    },
+
+    // One filesystem level from the preview dir tree — mirrors the real
+    // GET /api/board/dir-listing (roots when path is empty).
+    async listDir(path) {
+      await delay();
+      guardScenario();
+      if (!path) {
+        const entries = dirTree.map(({ name, path }) => ({ name, path }));
+        return { path: "", parent: null, entries };
+      }
+      const node = locateDir(dirTree, path);
+      if (!node) throw httpError(400, "path must be an absolute directory");
+      const entries = (node.children || []).map(({ name, path }) => ({ name, path }));
+      return { path, parent: parentDir(path), entries };
+    },
+  };
+}
+
+/** @type {BoardApi} */
+export const mockApi = createMockApi();