sensorium-mcp 3.1.2 → 3.1.3-board.10

package/dist/board/state/useBuilder.test.ts

@@ -0,0 +1,468 @@
+import assert from "node:assert/strict";
+import test, { type TestContext } from "node:test";
+
+import type { ExecutionProfile, NamedProfile } from "../api/contract.js";
+import { evaluateField, profileFromHow, slugifyProfileName, useBuilder } from "./useBuilder.js";
+
+/**
+ * A single-slot fake for the debounce timer: setTimeout stores the pending
+ * callback, clearTimeout drops it, and fire() runs it once (one-shot, like a
+ * real timeout). A rescheduled debounce clears the previous slot first, so at
+ * most one callback is ever pending — exactly what the composable relies on.
+ */
+function fakeTimers() {
+  let pending: { id: number; cb: () => void } | undefined;
+  let nextId = 1;
+  return {
+    setTimeout: (cb: () => void) => {
+      const id = nextId++;
+      pending = { id, cb };
+      return id;
+    },
+    clearTimeout: (id: number) => {
+      if (pending && pending.id === id) pending = undefined;
+    },
+    fire() {
+      if (!pending) throw new Error("no pending debounce timer to fire");
+      const { cb } = pending;
+      pending = undefined;
+      cb();
+    },
+  };
+}
+
+type PreviewOutcome = string | Promise<string> | Error;
+
+/**
+ * A programmable previewBriefing stub that replays an ordered list of outcomes —
+ * a briefing string, a pending promise (to control in-flight timing), or an
+ * Error to reject with — one per call, in call order. Lets a test arrange
+ * "in-flight then superseded" without hand-rolling a call counter in the body.
+ */
+function previewFeed(outcomes: PreviewOutcome[]) {
+  const queue = [...outcomes];
+  let calls = 0;
+  return {
+    api: {
+      previewBriefing: async () => {
+        calls += 1;
+        const outcome = queue.shift();
+        if (outcome === undefined) throw new Error("previewFeed ran out of scripted responses");
+        if (outcome instanceof Error) throw outcome;
+        return outcome;
+      },
+    },
+    get calls() {
+      return calls;
+    },
+  };
+}
+
+/**
+ * A programmable saveProfile stub: it records every input it receives and replays
+ * a single scripted outcome — the saved NamedProfile to resolve with, or an Error
+ * to reject with. Lets a test assert the exact call shape (id/name/profile) or the
+ * failure path without a hand-rolled counter in the body.
+ */
+function saveFeed(outcome: NamedProfile | Error) {
+  const calls: Array<{ id: string; name: string; profile: ExecutionProfile }> = [];
+  return {
+    api: {
+      saveProfile: async (input: { id: string; name: string; profile: ExecutionProfile }) => {
+        calls.push(input);
+        if (outcome instanceof Error) throw outcome;
+        return outcome;
+      },
+    },
+    calls,
+  };
+}
+
+/**
+ * Build a directly-mounted builder store wired to the scripted save feed. The
+ * preview watcher is a live resource, so its teardown is registered here via
+ * t.after — the test body stays free of cleanup calls.
+ */
+function openSavingBuilder(t: TestContext, outcome: NamedProfile | Error) {
+  const feed = saveFeed(outcome);
+  const store = useBuilder({ api: feed.api, timers: fakeTimers() });
+  t.after(() => store.stopPreview());
+  return { store, feed };
+}
+
+function deferred() {
+  let resolve!: (value: string) => void;
+  const promise = new Promise<string>((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+function flush() {
+  return new Promise<void>((resolve) => setImmediate(resolve));
+}
+
+/**
+ * Build a directly-mounted builder store wired to the scripted preview feed and
+ * a fake debounce timer. Teardown (stop the watcher + pending timer) is
+ * registered here via t.after, so every test body stays free of cleanup calls.
+ */
+function openBuilder(t: TestContext, outcomes: PreviewOutcome[]) {
+  const timers = fakeTimers();
+  const feed = previewFeed(outcomes);
+  const store = useBuilder({ api: feed.api, timers });
+  t.after(() => store.stopPreview());
+  return { store, timers, feed };
+}
+
+test("useBuilder load keys named profiles by id", async (t) => {
+  const store = useBuilder({
+    api: {
+      listLaneGroups: async () => [],
+      getProfiles: async () => [
+        { id: "default", name: "Default", profile: { runTests: true }, builtin: true },
+        { id: "research", name: "Research", profile: { runTests: false }, builtin: true },
+      ],
+    },
+    timers: fakeTimers(),
+  });
+  t.after(() => store.stopPreview());
+
+  await store.load();
+
+  assert.deepEqual(store.profiles.value, {
+    default: { runTests: true },
+    research: { runTests: false },
+  });
+});
+
+test("useBuilder debounces rapid draft edits into a single preview compile", async (t) => {
+  // Three keystrokes before the debounce elapses must yield ONE endpoint call.
+  const { store, timers, feed } = openBuilder(t, ["briefing"]);
+
+  store.draft.title = "M";
+  await flush();
+  store.draft.title = "Mi";
+  await flush();
+  store.draft.title = "Migrate";
+  await flush();
+  timers.fire();
+  await flush();
+
+  assert.equal(feed.calls, 1);
+});
+
+test("useBuilder exposes the compiled briefing as preview.text", async (t) => {
+  const { store, timers } = openBuilder(t, ["# Task Board card (preview): Migrate auth"]);
+
+  store.draft.title = "Migrate auth";
+  await flush();
+  timers.fire();
+  await flush();
+
+  assert.equal(store.preview.text, "# Task Board card (preview): Migrate auth");
+});
+
+test("useBuilder raises preview.loading while a compile is in flight", async (t) => {
+  const inFlight = deferred();
+  const { store, timers } = openBuilder(t, [inFlight.promise]);
+
+  store.draft.title = "x";
+  await flush();
+  timers.fire();
+  await flush();
+
+  assert.equal(store.preview.loading, true);
+});
+
+test("useBuilder lowers preview.loading once the compile settles", async (t) => {
+  const inFlight = deferred();
+  const { store, timers } = openBuilder(t, [inFlight.promise]);
+  store.draft.title = "x";
+  await flush();
+  timers.fire();
+  await flush();
+
+  inFlight.resolve("done");
+  await flush();
+
+  assert.equal(store.preview.loading, false);
+});
+
+test("useBuilder surfaces a failed compile as preview.error", async (t) => {
+  const { store, timers } = openBuilder(t, [new Error("preview offline")]);
+
+  store.draft.title = "x";
+  await flush();
+  timers.fire();
+  await flush();
+
+  assert.equal(store.preview.error, "preview offline");
+});
+
+test("useBuilder ignores a stale compile that resolves after a newer draft", async (t) => {
+  // The first (slow) compile must not overwrite the newer draft's briefing.
+  const stale = deferred();
+  const { store, timers } = openBuilder(t, [stale.promise, "fresh-briefing"]);
+  store.draft.title = "v1";
+  await flush();
+  timers.fire(); // gen 1 — left in flight on stale.promise
+  await flush();
+  store.draft.title = "v2";
+  await flush();
+  timers.fire(); // gen 2 — resolves immediately with "fresh-briefing"
+  await flush();
+
+  stale.resolve("stale-briefing"); // late, superseded
+  await flush();
+
+  assert.equal(store.preview.text, "fresh-briefing");
+});
+
+test("profileFromHow maps the verifyDone toggle into the profile", () => {
+  const profile = profileFromHow({ verifyDone: true });
+
+  assert.equal(profile.verifyDone, true);
+});
+
+test("profileFromHow keeps the model alias when its showWhen holds (provider Claude)", () => {
+  const fields = [{ key: "model", showWhen: { key: "provider", equals: "Claude" } }];
+
+  const profile = profileFromHow({ provider: "Claude", model: "  claude-opus-4-8  " }, fields);
+
+  assert.equal(profile.model, "claude-opus-4-8");
+});
+
+test("profileFromHow drops the model alias when its showWhen is unmet (provider not Claude)", () => {
+  // The model field's showWhen hides it off Claude, so a leftover alias from
+  // before a provider switch is never persisted for Copilot/Codex.
+  const fields = [{ key: "model", showWhen: { key: "provider", equals: "Claude" } }];
+
+  const profile = profileFromHow({ provider: "Copilot", model: "claude-opus-4.8" }, fields);
+
+  assert.ok(!("model" in profile));
+});
+
+test("profileFromHow skips any control whose field is hidden by showWhen, keyed off the field key", () => {
+  // Generic, not model-specific: worktree is dropped purely because its own
+  // showWhen is unmet — the engine never special-cases a field key.
+  const fields = [{ key: "worktree", showWhen: { key: "autonomy", equals: "Collaborative" } }];
+
+  const profile = profileFromHow({ worktree: true, autonomy: "Autonomous" }, fields);
+
+  assert.ok(!("worktree" in profile));
+});
+
+test("profileFromHow with no schema fields imposes no constraints and persists every control", () => {
+  const profile = profileFromHow({ provider: "Copilot", model: "gpt-5.2", worktree: true }, []);
+
+  assert.deepEqual(profile, { agentType: "copilot", model: "gpt-5.2", worktree: true });
+});
+
+test("profileFromHow maps Ephemeral memory to just its mode", () => {
+  const profile = profileFromHow({ memory: { mode: "Ephemeral", threadId: null } });
+
+  assert.deepEqual(profile.memory, { mode: "Ephemeral" });
+});
+
+test("profileFromHow strips the transient auto/_id keys from mapped phases", () => {
+  const profile = profileFromHow({
+    phases: [
+      { name: "Plan", review: true, provider: "Inherit", model: "", auto: false, _id: "ph1" },
+    ],
+  });
+
+  assert.deepEqual(profile.phases, [
+    { name: "Plan", review: true, provider: "Inherit", model: "" },
+  ]);
+});
+
+test("profileFromHow drops the synthetic auto Review row the widget inserts for display", () => {
+  // Toggling review inserts a visual-only {name:"Review", auto:true} row after the
+  // parent; it must never persist — the parent's review:true already encodes it.
+  const profile = profileFromHow({
+    phases: [
+      { name: "Plan", review: true, provider: "Inherit", model: "" },
+      { name: "Review", review: false, provider: "Inherit", model: "", auto: true },
+    ],
+  });
+
+  assert.deepEqual(profile.phases, [
+    { name: "Plan", review: true, provider: "Inherit", model: "" },
+  ]);
+});
+
+test("profileFromHow drops a half-added phase row whose name is blank", () => {
+  const profile = profileFromHow({
+    phases: [
+      { name: "Implement", review: false, provider: "Claude", model: "" },
+      { name: "   ", review: false, provider: "Inherit", model: "" },
+    ],
+  });
+
+  assert.deepEqual(profile.phases, [
+    { name: "Implement", review: false, provider: "Claude", model: "" },
+  ]);
+});
+
+test("profileFromHow omits phases entirely when every row is blank", () => {
+  const profile = profileFromHow({
+    phases: [{ name: "", review: false, provider: "Inherit", model: "" }],
+  });
+
+  assert.ok(!("phases" in profile));
+});
+
+test("evaluateField shows a field with no constraints and leaves it enabled", () => {
+  const result = evaluateField({}, {});
+
+  assert.deepEqual(result, { visible: true, disabled: false, reason: "" });
+});
+
+test("evaluateField hides a field whose showWhen equals condition is unmet", () => {
+  const field = { showWhen: { key: "provider", equals: "Claude" } };
+
+  const result = evaluateField(field, { provider: "Copilot" });
+
+  assert.equal(result.visible, false);
+});
+
+test("evaluateField shows a field whose showWhen equals condition holds", () => {
+  const field = { showWhen: { key: "provider", equals: "Claude" } };
+
+  const result = evaluateField(field, { provider: "Claude" });
+
+  assert.equal(result.visible, true);
+});
+
+test("evaluateField requires every condition of an AND-array showWhen to hold", () => {
+  const field = {
+    showWhen: [
+      { key: "provider", equals: "Claude" },
+      { key: "openPr", equals: true },
+    ],
+  };
+
+  const result = evaluateField(field, { provider: "Claude", openPr: false });
+
+  assert.equal(result.visible, false);
+});
+
+test("evaluateField shows a field when every condition of an AND-array showWhen holds", () => {
+  const field = {
+    showWhen: [
+      { key: "provider", equals: "Claude" },
+      { key: "openPr", equals: true },
+    ],
+  };
+
+  const result = evaluateField(field, { provider: "Claude", openPr: true });
+
+  assert.equal(result.visible, true);
+});
+
+test("evaluateField matches a showWhen `in` condition when the value is one of the options", () => {
+  const field = { showWhen: { key: "provider", in: ["Claude", "Codex"] } };
+
+  const result = evaluateField(field, { provider: "Codex" });
+
+  assert.equal(result.visible, true);
+});
+
+test("evaluateField fails a showWhen `in` condition when the value is not among the options", () => {
+  const field = { showWhen: { key: "provider", in: ["Claude", "Codex"] } };
+
+  const result = evaluateField(field, { provider: "Copilot" });
+
+  assert.equal(result.visible, false);
+});
+
+test("evaluateField honors a legacy visibleIf as showWhen", () => {
+  const field = { visibleIf: { key: "provider", equals: "Claude" } };
+
+  const result = evaluateField(field, { provider: "Copilot" });
+
+  assert.equal(result.visible, false);
+});
+
+test("evaluateField disables a visible field when a requires condition is unmet", () => {
+  const field = { requires: { key: "openPr", equals: true } };
+
+  const result = evaluateField(field, { openPr: false });
+
+  assert.deepEqual(result, { visible: true, disabled: true, reason: "Requires openPr = true" });
+});
+
+test("evaluateField enables a field when its requires condition holds", () => {
+  const field = { requires: { key: "openPr", equals: true } };
+
+  const result = evaluateField(field, { openPr: true });
+
+  assert.equal(result.disabled, false);
+});
+
+test("evaluateField disables a visible field when a conflicts condition holds", () => {
+  const field = { conflicts: { key: "worktree", equals: true } };
+
+  const result = evaluateField(field, { worktree: true });
+
+  assert.deepEqual(result, {
+    visible: true,
+    disabled: true,
+    reason: "Conflicts with worktree = true",
+  });
+});
+
+test("slugifyProfileName kebab-cases a name: lowercase, non-alphanumerics to single dashes, trimmed", () => {
+  assert.equal(slugifyProfileName("Nightly CI"), "nightly-ci");
+  assert.equal(slugifyProfileName("  Bug + Fix!! "), "bug-fix");
+});
+
+test("useBuilder.saveProfile sends the slugified id, trimmed name and profileFromHow profile", async (t) => {
+  const saved: NamedProfile = {
+    id: "nightly-ci",
+    name: "Nightly CI",
+    profile: { verifyDone: true },
+    builtin: false,
+  };
+  const { store, feed } = openSavingBuilder(t, saved);
+
+  await store.saveProfile("  Nightly CI  ", { verifyDone: true });
+
+  assert.deepEqual(feed.calls, [
+    { id: "nightly-ci", name: "Nightly CI", profile: { verifyDone: true } },
+  ]);
+});
+
+test("useBuilder.saveProfile on success records the saved name and merges the profile into profiles.value", async (t) => {
+  const saved: NamedProfile = {
+    id: "nightly-ci",
+    name: "Nightly CI",
+    profile: { verifyDone: true },
+    builtin: false,
+  };
+  const { store } = openSavingBuilder(t, saved);
+
+  await store.saveProfile("Nightly CI", { verifyDone: true });
+
+  assert.equal(store.profileSave.savedName, "Nightly CI");
+  assert.deepEqual(store.profiles.value["nightly-ci"], { verifyDone: true });
+});
+
+test("useBuilder.saveProfile surfaces a rejected save as an error and leaves the saved name empty", async (t) => {
+  const { store } = openSavingBuilder(t, new Error("A profile with this name already exists"));
+
+  await store.saveProfile("Nightly CI", { verifyDone: true });
+
+  assert.equal(store.profileSave.error, "A profile with this name already exists");
+  assert.equal(store.profileSave.savedName, "");
+});
+
+test("useBuilder.saveProfile makes no api call for a blank name", async (t) => {
+  const saved: NamedProfile = { id: "x", name: "x", profile: {}, builtin: false };
+  const { store, feed } = openSavingBuilder(t, saved);
+
+  await store.saveProfile("   ", { verifyDone: true });
+
+  assert.equal(feed.calls.length, 0);
+});

package/dist/board/state/useCard.js

@@ -0,0 +1,193 @@
+/**
+ * Single-card store — card + comments + worker health/log, plus operator actions.
+ * FROZEN SEAM: P3 adds richer logs without changing existing return fields.
+ */
+
+import { onUnmounted, ref } from "../vendor/vue.esm-browser.js";
+import { api } from "../api/api.js";
+
+const LOG_POLL_INTERVAL_MS = 4000;
+const LOG_VISIBLE_STATUSES = new Set(["in_progress", "decision_needed", "blocked", "rate_limited"]);
+
+function logStatus(card, running) {
+  if (card?.status === "blocked") return "HALTED";
+  if (card?.status !== "in_progress") return "PAUSED";
+  return running === false ? "IDLE" : "LIVE";
+}
+
+export function useCard(cardId, dependencies = {}) {
+  const id = Number(cardId);
+  const apiClient = dependencies.api || api;
+  const pollIntervalMs = dependencies.pollIntervalMs || LOG_POLL_INTERVAL_MS;
+  const timers = dependencies.timers || globalThis;
+  const card = ref(null);
+  const comments = ref([]);
+  const running = ref(null);
+  const loading = ref(false);
+  const error = ref(null);
+  // The answer the operator just submitted. Survives the card resuming to
+  // backlog so the view can show an in-place "answer saved" confirmation; a
+  // fresh load() (reopening the card, or any other action) clears it.
+  const submittedDecision = ref(null);
+  const log = ref({ text: "", nextOffset: 0, hasMore: false, status: "PAUSED" });
+  const logView = ref("assistant");
+  // Real fetch state for the designed loading/error/last-updated cues. These are
+  // ADDITIVE seam fields (P3): the existing `log` shape is unchanged.
+  const logLoading = ref(false);
+  const logError = ref(null);
+  const lastUpdated = ref(null);
+  let logTimer = null;
+  let logGen = 0;
+  let loadingOlder = false;
+  let newestLog = { text: "", nextOffset: 0, hasMore: false };
+  let olderLogs = [];
+
+  function canPollLogs() {
+    return !!(card.value && LOG_VISIBLE_STATUSES.has(card.value.status) && card.value.workerThreadId != null);
+  }
+
+  function syncLog() {
+    const lastOlderLog = olderLogs.at(-1);
+    log.value = {
+      text: [newestLog.text, ...olderLogs.map((page) => page.text)].filter(Boolean).join("\n"),
+      nextOffset: lastOlderLog ? lastOlderLog.nextOffset : newestLog.nextOffset,
+      hasMore: lastOlderLog ? lastOlderLog.hasMore : newestLog.hasMore,
+      status: logStatus(card.value, running.value),
+    };
+  }
+
+  function resetLogPages() {
+    newestLog = { text: "", nextOffset: 0, hasMore: false };
+    olderLogs = [];
+    syncLog();
+  }
+
+  // A response is stale once the view/thread/generation moved on while it was in
+  // flight; a stale response must never clobber newer state (log OR fetch flags).
+  function isStaleLog(gen, view, thread) {
+    return gen !== logGen || view !== logView.value || thread !== card.value?.workerThreadId;
+  }
+
+  // `silent` background polls refresh the log WITHOUT raising logLoading, so a
+  // live-but-empty log never blinks its "no output yet" panel to the loading
+  // skeleton every tick. Only foreground fetches (first load, view switch, retry)
+  // drive the loading state; logError/lastUpdated are still updated either way.
+  async function fetchLog(offset = 0, { silent = false } = {}) {
+    if (!canPollLogs()) return;
+    const gen = logGen;
+    const view = logView.value;
+    const thread = card.value.workerThreadId;
+    const isNewest = offset === 0;
+    const showLoading = isNewest && !silent;
+    if (showLoading) logLoading.value = true;
+    try {
+      const result = await apiClient.threadLogs(thread, { view, offset });
+      if (isStaleLog(gen, view, thread)) return;
+      if (isNewest) {
+        newestLog = result;
+      } else {
+        olderLogs.push(result);
+      }
+      syncLog();
+      logError.value = null;
+      lastUpdated.value = new Date().toISOString();
+    } catch (e) {
+      // Surface the failure instead of swallowing it, but keep the poll loop
+      // alive — the next tick may recover. A stale rejection is ignored.
+      if (isStaleLog(gen, view, thread)) return;
+      logError.value = (e && e.message) || String(e);
+    } finally {
+      if (showLoading && !isStaleLog(gen, view, thread)) logLoading.value = false;
+    }
+  }
+
+  function stopLogPolling() {
+    logGen += 1;
+    if (logTimer) timers.clearInterval(logTimer);
+    logTimer = null;
+  }
+
+  function startLogPolling() {
+    stopLogPolling();
+    if (!canPollLogs()) return;
+    // Foreground first fetch drives the loading skeleton; interval polls refresh
+    // silently so an empty log's panel never flashes back to the skeleton.
+    // fetchLog owns its own error handling now (it sets logError, never rejects),
+    // so callers no longer swallow failures blindly.
+    fetchLog();
+    logTimer = timers.setInterval(() => fetchLog(0, { silent: true }), pollIntervalMs);
+  }
+
+  // Re-fetch the newest page for the current view after a failure. Bumps the
+  // generation so any in-flight (failing) poll can't clobber the retry result.
+  async function retryLog() {
+    logGen += 1;
+    await fetchLog();
+  }
+
+  async function setLogView(view) {
+    logGen += 1;
+    logView.value = view === "full" ? "full" : "assistant";
+    resetLogPages();
+    await fetchLog();
+  }
+
+  async function loadOlderLogs() {
+    if (loadingOlder || !log.value.hasMore) return;
+    loadingOlder = true;
+    try {
+      await fetchLog(log.value.nextOffset);
+    } finally {
+      loadingOlder = false;
+    }
+  }
+
+  async function load() {
+    logGen += 1;
+    stopLogPolling();
+    resetLogPages();
+    submittedDecision.value = null;
+    logError.value = null;
+    lastUpdated.value = null;
+    logLoading.value = false;
+    loading.value = true;
+    error.value = null;
+    try {
+      const detail = await apiClient.getCard(id);
+      card.value = detail.card;
+      comments.value = detail.comments;
+      if (detail.card.status === "in_progress" && detail.card.workerThreadId != null) {
+        running.value = await apiClient.threadRunning(detail.card.workerThreadId).catch(() => null);
+      } else {
+        running.value = null;
+      }
+      syncLog();
+      startLogPolling();
+    } catch (e) {
+      error.value = (e && e.message) || String(e);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  const actions = {
+    reload: load,
+    retryLog,
+    comment: async (content) => { await apiClient.addComment(id, content); await load(); },
+    decide: async (answer) => {
+      const submitted = String(answer);
+      await apiClient.postDecision(id, answer);
+      await load();
+      submittedDecision.value = submitted;
+    },
+    move: async (status) => { await apiClient.updateCard(id, { status }); await load(); },
+    stop: async () => { await apiClient.stopCard(id); await load(); },
+    archive: async () => { await apiClient.updateCard(id, { archivedAt: new Date().toISOString() }); await load(); },
+    remove: async () => { await apiClient.deleteCard(id); },
+    save: async (patch) => { await apiClient.updateCard(id, patch); await load(); },
+  };
+
+  onUnmounted(stopLogPolling);
+
+  return { card, comments, running, loading, error, submittedDecision, load, log, logView, setLogView, loadOlderLogs, logLoading, logError, lastUpdated, startLogPolling, stopLogPolling, actions };
+}