@polderlabs/bizar 5.2.0 → 5.3.1

package/bizar-dash/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -1 +1 @@
-{"version":"4.1.9","results":[[":tests/lib/utils.test.ts",{"duration":16.303165999999976,"failed":false}],[":tests/components/Button.test.tsx",{"duration":106.694435,"failed":false}],[":tests/components/Card.test.tsx",{"duration":19.81299100000001,"failed":false}],[":tests/hooks/useModal.test.tsx",{"duration":159.28117799999995,"failed":false}],[":tests/components/Toast.test.tsx",{"duration":196.709385,"failed":false}],[":tests/components/Modal.test.tsx",{"duration":196.62032399999998,"failed":false}],[":tests/lib/i18n.test.ts",{"duration":3.903647000000035,"failed":false}],[":tests/components/StatusBadge.test.tsx",{"duration":49.069886,"failed":false}],[":tests/hooks/useToast.test.tsx",{"duration":120.39812900000004,"failed":false}],[":tests/components/Spinner.test.tsx",{"duration":77.51955700000008,"failed":false}],[":tests/backup-restore.test.tsx",{"duration":205.62362600000006,"failed":false}],[":tests/a11y.test.tsx",{"duration":754.295168,"failed":false}],[":tests/lib/search-fuzzy.test.ts",{"duration":5.431500000000028,"failed":false}],[":tests/components/settings-search.test.tsx",{"duration":723.2007870000001,"failed":false}],[":tests/memory-graph-view.test.tsx",{"duration":47.14713799999993,"failed":false}],[":tests/components/workspace-selector.test.tsx",{"duration":152.31454200000007,"failed":false}],[":tests/components/screenshot-ocr.test.tsx",{"duration":54.37460299999998,"failed":false}],[":tests/voice-recorder.test.tsx",{"duration":138.534312,"failed":false}],[":tests/autosave.test.tsx",{"duration":268.9614950000001,"failed":false}],[":tests/settings-layout.test.tsx",{"duration":248.58253200000001,"failed":false}],[":tests/settings-nav.test.tsx",{"duration":311.78257699999995,"failed":false}],[":tests/components/doctor-panel.test.tsx",{"duration":82.92706099999998,"failed":false}],[":tests/chat-composer.test.tsx",{"duration":207.18291899999997,"failed":false}],[":tests/settings-mode-wiring.test.tsx",{"duration":221.4198530000001,"failed":false}],[":tests/minimax-bar.test.ts",{"duration":0,"failed":true}],[":tests/minimax-bar.test.tsx",{"duration":36.76302400000009,"failed":false}],[":tests/components/plugin-permissions.test.tsx",{"duration":104.179755,"failed":false}],[":tests/eval-web-ui.test.tsx",{"duration":152.385127,"failed":false}]]}
+{"version":"4.1.9","results":[[":tests/lib/utils.test.ts",{"duration":15.788036999999974,"failed":false}],[":tests/components/Button.test.tsx",{"duration":84.90294800000004,"failed":false}],[":tests/components/Card.test.tsx",{"duration":18.837508999999955,"failed":false}],[":tests/hooks/useModal.test.tsx",{"duration":120.20212400000003,"failed":false}],[":tests/components/Toast.test.tsx",{"duration":161.860364,"failed":false}],[":tests/components/Modal.test.tsx",{"duration":169.36771700000008,"failed":false}],[":tests/lib/i18n.test.ts",{"duration":2.9599100000000362,"failed":false}],[":tests/components/StatusBadge.test.tsx",{"duration":22.451562999999965,"failed":false}],[":tests/hooks/useToast.test.tsx",{"duration":113.03238799999997,"failed":false}],[":tests/components/Spinner.test.tsx",{"duration":56.80167199999994,"failed":false}],[":tests/backup-restore.test.tsx",{"duration":209.892064,"failed":false}],[":tests/a11y.test.tsx",{"duration":679.8717469999999,"failed":false}],[":tests/lib/search-fuzzy.test.ts",{"duration":5.03047799999996,"failed":false}],[":tests/components/settings-search.test.tsx",{"duration":718.4375819999999,"failed":false}],[":tests/memory-graph-view.test.tsx",{"duration":29.26699000000002,"failed":false}],[":tests/components/workspace-selector.test.tsx",{"duration":120.47785299999998,"failed":false}],[":tests/components/screenshot-ocr.test.tsx",{"duration":27.81256400000001,"failed":false}],[":tests/voice-recorder.test.tsx",{"duration":114.61372900000003,"failed":false}],[":tests/autosave.test.tsx",{"duration":254.917053,"failed":false}],[":tests/settings-layout.test.tsx",{"duration":217.68918099999996,"failed":false}],[":tests/settings-nav.test.tsx",{"duration":290.68972699999995,"failed":false}],[":tests/components/doctor-panel.test.tsx",{"duration":70.02781100000004,"failed":false}],[":tests/chat-composer.test.tsx",{"duration":232.71696299999996,"failed":false}],[":tests/settings-mode-wiring.test.tsx",{"duration":276.79545799999994,"failed":false}],[":tests/minimax-bar.test.ts",{"duration":0,"failed":true}],[":tests/minimax-bar.test.tsx",{"duration":22.24368499999997,"failed":false}],[":tests/components/plugin-permissions.test.tsx",{"duration":92.75674500000002,"failed":false}],[":tests/eval-web-ui.test.tsx",{"duration":117.119639,"failed":false}],[":tests/components/marketplace-plugin-card.test.tsx",{"duration":188.3587500000001,"failed":false}],[":tests/a11y/components.test.tsx",{"duration":127.70726300000001,"failed":false}],[":tests/a11y/forms.test.tsx",{"duration":103.14186000000007,"failed":true}],[":tests/a11y/navigation.test.tsx",{"duration":120.83297300000004,"failed":true}]]}

