sensorium-mcp 3.1.2 → 3.1.3-board.2

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 with the Bearer token.
+ *   'preview'    → mock adapter over fixtures (Claude Design sandbox); auth is a
+ *                  no-op 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,193 @@
+/**
+ * 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 } from "./fixtures.js";
+import { POLICY_SCHEMA, PRESETS } from "../schema/policy.js";
+
+const clone = (x) => JSON.parse(JSON.stringify(x));
+
+const scenario = (() => {
+  try {
+    return new URLSearchParams(location.search).get("mock") || "default";
+  } catch {
+    return "default";
+  }
+})();
+
+const db = {
+  lanes: clone(fixtures.lanes),
+  cards: scenario === "empty" ? [] : clone(fixtures.cards),
+  comments: clone(fixtures.comments),
+  profiles: clone(fixtures.profiles),
+  seq: 1000,
+};
+
+const delay = (v) => new Promise((r) => setTimeout(() => r(v), 120));
+const nowIso = () => new Date().toISOString();
+const find = (id) => db.cards.find((c) => c.cardId === id);
+
+function guardScenario() {
+  if (scenario === "error") throw new Error("Simulated preview error (?mock=error)");
+}
+
+/** @type {BoardApi} */
+export const mockApi = {
+  async listCards({ includeArchived = false, lane } = {}) {
+    await delay();
+    guardScenario();
+    let cards = db.cards.filter((c) => (includeArchived ? true : !c.archivedAt));
+    if (lane != null) cards = cards.filter((c) => c.laneThreadId === lane);
+    return clone(cards);
+  },
+
+  async getCard(id) {
+    await delay();
+    const card = find(id);
+    if (!card) throw new Error(`Card ${id} not found`);
+    return clone({ card, comments: db.comments[id] || [] });
+  },
+
+  async createCard(input) {
+    await delay();
+    if (!input.title || !input.title.trim()) throw new Error("'title' is required");
+    if (input.laneThreadId == null) throw new Error("integer 'laneThreadId' is required");
+    const id = ++db.seq;
+    const card = {
+      cardId: id,
+      title: input.title.trim(),
+      description: input.description || "",
+      acceptance: input.acceptance || "",
+      type: input.type || "chore",
+      laneThreadId: input.laneThreadId,
+      priority: input.priority || 0,
+      status: "backlog",
+      profile: input.profile || db.profiles[input.type || "chore"] || {},
+      escalate: input.escalate === true,
+      recurDelayMin: input.recurDelayMin ?? null,
+      recurGroupId: null,
+      nextSpawnAt: null,
+      workerThreadId: null,
+      blockedReason: null,
+      archivedAt: null,
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+      startedAt: null,
+      finishedAt: null,
+    };
+    db.cards.push(card);
+    return clone(card);
+  },
+
+  async updateCard(id, patch) {
+    await delay();
+    const card = find(id);
+    if (!card) throw new Error(`Card ${id} not found`);
+    if ("archivedAt" in patch) card.archivedAt = patch.archivedAt === null ? null : nowIso();
+    for (const k of ["title", "description", "acceptance", "type", "laneThreadId", "priority", "escalate", "status"]) {
+      if (k in patch && patch[k] !== undefined) card[k] = patch[k];
+    }
+    if (patch.status === "backlog") {
+      card.workerThreadId = null;
+      card.blockedReason = null;
+    } else if (patch.status === "done") {
+      card.finishedAt = nowIso();
+      card.workerThreadId = null;
+    }
+    card.updatedAt = nowIso();
+    return clone(card);
+  },
+
+  async deleteCard(id) {
+    await delay();
+    const i = db.cards.findIndex((c) => c.cardId === id);
+    if (i >= 0) db.cards.splice(i, 1);
+    delete db.comments[id];
+  },
+
+  async stopCard(id) {
+    await delay();
+    const card = find(id);
+    if (!card) throw new Error(`Card ${id} not found`);
+    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);
+    if (!card) throw new Error(`Card ${id} not found`);
+    const comment = { id: ++db.seq, cardId: id, author: "operator", content, createdAt: nowIso() };
+    (db.comments[id] ||= []).push(comment);
+    return clone(comment);
+  },
+
+  async listLanes() {
+    await delay();
+    return clone(db.lanes);
+  },
+
+  async getProfiles() {
+    await delay();
+    return clone(db.profiles);
+  },
+
+  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);
+  },
+
+  // 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 wiring is a P1 TODO in api/client.js.)
+  async getPolicySchema() {
+    await delay();
+    return clone(POLICY_SCHEMA);
+  },
+
+  async getPresets() {
+    await delay();
+    return clone(PRESETS);
+  },
+
+  // Lane management. Delete is refused while any card (incl. archived) is on
+  // the lane — mirrors the real board rule.
+  async createLane(name) {
+    await delay();
+    if (!name || !name.trim()) throw new Error("'name' is required");
+    const lane = { threadId: ++db.seq, name: name.trim(), connected: false, maxConcurrent: 1 };
+    db.lanes.push(lane);
+    return clone(lane);
+  },
+
+  async updateLane(id, patch) {
+    await delay();
+    const lane = db.lanes.find((l) => l.threadId === id);
+    if (!lane) throw new Error(`Lane ${id} not found`);
+    if (patch.name != null && String(patch.name).trim()) lane.name = String(patch.name).trim();
+    return clone(lane);
+  },
+
+  async deleteLane(id) {
+    await delay();
+    const used = db.cards.filter((c) => c.laneThreadId === id).length;
+    if (used) throw new Error(`Lane has ${used} card(s) — move or delete them first`);
+    const i = db.lanes.findIndex((l) => l.threadId === id);
+    if (i >= 0) db.lanes.splice(i, 1);
+  },
+};