package/bizar-dash/src/server/auth.mjs

@@ -484,7 +484,20 @@ function extractToken(req) {
  */
 export function getCurrentUserId(req) {
   const token = extractToken(req);
-  if (!token) return null;
+  if (!token) {
+    // v5.3.1 — Tailscale trust: when the dashboard is reached via
+    // tailscale serve and the operator has opted in to trust tailnet
+    // clients, derive a deterministic userId from the tailnet hostname
+    // so the rest of the v5.0 multi-user code paths (workspaces, etc.)
+    // work without requiring an explicit token.
+    if (process.env.BIZAR_DASHBOARD_TRUST_TAILSCALE === '1' && isLoopback(req)) {
+      const hostname = String(req?.headers?.host || '').split(':')[0];
+      if (hostname && hostname.endsWith('.ts.net')) {
+        return 'usr_ts_' + createHash('sha256').update(hostname).digest('hex').slice(0, 12);
+      }
+    }
+    return null;
+  }
 
   const secret = getOrCreateSecret();
 

package/bizar-dash/src/server/eval-store.mjs

@@ -22,6 +22,10 @@ const STORE_HOME = process.env.BIZAR_STORE_HOME
   : join(homedir(), '.local', 'share', 'bizar');
 const EVAL_DIR = join(STORE_HOME, 'eval');
 const INDEX_FILE = join(EVAL_DIR, '.index.json');
+const CONFIG_DIR = process.env.BIZAR_EVAL_CONFIG_DIR
+  ? process.env.BIZAR_EVAL_CONFIG_DIR
+  : join(homedir(), '.config', 'bizar');
+const SCHEDULES_FILE = join(CONFIG_DIR, 'eval-schedules.json');
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -210,6 +214,57 @@ export function buildRunId() {
   return `run_${ts}_${rand}`;
 }
 
+// ── Eval schedules ───────────────────────────────────────────────────────────
+
+function loadSchedules() {
+  return safeReadJSON(SCHEDULES_FILE, []);
+}
+
+function saveSchedulesIndex(schedules) {
+  ensureDir(join(homedir(), '.config', 'bizar'));
+  atomicWriteJson(SCHEDULES_FILE, schedules);
+}
+
+/**
+ * Register a new eval schedule.
+ *
+ * @param {{ name: string, suitePath: string, cron: string, agent?: string }} opts
+ * @returns {{ id: string, name: string, suitePath: string, cron: string, agent: string }}
+ */
+export function registerEvalSchedule({ name, suitePath, cron, agent = 'thor' }) {
+  const schedules = loadSchedules();
+  const id = `eval_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+  const schedule = { id, name, suitePath, cron, agent };
+  schedules.push(schedule);
+  saveSchedulesIndex(schedules);
+  return schedule;
+}
+
+/**
+ * List all eval schedules.
+ *
+ * @returns {Array<{ id: string, name: string, suitePath: string, cron: string, agent: string }>}
+ */
+export function listEvalSchedules() {
+  return loadSchedules();
+}
+
+/**
+ * Delete an eval schedule by id.
+ *
+ * @param {string} id
+ * @returns {{ ok: boolean }}
+ */
+export function deleteEvalSchedule(id) {
+  if (!id) return { ok: false };
+  const schedules = loadSchedules();
+  const idx = schedules.findIndex((s) => s.id === id);
+  if (idx < 0) return { ok: false };
+  schedules.splice(idx, 1);
+  saveSchedulesIndex(schedules);
+  return { ok: true };
+}
+
 // ── Test reset ────────────────────────────────────────────────────────────────
 
 /**

package/bizar-dash/src/server/eval.mjs

@@ -358,6 +358,69 @@ export async function runFixtureById(
   return runFixture(fixture, { llmCall, timeoutMs, toolCalls });
 }
 
+// ── CSV export ────────────────────────────────────────────────────────────────
+
+/**
+ * Convert an array of EvalResult to CSV format.
+ *
+ * @param {object[]} results
+ * @returns {string}
+ */
+export function toCSV(results) {
+  const headers = [
+    'fixture_id',
+    'name',
+    'agent',
+    'ok',
+    'pass_count',
+    'fail_count',
+    'latency_ms',
+    'tokens',
+    'timestamp',
+  ];
+  const rows = results.map((r) => [
+    r.fixtureId,
+    r.name || '',
+    r.agent || '',
+    r.ok ? '1' : '0',
+    r.checks?.filter((c) => c.pass).length || 0,
+    r.checks?.filter((c) => !c.pass).length || 0,
+    r.latencyMs || 0,
+    r.usage?.total_tokens || 0,
+    r.timestamp || '',
+  ]);
+
+  return [headers, ...rows]
+    .map((row) =>
+      row
+        .map((cell) => {
+          const s = String(cell);
+          return s.includes(',') || s.includes('"') || s.includes('\n')
+            ? `"${s.replace(/"/g, '""')}"`
+            : s;
+        })
+        .join(',')
+    )
+    .join('\n');
+}
+
+/**
+ * Run a suite and return both the run result and CSV export.
+ *
+ * @param {string} suitePath
+ * @param {{ llmCall?: Function, concurrency?: number, timeoutMs?: number }} opts
+ * @returns {Promise<{ run: object, csv: string }>}
+ */
+export async function runSuiteAndExport(suitePath, opts) {
+  const run = await runSuite(suitePath, opts);
+  return {
+    run,
+    csv: toCSV(run.results),
+  };
+}
+
+// ── Fixture loading ─────────────────────────────────────────────────────────
+
 /**
  * Load all JSON fixtures from a directory.
  *

package/bizar-dash/src/server/plugins/permission-audit.mjs

@@ -0,0 +1,109 @@
+/**
+ * src/server/plugins/permission-audit.mjs
+ *
+ * v5.3.0 — Audit log for plugin permission uses.
+ *
+ * Every call to `safeInvoke` (and every successful run after the
+ * permission check) emits one entry here. The audit log is in-memory
+ * (bounded to 1000 entries — older entries are evicted FIFO) because
+ * it is meant for live UI ("who invoked what on which plugin in the
+ * last hour") and for incident triage, not for permanent record
+ * keeping. For long-term storage, extend this module with a sink that
+ * writes to disk or to a structured-log aggregator.
+ *
+ * Why a separate module?
+ *   - `sandbox.mjs` stays focused on the execution boundary.
+ *   - `routes/plugins.mjs` and any future admin UI can read the log
+ *     without importing the entire sandbox.
+ *   - Tests can `clearPermissionAuditLog()` between cases.
+ */
+import * as logger from '../logger.mjs';
+
+/** Bounded ring buffer of audit entries; trimmed at 1000. */
+const auditLog = [];
+
+/** Hard cap to bound memory; oldest entries fall off. */
+const MAX_AUDIT_ENTRIES = 1000;
+
+/**
+ * @typedef {{
+ *   timestamp: string,
+ *   pluginId: string,
+ *   method: string,
+ *   permission: string,
+ *   allowed: boolean
+ * }} PermissionAuditEntry
+ */
+
+/**
+ * Record a permission use (allowed or denied) for one method call.
+ *
+ * @param {string} pluginId    plugin identifier (matches `loaded.id` or
+ *                             `installed.id`)
+ * @param {string} method      method name invoked
+ * @param {string} permission  comma-joined permission names that the
+ *                             method was checked against; pass `'none'`
+ *                             if no permissions were required
+ * @param {boolean} allowed    true if the call was allowed, false if it
+ *                             was rejected with permission_denied
+ */
+export function logPermissionUse(pluginId, method, permission, allowed) {
+  const entry = {
+    timestamp: new Date().toISOString(),
+    pluginId: pluginId || 'unknown',
+    method: method || '',
+    permission: permission || 'none',
+    allowed: !!allowed,
+  };
+  auditLog.push(entry);
+  // FIFO eviction — keep memory bounded without losing the most recent
+  // activity, which is what the UI typically wants.
+  while (auditLog.length > MAX_AUDIT_ENTRIES) {
+    auditLog.shift();
+  }
+  logger.info('plugin.permission.use', {
+    module: 'plugin-audit',
+    pluginId: entry.pluginId,
+    method: entry.method,
+    permission: entry.permission,
+    allowed: entry.allowed,
+  });
+}
+
+/**
+ * Read recent audit entries, optionally filtered by plugin.
+ * Returns newest-first so the UI can render a live list directly.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.pluginId]  if set, only entries for this plugin
+ * @param {number} [opts.limit=50]  max entries to return
+ * @returns {PermissionAuditEntry[]}
+ */
+export function getPermissionAuditLog({ pluginId, limit = 50 } = {}) {
+  let entries = auditLog;
+  if (pluginId) {
+    entries = entries.filter((e) => e.pluginId === pluginId);
+  }
+  // `slice(-limit)` gives the last `limit` entries in chronological order;
+  // reversing once gives newest-first for the API consumer.
+  return entries.slice(-limit).reverse();
+}
+
+/**
+ * Wipe all audit entries. Used by tests in `beforeEach` so cases are
+ * isolated. Not exposed via any HTTP route — admin tools that want to
+ * reset the buffer should not exist (the audit log is read-only).
+ */
+export function clearPermissionAuditLog() {
+  auditLog.length = 0;
+}
+
+/**
+ * Test/internal: expose the current entry count so routes can detect
+ * when the buffer was emptied by an outside test runner. Not exported
+ * in the public surface; consumers should treat the audit log as
+ * opaque.
+ */
+export function _permissionAuditLength() {
+  return auditLog.length;
+}

package/bizar-dash/src/server/plugins/sandbox.mjs

@@ -33,6 +33,7 @@ import { readFileSync, statSync } from 'node:fs';
 import { resolve as pathResolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import * as logger from '../logger.mjs';
+import { logPermissionUse } from './permission-audit.mjs';
 
 /** Default timeout for both script compile + async method execution. */
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -380,7 +381,20 @@ function safeStringify(value) {
  * @param {number} [opts.timeoutMs]
  * @param {number} [opts.memoryLimitMb]
  * @param {typeof globalThis.fetch} [opts.fetchImpl]
- * @returns {Promise<Record<string, Function>>}
+ * @param {Array<{ name: string, permissions?: string[] }>} [opts.methodSpecs]
+ *     Per-method permission declarations from `plugin.json`'s
+ *     `exports` array. Each entry is `{ name, permissions }`; used by
+ *     `safeInvoke` to enforce method-level permission checks before
+ *     invoking. Optional — a plugin loaded without this field gets no
+ *     method-level gating (legacy behaviour).
+ * @returns {Promise<{
+ *   exports: Record<string, Function>,
+ *   permissions: Set<string>,
+ *   invalidPermissions: string[],
+ *   memoryLimitMb: number,
+ *   api: object,
+ *   methodSpecs: Array<{ name: string, permissions?: string[] }>
+ * }>}
  */
 export async function loadPlugin(opts) {
   const {
@@ -393,6 +407,7 @@ export async function loadPlugin(opts) {
     timeoutMs = DEFAULT_TIMEOUT_MS,
     memoryLimitMb = DEFAULT_MEMORY_LIMIT_MB,
     fetchImpl,
+    methodSpecs = [],
   } = opts;
 
   if (!mainFile || typeof mainFile !== 'string') {
@@ -494,24 +509,79 @@ export async function loadPlugin(opts) {
     invalidPermissions: invalid,
     memoryLimitMb,
     api,
+    methodSpecs: Array.isArray(methodSpecs) ? methodSpecs : [],
+    // Stash the plugin id on the loaded object so safeInvoke can
+    // write it to the audit log without callers having to thread it
+    // through as a separate argument (compatible with the v5.0
+    // invocation shape).
+    pluginId,
   };
 }
 
+/**
+ * v5.3.0 helper — normalise whatever shape `loaded.permissions` was
+ * stored as into a plain array. `loadPlugin` uses a `Set` internally,
+ * but tests may pass an `Array`, and `loaded.permissions` may also be
+ * missing entirely (older callers). Always returns an array of strings.
+ *
+ * @param {unknown} perms
+ * @returns {string[]}
+ */
+function permissionsAsArray(perms) {
+  if (!perms) return [];
+  if (perms instanceof Set) return [...perms];
+  if (Array.isArray(perms)) return perms.filter((p) => typeof p === 'string');
+  return [];
+}
+
 /**
  * Invoke a method on a loaded plugin inside a sandbox timeout race.
  * Returns `{ ok: true, result }` on success, `{ ok: false, error }`
  * on any throw (including permission errors, timeouts, plugin bugs).
  *
+ * v5.3.0 — method-level permission enforcement: when `loaded.methodSpecs`
+ * is populated (from plugin.json's `exports` array), `safeInvoke` checks
+ * the called method's declared permissions against the plugin's granted
+ * permissions BEFORE running. A denial is recorded in the audit log
+ * (`permission-audit.mjs`) and returned with `code: 'permission_denied'`
+ * and a `missing` array listing the ungranted permissions.
+ *
  * @param {object} loaded  return value of loadPlugin()
  * @param {string} method  method name on the plugin's exports
  * @param {unknown[]} args
  * @param {number} [timeoutMs]
- * @returns {Promise<{ ok: true, result: unknown } | { ok: false, error: string, code?: string }>}
+ * @returns {Promise<{ ok: true, result: unknown } | { ok: false, error: string, code?: string, missing?: string[] }>}
  */
 export async function safeInvoke(loaded, method, args = [], timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (!loaded || typeof loaded !== 'object') {
     return { ok: false, error: 'plugin not loaded', code: 'not_loaded' };
   }
+
+  // v5.3.0 — method-level permission enforcement. Uses
+  // `loaded.methodSpecs` (a copy of plugin.json's `exports` array, each
+  // entry shaped `{ name, permissions?: string[] }`). When the plugin
+  // declares no method-level permissions, we skip the check entirely
+  // (backward compatibility for plugins loaded without a manifest).
+  const pluginId = loaded.pluginId || loaded.id || 'unknown';
+  const methodSpecs = Array.isArray(loaded.methodSpecs) ? loaded.methodSpecs : [];
+  const methodSpec = methodSpecs.find((s) => s && s.name === method);
+  if (methodSpec) {
+    const required = Array.isArray(methodSpec.permissions) ? methodSpec.permissions : [];
+    const grantedArr = permissionsAsArray(loaded.permissions);
+    const missing = required.filter((p) => !grantedArr.includes(p));
+    if (missing.length > 0) {
+      logPermissionUse(pluginId, method, missing.join(','), false);
+      return {
+        ok: false,
+        error: `Method "${method}" requires permissions: ${missing.join(', ')}`,
+        code: 'permission_denied',
+        missing,
+      };
+    }
+    // Allowed — log the granted set (or 'none' if no perms required).
+    logPermissionUse(pluginId, method, required.join(',') || 'none', true);
+  }
+
   const fn = loaded.exports && loaded.exports[method];
   if (typeof fn !== 'function') {
     return {
@@ -586,6 +656,9 @@ export async function loadAndInvoke(opts) {
       pluginRoot: opts.pluginRoot,
       timeoutMs: opts.timeoutMs,
       fetchImpl: opts.fetchImpl,
+      // v5.3.0 — wire method-level permissions through from the manifest
+      // so safeInvoke can enforce them.
+      methodSpecs: Array.isArray(manifest.exports) ? manifest.exports : [],
     });
   } catch (err) {
     return {
@@ -652,4 +725,5 @@ export const __testing = {
   DEFAULT_MEMORY_LIMIT_MB,
   ALLOWED_GLOBALS,
   KNOWN_PERMS,
+  permissionsAsArray,
 };

package/bizar-dash/src/server/plugins/store.mjs

@@ -628,6 +628,10 @@ export async function invokePlugin(pluginId, method, args = [], opts = {}) {
       pluginRoot: pluginDir,
       timeoutMs: opts.timeoutMs,
       fetchImpl: opts.fetchImpl,
+      // v5.3.0 — pass method-level permission declarations through to
+      // the sandbox so `safeInvoke` can enforce them. Manifest defaults
+      // to an empty array (readManifest normalises missing exports).
+      methodSpecs: Array.isArray(manifest.exports) ? manifest.exports : [],
     });
   } catch (err) {
     return { ok: false, error: err.message, code: err.code || 'load_error' };

package/bizar-dash/src/server/routes/eval.mjs

@@ -14,8 +14,8 @@
  * via the state for custom providers.
  */
 import { Router } from 'express';
-import { loadFixtures, runFixture, runSuite } from '../eval.mjs';
-import { saveRun, listRuns, getRun, compareRuns, buildRunId } from '../eval-store.mjs';
+import { loadFixtures, runFixture, runSuite, toCSV } from '../eval.mjs';
+import { saveRun, listRuns, getRun, compareRuns, buildRunId, registerEvalSchedule, listEvalSchedules, deleteEvalSchedule } from '../eval-store.mjs';
 import { chatCompletion } from '../minimax.mjs';
 import { wrap } from './_shared.mjs';
 
@@ -45,6 +45,19 @@ export function createEvalRouter({ state, broadcast }) {
     res.json(run);
   }));
 
+  // GET /api/eval/runs/:id/export.csv — download run results as CSV
+  router.get('/eval/runs/:id/export.csv', wrap(async (req, res) => {
+    const run = await getRun(req.params.id);
+    if (!run) {
+      res.status(404).json({ error: 'not_found', message: `run ${req.params.id} not found` });
+      return;
+    }
+    const csv = toCSV(run.results || []);
+    res.set('Content-Type', 'text/csv; charset=utf-8');
+    res.set('Content-Disposition', `attachment; filename="eval-${req.params.id}.csv"`);
+    res.send(csv);
+  }));
+
   // GET /api/eval/fixtures — list fixtures in a suite path
   router.get('/eval/fixtures', wrap(async (req, res) => {
     const { path: suitePath } = req.query;
@@ -143,5 +156,32 @@ export function createEvalRouter({ state, broadcast }) {
     res.json(diff);
   }));
 
+  // GET /api/eval/schedules — list all eval schedules
+  router.get('/eval/schedules', wrap(async (req, res) => {
+    const schedules = await listEvalSchedules();
+    res.json({ schedules });
+  }));
+
+  // POST /api/eval/schedules — create a new eval schedule
+  router.post('/eval/schedules', wrap(async (req, res) => {
+    const { name, suitePath, cron, agent } = req.body || {};
+    if (!name || !suitePath || !cron) {
+      res.status(400).json({ error: 'bad_request', message: 'name, suitePath, and cron are required' });
+      return;
+    }
+    const schedule = await registerEvalSchedule({ name, suitePath, cron, agent });
+    res.status(201).json(schedule);
+  }));
+
+  // DELETE /api/eval/schedules/:id — delete an eval schedule
+  router.delete('/eval/schedules/:id', wrap(async (req, res) => {
+    const result = await deleteEvalSchedule(req.params.id);
+    if (!result.ok) {
+      res.status(404).json({ error: 'not_found', message: `schedule ${req.params.id} not found` });
+      return;
+    }
+    res.json({ ok: true });
+  }));
+
   return router;
 }

package/bizar-dash/src/server/routes/plugins.mjs

@@ -29,6 +29,7 @@ import { withSpan, setCommonAttributes } from '../otel.mjs';
 import { recordTrace } from '../metrics.mjs';
 import * as registry from '../plugins/registry.mjs';
 import * as store from '../plugins/store.mjs';
+import { getPermissionAuditLog } from '../plugins/permission-audit.mjs';
 
 /**
  * @returns {import('express').Router}
@@ -315,21 +316,60 @@ export function createPluginsRouter() {
     }
     // Distinguish "this is a plugin bug" (500) from "this is a usage
     // error" (400/404) so the client can decide whether to retry.
+    // v5.3.0 — `permission_denied` returns HTTP 403 (Forbidden) since
+    // the request is well-formed but the caller is not authorised to
+    // invoke the method. All other usage errors stay at 400.
     const usageCodes = new Set([
       'not_installed',
       'no_such_method',
       'bad_manifest',
-      'permission_denied',
       'corrupt_install',
     ]);
-    const status = usageCodes.has(result.code) ? 400 : 500;
+    let status;
+    if (result.code === 'permission_denied') {
+      status = 403;
+    } else if (usageCodes.has(result.code)) {
+      status = 400;
+    } else {
+      status = 500;
+    }
     span.setAttribute('plugin.invoke.error_code', result.code || 'unknown');
-    res.status(status).json(result);
+    if (result.code === 'permission_denied') {
+      span.setAttribute('plugin.invoke.permission_missing',
+        (result.missing || []).join(','));
+    }
+    res.status(status).json({
+      error: result.code || 'plugin_error',
+      message: result.error,
+      ...(result.code === 'permission_denied'
+        ? { missing: result.missing }
+        : {}),
+      ...(result.permission ? { permission: result.permission } : {}),
+    });
     recordTrace('plugin.invoke', {
-      outcome: 'error',
+      outcome: result.code === 'permission_denied' ? 'permission_denied' : 'error',
       code: result.code || 'unknown',
     });
   })));
 
+  // ── GET /api/plugins/:id/audit ─────────────────────────────────────────
+  // v5.3.0 — return the in-memory permission audit log for one plugin
+  // (newest-first). Bounded to 50 entries by default; pass `?limit=N`
+  // to fetch up to the buffer's full capacity. The route is read-only
+  // — admin tools should not clear the log from here.
+  router.get('/plugins/:id/audit', wrap(withSpan('plugin.audit.get', async (span, req, res) => {
+    setCommonAttributes(span, {
+      ip: req.ip || req.socket?.remoteAddress,
+      userAgent: req.headers?.['user-agent'],
+    });
+    span.setAttribute('plugin.id', req.params.id || '');
+    const limit = Number.isFinite(Number(req.query?.limit))
+      ? Math.max(1, Math.min(1000, Number(req.query.limit)))
+      : 50;
+    const audit = getPermissionAuditLog({ pluginId: req.params.id, limit });
+    res.json({ audit });
+    recordTrace('plugin.audit.get', { count: audit.length });
+  })));
+
   return router;
 }

package/bizar-dash/src/server/routes/users.mjs

@@ -26,7 +26,25 @@ export function createUsersRouter() {
       return res.status(401).json({ error: 'unauthorized', message: 'Not authenticated' });
     }
     const user = await getUser(userId);
+    // v5.3.1 — Tailscale-trust: when getCurrentUserId returns a derived
+    // userId (usr_ts_*) that doesn't exist in the store, synthesize a
+    // minimal user record from the request Host header so the dashboard
+    // can render a profile without needing a full signup.
     if (!user) {
+      if (userId.startsWith('usr_ts_')) {
+        const host = String(req.headers?.host || '').split(':')[0] || 'tailnet';
+        const tailnetName = host.split('.')[0] || 'tailnet';
+        const workspaces = await listWorkspacesWithRoles(userId);
+        return res.json({
+          user: {
+            id: userId,
+            email: `${tailnetName}@tailscale.local`,
+            name: `Tailnet user (${tailnetName})`,
+            tailnet: true
+          },
+          workspaces
+        });
+      }
       return res.status(404).json({ error: 'not_found', message: 'User not found' });
     }
     const workspaces = await listWorkspacesWithRoles(userId);

package/bizar-dash/src/server/schedules-runner.mjs

@@ -199,6 +199,9 @@ async function runAction(action, ctx = {}) {
   if (action.type === 'agent') {
     return runAgentAction(action, ctx);
   }
+  if (action.type === 'eval-run') {
+    return runEvalAction(action, ctx);
+  }
   throw new Error(`unknown action type: ${action.type}`);
 }
 
@@ -370,6 +373,64 @@ async function runWebhook(action) {
   }
 }
 
+async function runEvalAction(action, ctx = {}) {
+  const logger = ctx.logger || {
+    info: (msg, meta) => console.log(`[eval-run] ${msg}`, meta || ''),
+    error: (msg, meta) => console.error(`[eval-run] ${msg}`, meta || ''),
+  };
+  try {
+    const { runSuite } = await import('./eval.mjs');
+    const { saveRun, buildRunId } = await import('./eval-store.mjs');
+    const { chatCompletion } = await import('./minimax.mjs');
+
+    const runId = buildRunId();
+    const startedAt = new Date().toISOString();
+
+    const llmCall = async (prompt, opts = {}) => {
+      const result = await chatCompletion({ prompt, model: 'MiniMax-M3' });
+      if (!result.ok) throw new Error(result.message || 'llm call failed');
+      return {
+        content: result.content,
+        usage: {
+          inputTokens: result.usage?.prompt_tokens ?? 0,
+          outputTokens: result.usage?.completion_tokens ?? 0,
+          totalTokens: result.usage?.total_tokens ?? 0,
+        },
+      };
+    };
+
+    const result = await runSuite(action.suitePath, {
+      llmCall,
+      concurrency: 5,
+      timeoutMs: 120_000,
+      agent: action.agent,
+    });
+
+    const finishedAt = new Date().toISOString();
+    const run = {
+      id: runId,
+      startedAt,
+      finishedAt,
+      suitePath: action.suitePath,
+      total: result.total,
+      passed: result.passed,
+      failed: result.failed,
+      results: result.results,
+    };
+
+    await saveRun(run);
+    logger.info('scheduled eval completed', {
+      suite: action.suitePath,
+      passed: result.passed,
+      total: result.total,
+    });
+    return { ok: result.failed === 0, passed: result.passed, failed: result.failed, total: result.total };
+  } catch (err) {
+    logger.error('scheduled eval failed', { error: err.message });
+    return { ok: false, error: err.message };
+  }
+}
+
 export const schedulesRunner = {
   LOG_FILE,