package/dist/board/mock/fixtures.js

@@ -0,0 +1,164 @@
+/**
+ * Preview fixtures.  ❌ FROZEN DATA (not UI) — fixture changes go through a coding
+ * worker so preview stays honest to the real API shapes. Card objects match
+ * src/data/board/board-types.ts `BoardCard` exactly; lanes match the GET
+ * /api/board/lanes decorated shape (`name` added).
+ *
+ * Covers EVERY kanban column so all screens render standalone from mocks:
+ * backlog, in_progress (with worker), decision_needed, blocked, done + one
+ * archived card (visible only with "include archived").
+ */
+
+const T0 = "2026-08-08T09:00:00.000Z";
+const T1 = "2026-08-08T12:30:00.000Z";
+const T2 = "2026-08-08T14:05:00.000Z";
+
+/** @param {Partial<import('../api/contract.js').BoardCard>} o */
+function card(o) {
+  return {
+    cardId: 0,
+    title: "",
+    description: "",
+    acceptance: "",
+    type: "chore",
+    laneThreadId: 101,
+    priority: 0,
+    status: "backlog",
+    profile: {},
+    escalate: false,
+    recurDelayMin: null,
+    recurGroupId: null,
+    nextSpawnAt: null,
+    workerThreadId: null,
+    blockedReason: null,
+    archivedAt: null,
+    createdAt: T0,
+    updatedAt: T0,
+    startedAt: null,
+    finishedAt: null,
+    ...o,
+  };
+}
+
+export const fixtures = {
+  lanes: [
+    { threadId: 101, connected: true, maxConcurrent: 2, createdAt: T0, name: "Frontend Lane" },
+    { threadId: 202, connected: true, maxConcurrent: 1, createdAt: T0, name: "Backend Lane" },
+    { threadId: 303, connected: false, maxConcurrent: 1, createdAt: T0, name: "Research Lane" },
+  ],
+
+  cards: [
+    card({
+      cardId: 1,
+      title: "Add dark-mode toggle to settings",
+      description: "Persist the choice in localStorage and honour prefers-color-scheme on first load.",
+      acceptance: "Toggle flips theme instantly; choice survives reload; no FOUC.",
+      type: "feature",
+      laneThreadId: 101,
+      priority: 2,
+      status: "backlog",
+      profile: { agentType: "claude", createBranch: true, runTests: true, openPr: true, expertReview: true, push: true, ciCheck: "github" },
+    }),
+    card({
+      cardId: 2,
+      title: "Bump eslint to v10 and fix new violations",
+      description: "Upgrade eslint + config, resolve the handful of new lint errors.",
+      acceptance: "npm run lint passes clean on CI.",
+      type: "tech-debt",
+      laneThreadId: 202,
+      priority: 0,
+      status: "backlog",
+      profile: { agentType: "claude", createBranch: true, runTests: true },
+    }),
+    card({
+      cardId: 3,
+      title: "Investigate intermittent worker hang on spawn",
+      description: "A worker occasionally never emits STARTED. Reproduce, find the root cause, propose a fix.",
+      acceptance: "Root cause identified with evidence; fix plan attached as a comment.",
+      type: "bug",
+      laneThreadId: 202,
+      priority: 3,
+      status: "in_progress",
+      workerThreadId: 9901,
+      startedAt: T1,
+      profile: { agentType: "claude", createBranch: true, runTests: true, expertReview: true },
+    }),
+    card({
+      cardId: 4,
+      title: "Choose analytics vendor for usage metrics",
+      description: "Compare 3 options against privacy + cost constraints. Needs an operator call before build.",
+      acceptance: "A vendor is chosen and rationale recorded.",
+      type: "research",
+      laneThreadId: 303,
+      priority: 1,
+      status: "decision_needed",
+      startedAt: T1,
+      finishedAt: T2,
+      profile: { agentType: "claude" },
+    }),
+    card({
+      cardId: 5,
+      title: "Migrate payments module to new SDK",
+      description: "Blocked on an upstream dependency that has not shipped the 4.x release yet.",
+      acceptance: "All payment flows pass integration tests on the new SDK.",
+      type: "feature",
+      laneThreadId: 202,
+      priority: 2,
+      status: "blocked",
+      blockedReason: "Upstream SDK 4.x not released; waiting on vendor.",
+      profile: { agentType: "claude", createBranch: true, runTests: true, openPr: true },
+    }),
+    card({
+      cardId: 6,
+      title: "Document the board-front isolation contract",
+      description: "Write the CLAUDE.md guardrail describing editable vs frozen folders.",
+      acceptance: "Guardrail file present and accurate.",
+      type: "chore",
+      laneThreadId: 101,
+      priority: 0,
+      status: "done",
+      startedAt: T0,
+      finishedAt: T1,
+      profile: { agentType: "claude" },
+    }),
+    card({
+      cardId: 7,
+      title: "Old spike: prototype swipe gestures",
+      description: "Archived experiment kept for reference.",
+      acceptance: "n/a",
+      type: "research",
+      laneThreadId: 101,
+      priority: 0,
+      status: "done",
+      startedAt: T0,
+      finishedAt: T0,
+      archivedAt: T1,
+      profile: {},
+    }),
+  ],
+
+  /** Keyed by cardId. */
+  comments: {
+    3: [
+      { id: 1, cardId: 3, author: "board", content: "Card dispatched to worker thread 9901.", createdAt: T1 },
+      { id: 2, cardId: 3, author: "worker", content: "Reproduced once in 40 runs. Adding instrumentation around the spawn barrier.", createdAt: T2 },
+    ],
+    4: [
+      { id: 3, cardId: 4, author: "worker", content: "Shortlisted 3 vendors; two meet the privacy bar. Need an operator decision on cost tier.", createdAt: T2 },
+    ],
+    5: [
+      { id: 4, cardId: 5, author: "operator", content: "Parking this until the SDK ships.", createdAt: T1 },
+    ],
+    6: [{ id: 5, cardId: 6, author: "operator", content: "Looks good — merged.", createdAt: T1 }],
+  },
+
+  /** Mirrors GET /api/board/profiles (effective per-type templates). */
+  profiles: {
+    bug: { createBranch: true, runTests: true, openPr: true, expertReview: true, push: true, ciCheck: "github", workerSplit: "single" },
+    feature: { createBranch: true, runTests: true, build: true, openPr: true, expertReview: true, push: true, ciCheck: "github", workerSplit: "single" },
+    "tech-debt": { createBranch: true, runTests: true, openPr: true, expertReview: false, push: true, ciCheck: "github", workerSplit: "single" },
+    chore: { createBranch: false, runTests: false, openPr: false, expertReview: false, push: false, ciCheck: "none", workerSplit: "single" },
+    research: { createBranch: false, runTests: false, openPr: false, expertReview: false, push: false, ciCheck: "none", workerSplit: "single" },
+    "recurring-ops": { createBranch: false, runTests: false, openPr: false, expertReview: false, push: false, ciCheck: "none", workerSplit: "single" },
+  },
+};

package/dist/board/schema/policy.js

@@ -0,0 +1,192 @@
+/**
+ * Card-builder "How" policy schema.  ✅ EDITABLE design-layer data.
+ *
+ * This is the single source of truth for the builder Step 2 ("How") controls.
+ * A designer (Claude Design) edits the option lists / presets / phases here and
+ * sees them live in the buildless preview — no build step, no code change in the
+ * view. views/BuilderView.js renders this GENERICALLY: only the widget *types*
+ * below are hardcoded (in the view's dispatch), never the options themselves.
+ *
+ * It flows to the view through the frozen seam (mock/api.mock.js → useBuilder()),
+ * so this file is design-tier just like views/ and components/ — NOT frozen.
+ *
+ * ── Widget vocabulary (the only hardcoded part) ──────────────────────────────
+ *   "select"    — single choice from `options` (dropdown)
+ *   "segmented" — single choice from `options` (button group)
+ *   "chips"     — multi-select subset of `options` (value is an array)
+ *   "toggle"    — boolean on/off switch
+ *   "phases"    — ordered list of [name, reviewFlag] pairs (editable in place)
+ *
+ * ── Field shape ──────────────────────────────────────────────────────────────
+ *   { key, widget, label, desc?, options?, default }
+ *   - key      unique id; also the value key on the compiled policy
+ *   - widget   one of the vocabulary above
+ *   - label    shown to the operator; also the compiled-policy row heading
+ *   - desc     optional helper line (rendered under the label / switch)
+ *   - options  choices for select / segmented / chips (ignored otherwise)
+ *   - default  initial value (chips → array, phases → array of [name, bool])
+ */
+
+/** @typedef {"select"|"segmented"|"chips"|"toggle"|"phases"} PolicyWidget */
+
+/**
+ * Ordered list of How-step fields. Reorder / add / edit freely — the view
+ * iterates this array in order and dispatches on `widget`.
+ * @type {Array<{key:string, widget:PolicyWidget, label:string, desc?:string, options?:string[], default:*}>}
+ */
+export const POLICY_SCHEMA = [
+  {
+    key: "provider",
+    widget: "segmented",
+    label: "Provider",
+    options: ["Claude", "Copilot", "Codex"],
+    default: "Claude",
+  },
+  {
+    key: "model",
+    widget: "select",
+    label: "Worker model",
+    options: ["Claude Haiku · fast", "Claude Sonnet · balanced", "Claude Opus · deep"],
+    default: "Claude Sonnet · balanced",
+  },
+  {
+    key: "skills",
+    widget: "chips",
+    label: "Skills",
+    options: ["Git", "Tests", "Web search", "Docs", "Database", "Design review"],
+    default: ["Git"],
+  },
+  {
+    key: "runIn",
+    widget: "select",
+    label: "Run in",
+    desc: "Where the worker executes",
+    // Base run targets; existing threads are appended by the seam in P1.
+    options: ["New worker", "New persistent thread"],
+    default: "New worker",
+  },
+  {
+    key: "worktree",
+    widget: "toggle",
+    label: "Run in a git worktree",
+    desc: "Isolated branch — nothing touches main until you merge",
+    default: true,
+    // Compiled-policy phrasing (optional; falls back to "on"/"off").
+    onText: "git worktree, merge on approval",
+    offText: "direct on main",
+  },
+  {
+    key: "review",
+    widget: "toggle",
+    label: "Expert code review",
+    desc: "A second model reviews the diff before completion",
+    default: false,
+    onText: "expert pass before completion",
+    offText: "off",
+  },
+  {
+    key: "verifyDone",
+    widget: "toggle",
+    label: "Verify on done",
+    desc: "Check the acceptance criteria before moving to Done (else an ephemeral check)",
+    default: true,
+    onText: "verify acceptance → move to Done → notify you",
+    offText: "off",
+  },
+  {
+    key: "phases",
+    widget: "phases",
+    label: "Phases",
+    desc: "run in order",
+    default: [["Plan", true], ["Implement", false]],
+  },
+];
+
+/**
+ * Presets seed the whole How step (and the card `type`) in one click.
+ * `values` is keyed by POLICY_SCHEMA field `key`; any key omitted falls back to
+ * that field's `default`. Editing a control after applying a preset clears it.
+ *
+ * "Research" demonstrates a phase-less run (`phases: []` → "single pass").
+ * "Full delivery" carries the canonical
+ * Analysis → Plan → Implementation → Expert code review → Commit pipeline.
+ * @type {Array<{name:string, type?:string, values:Object}>}
+ */
+export const PRESETS = [
+  {
+    name: "Bug fix",
+    type: "bug",
+    values: {
+      provider: "Claude",
+      model: "Claude Sonnet · balanced",
+      skills: ["Git", "Tests"],
+      runIn: "New worker",
+      worktree: true,
+      review: true,
+      verifyDone: true,
+      phases: [["Reproduce", false], ["Fix root cause", true], ["Verify", false]],
+    },
+  },
+  {
+    name: "Feature",
+    type: "feature",
+    values: {
+      provider: "Claude",
+      model: "Claude Opus · deep",
+      skills: ["Git", "Tests", "Docs"],
+      runIn: "New worker",
+      worktree: true,
+      review: true,
+      verifyDone: true,
+      phases: [["Plan", true], ["Implement", false], ["Test & document", true]],
+    },
+  },
+  {
+    name: "Full delivery",
+    type: "feature",
+    values: {
+      provider: "Claude",
+      model: "Claude Opus · deep",
+      skills: ["Git", "Tests", "Docs"],
+      runIn: "New persistent thread",
+      worktree: true,
+      review: true,
+      verifyDone: true,
+      phases: [
+        ["Analysis", false],
+        ["Plan", true],
+        ["Implementation", false],
+        ["Expert code review", true],
+        ["Commit", false],
+      ],
+    },
+  },
+  {
+    name: "Research",
+    type: "research",
+    values: {
+      provider: "Claude",
+      model: "Claude Sonnet · balanced",
+      skills: ["Web search", "Docs"],
+      runIn: "New worker",
+      worktree: false,
+      review: false,
+      verifyDone: false,
+      phases: [],
+    },
+  },
+  {
+    name: "Tech debt",
+    type: "tech-debt",
+    values: {
+      provider: "Codex",
+      model: "Claude Sonnet · balanced",
+      skills: ["Git", "Tests"],
+      runIn: "New worker",
+      worktree: true,
+      review: false,
+      verifyDone: true,
+      phases: [["Map current structure", false], ["Migrate incrementally", true]],
+    },
+  },
+];