@njeybe/nativ 2.2.0 → 2.3.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## Unreleased
+
+### Fixed
+
+- Studio Dispatch on Windows: task text with quotes or symbols like > could cut off the agent's instructions and send its output to a stray file.
+
+### Removed
+
+- The simulation endpoints (`/api/pipeline/simulation/start` and `/stop`) that fed the old Workflow Canvas.
+
+## 2.3.0
+
+### Changed
+
+- **Studio redesign.** New Home, Tasks, Flow and Team pages focused on what needs you, what
+  finished, how the work connects, and how each agent is doing. Ctrl+K command palette to find
+  any task, a detail panel to read and act on one task, and light and dark themes.
+
+### Removed
+
+- Agent Cockpits and Workflow Canvas pages and the simulation controls in the UI. The
+  simulation server endpoints remain for now and will be removed in a later cleanup.
+
 ## 2.2.0
 
 ### Added
@@ -34,7 +57,7 @@
 
 Documentation and package metadata only; no behaviour changes.
 
-- **npm is the only install path.** The source repository is private, so the instructions for `npm install -g github:…` and for adding the plugin marketplace were removed from the README and the installation guide. `nativ setup` is the complete route: it writes the agents, the enforcement hook, the MCP entry and the permission rules, which a plugin cannot ship.
+- **npm is the only install path.** The source repository is private, so the instructions for `npm install -g github:...` and for adding the plugin marketplace were removed from the README and the installation guide. `nativ setup` is the complete route: it writes the agents, the enforcement hook, the MCP entry and the permission rules, which a plugin cannot ship.
 - The plugin files still ship inside the package (`plugin/`) and can be tried for one session with `claude --plugin-dir`.
 - `package.json` no longer declares `repository`, `homepage` or `bugs`, so the npm page has no dead links.
 - The 2.0.0 entry below still mentions the plugin marketplace; that route is not available outside the private repository.

package/README.md

@@ -234,6 +234,21 @@ nativ bench --scenario concurrency --concurrency 8
 nativ bench --json
 ```
 
+### Studio
+
+`nativ studio` runs a local dashboard at http://localhost:4983 with live updates. It loads
+nothing from the internet and runs under a strict content security policy. The sidebar
+groups pages by role.
+
+**Home** shows what needs you, what's running now, and what just finished.
+**Tasks** displays one milestone at a time, sorted newest completed first.
+**Flow** shows how the work connects and visualizes how the run really happened.
+**Team** lists each agent's activity in plain terms: tasks done, time spent, cost.
+**Worktrees, Benchmarks, Database** are system tools for branches, performance and schemas.
+
+Press Ctrl+K (or Cmd+K or /) to find any task by id, title, agent or file name. The theme
+toggle switches between light and dark; your choice is saved locally.
+
 ### Database studio and schema telemetry (masked, structure only)
 
 ```bash

package/dist/runner/agent-supervisor.d.ts

@@ -209,14 +209,16 @@ export declare function buildRunnerPermissions(task: Pick<MasterPlanTask, 'verif
 /** Where a task's runner settings live: a subdirectory, because run history parses every top-level .json in runs/. */
 export declare function runnerSettingsPath(runsDir: string, taskId: string): string;
 export declare function writeRunnerSettings(runsDir: string, taskId: string, settings: RunnerPermissions): string;
+/** The instructions text handed to the agent on its standard input. */
+export declare function buildRunnerPrompt(task: MasterPlanTask): string;
 /**
- * Builds the autonomous prompt and arguments required by Claude Code CLI
- * to execute non-interactively in a headless child process.
+ * Arguments for Claude Code CLI to run headless. The prompt goes on stdin, never in this string:
+ * quotes or symbols in task text would break the shell.
  *
  * It runs in `acceptEdits` mode with the rules in `settingsFile` (see buildRunnerPermissions); it does not bypass
  * permissions. Without a settings file only the file-edit tools and read-only commands are pre-approved.
  */
-export declare function buildDefaultClaudeCommand(task: MasterPlanTask, model?: string | null, settingsFile?: string): string;
+export declare function buildDefaultClaudeCommand(_task: MasterPlanTask, model?: string | null, settingsFile?: string): string;
 /** True when a runner command asks Claude Code for its line-delimited JSON event stream. */
 export declare function usesClaudeStreamJson(command: string): boolean;
 /** Final `result` event of a Claude Code stream: grounded usage for cli runs. */

package/dist/runner/agent-supervisor.js

@@ -213,15 +213,9 @@ export function writeRunnerSettings(runsDir, taskId, settings) {
     fs.writeFileSync(file, JSON.stringify(settings, null, 2) + '\n', 'utf8');
     return file;
 }
-/**
- * Builds the autonomous prompt and arguments required by Claude Code CLI
- * to execute non-interactively in a headless child process.
- *
- * It runs in `acceptEdits` mode with the rules in `settingsFile` (see buildRunnerPermissions); it does not bypass
- * permissions. Without a settings file only the file-edit tools and read-only commands are pre-approved.
- */
-export function buildDefaultClaudeCommand(task, model, settingsFile) {
-    const parts = [
+/** The instructions text handed to the agent on its standard input. */
+export function buildRunnerPrompt(task) {
+    return [
         `Execute task ${task.id} (${task.title}).`,
         task.description ? `Description: ${task.description}.` : '',
         task.verificationCommand ? `Verify your work using: ${task.verificationCommand}.` : '',
@@ -230,11 +224,19 @@ export function buildDefaultClaudeCommand(task, model, settingsFile) {
     ]
         .filter(Boolean)
         .join(' ');
-    const escapedPrompt = parts.replace(/"/g, '\\"');
+}
+/**
+ * Arguments for Claude Code CLI to run headless. The prompt goes on stdin, never in this string:
+ * quotes or symbols in task text would break the shell.
+ *
+ * It runs in `acceptEdits` mode with the rules in `settingsFile` (see buildRunnerPermissions); it does not bypass
+ * permissions. Without a settings file only the file-edit tools and read-only commands are pre-approved.
+ */
+export function buildDefaultClaudeCommand(_task, model, settingsFile) {
     const modelFlag = model ? ` --model ${model}` : '';
     // Plain `claude -p` prints nothing until it finishes; stream-json emits every message and tool call as it happens.
     const settingsFlag = settingsFile ? ` --settings "${settingsFile}"` : '';
-    return `claude -p "${escapedPrompt}"${modelFlag} --output-format stream-json --verbose --permission-mode acceptEdits${settingsFlag}`;
+    return `claude -p${modelFlag} --output-format stream-json --verbose --permission-mode acceptEdits${settingsFlag}`;
 }
 /** True when a runner command asks Claude Code for its line-delimited JSON event stream. */
 export function usesClaudeStreamJson(command) {
@@ -1092,7 +1094,7 @@ export class AgentSupervisor extends EventEmitter {
             // stdio pipes, so we stay attached and let `taskkill /T` walk the tree.
             detached: process.platform !== 'win32',
             windowsHide: true,
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ['pipe', 'pipe', 'pipe'],
             env: {
                 ...buildRunnerEnv(process.env, options.env),
                 ...(record.thinking?.budgetTokens ? { MAX_THINKING_TOKENS: String(record.thinking.budgetTokens) } : {}),
@@ -1103,6 +1105,9 @@ export class AgentSupervisor extends EventEmitter {
         });
         run.child = child;
         record.pid = child.pid ?? null;
+        // A runner that exits without reading its input must not crash us or fail the run.
+        child.stdin?.on('error', () => { });
+        child.stdin?.end(buildRunnerPrompt(task), 'utf8');
         child.stdout?.on('data', (chunk) => {
             if (run.streamJson)
                 this.consumeStreamJson(run, chunk.toString());

package/dist/server/studio-server.js

@@ -1580,128 +1580,6 @@ class PipelineEventHub {
             res.write(frame);
     }
 }
-/**
- * Interactive simulation engine for Mission Control Studio.
- * Broadcasts realistic multi-agent execution steps over the SSE stream
- * without modifying workspace files or invoking external model APIs.
- */
-class SimulationController {
-    events;
-    activeTimer = null;
-    running = false;
-    currentId = null;
-    constructor(events) {
-        this.events = events;
-    }
-    start(body = {}) {
-        this.stop();
-        const id = `sim-${Date.now()}`;
-        this.currentId = id;
-        this.running = true;
-        const speed = Math.max(1, Math.min(5, Number(body.speedMultiplier) || 1));
-        const scenario = String(body.scenario || 'default');
-        const steps = [
-            // Step 1: Foundation task (qa-tester)
-            { taskId: 'task-01', phase: 'spawning_worktree', log: '[qa-tester] Provisioning isolated worktree branch for task-01...\n', delay: 400 },
-            { taskId: 'task-01', phase: 'running', log: '[qa-tester] Validating dependencies, project manifest and baseline checks...\n', delay: 600 },
-            { taskId: 'task-01', phase: 'verifying', log: '[gatekeeper] Running verification command: npm test\n✔ Baseline contracts validated\n', delay: 600 },
-            { taskId: 'task-01', phase: 'completed', log: '[qa-tester] Task task-01 passed verification and merged.\n', delay: 400 },
-            // Step 2: Parallel execution (backend & frontend)
-            { taskId: 'task-studio-sse-api', phase: 'spawning_worktree', log: '[backend] Initializing git worktree .nativ/worktrees/task-studio-sse-api...\n', delay: 300 },
-            { taskId: 'task-studio-light-ui', phase: 'spawning_worktree', log: '[frontend] Initializing git worktree .nativ/worktrees/task-studio-light-ui...\n', delay: 300 },
-            { taskId: 'task-studio-sse-api', phase: 'running', log: '[backend] Implementing real-time event pipeline fanout & simulation endpoints in studio-server.ts...\n', delay: 700 },
-            { taskId: 'task-studio-light-ui', phase: 'running', log: '[frontend] Constructing SVG Workflow Canvas with Bezier cables and floating playback bar...\n', delay: 700 },
-            { taskId: 'task-studio-sse-api', phase: 'verifying', log: '[gatekeeper] Executing test-studio-pipeline-api.mjs...\n✔ All API endpoints passed\n', delay: 600 },
-            { taskId: 'task-studio-sse-api', phase: 'merging', log: '[backend] Merging worktree branch to main...\n', delay: 300 },
-            { taskId: 'task-studio-sse-api', phase: 'completed', log: '[backend] SSE pipeline stream online.\n', delay: 400 },
-            { taskId: 'task-studio-light-ui', phase: 'verifying', log: '[gatekeeper] Executing test-studio-light-ui.mjs...\n✔ Zero-emoji compliance and Canvas DOM validated\n', delay: 600 },
-            { taskId: 'task-studio-light-ui', phase: 'merging', log: '[frontend] Merging worktree branch to main...\n', delay: 300 },
-            { taskId: 'task-studio-light-ui', phase: 'completed', log: '[frontend] Workflow Canvas ready.\n', delay: 400 },
-            // Step 3: End-to-end integration & verification
-            { taskId: 'task-studio-e2e-verify', phase: 'spawning_worktree', log: '[qa-tester] Spawning E2E integration test runner...\n', delay: 300 },
-            { taskId: 'task-studio-e2e-verify', phase: 'running', log: '[qa-tester] Running comprehensive integration test matrix...\n', delay: 800 },
-            ...(scenario === 'circuit_breaker_heal'
-                ? [
-                    { taskId: 'task-studio-e2e-verify', phase: 'failed', stream: 'stderr', log: '[qa-tester] Invariant violation detected: test mock failure. Circuit breaker tripped.\n', delay: 600 },
-                ]
-                : [
-                    { taskId: 'task-studio-e2e-verify', phase: 'verifying', log: '[gatekeeper] Full E2E suite passed.\n', delay: 600 },
-                    { taskId: 'task-studio-e2e-verify', phase: 'completed', log: '[qa-tester] All milestones verified.\n', delay: 400 },
-                ]),
-        ];
-        let stepIndex = 0;
-        const runNext = () => {
-            if (!this.running || stepIndex >= steps.length) {
-                this.running = false;
-                return;
-            }
-            const step = steps[stepIndex++];
-            const record = {
-                runId: `${id}-${step.taskId}`,
-                taskId: step.taskId,
-                status: step.phase,
-                engine: 'native',
-                model: 'claude-opus-5-5 (simulation)',
-                thinking: { budget: 2048, effort: 'medium', budgetTokens: 2048 },
-                usage: {
-                    model: 'claude-opus-5-5 (simulation)',
-                    turns: 3,
-                    inputTokens: 1400,
-                    outputTokens: 380,
-                    cacheCreationTokens: 500,
-                    cacheReadTokens: 4000,
-                    thinkingTokens: 120,
-                    costUsd: 0.011,
-                },
-                pid: 99000 + stepIndex,
-                branch: `nativ/${step.taskId}`,
-                worktreeDir: `.nativ/worktrees/${step.taskId}`,
-                command: 'simulation',
-                startedAt: new Date(Date.now() - 2000).toISOString(),
-                endedAt: step.phase === 'completed' || step.phase === 'failed' ? new Date().toISOString() : null,
-                durationMs: 2500,
-                exitCode: step.phase === 'completed' ? 0 : step.phase === 'failed' ? 1 : null,
-                signal: null,
-                timeoutSeconds: 300,
-                timedOut: false,
-                logBytes: (step.log || '').length,
-                logFile: `.nativ/logs/${step.taskId}.log`,
-                error: step.phase === 'failed' ? (step.log || 'Task failed') : null,
-                abortReason: null,
-                verification: step.phase === 'completed' ? { command: 'npm test', success: true, exitCode: 0, durationMs: 400, skipped: false } : null,
-            };
-            this.events.publish('runner_status', runView(record));
-            if (step.log) {
-                this.events.publish('runner_log', {
-                    runId: `${id}-${step.taskId}`,
-                    taskId: step.taskId,
-                    stream: step.stream ?? 'stdout',
-                    chunk: step.log,
-                    at: new Date().toISOString(),
-                });
-            }
-            this.activeTimer = setTimeout(runNext, Math.max(80, Math.round(step.delay / speed)));
-        };
-        this.activeTimer = setTimeout(runNext, Math.round(150 / speed));
-        return {
-            ok: true,
-            simulationId: id,
-            scenario,
-            speed,
-            status: 'running',
-        };
-    }
-    stop() {
-        if (this.activeTimer) {
-            clearTimeout(this.activeTimer);
-            this.activeTimer = null;
-        }
-        const wasRunning = this.running;
-        this.running = false;
-        this.currentId = null;
-        return { ok: true, status: 'stopped', wasRunning };
-    }
-}
 // ─── Server ────────────────────────────────────────────────────────────────────
 export function createStudioServer(options = {}) {
     const cwd = options.cwd ?? process.cwd();
@@ -1742,7 +1620,6 @@ export function createStudioServer(options = {}) {
     supervisor.on('runner_status', (record) => events.publish('runner_status', runView(record)));
     supervisor.on('runner_log', (entry) => events.publish('runner_log', entry));
     supervisor.on('runner_token_usage', (usage) => events.publish('runner_token_usage', usage));
-    const simulation = new SimulationController(events);
     // Tier 1 strategist: settings and counters live for this server session only.
     const liaison = new Tier1Liaison(root, options.triage);
     const triageInFlight = new Map();
@@ -1842,10 +1719,6 @@ export function createStudioServer(options = {}) {
                     return sendJson(res, 200, handleEscalations(root, url.searchParams));
                 case 'POST /api/pipeline/escalations/resolve':
                     return sendJson(res, 200, await handleEscalationResolve(root, await readJsonBody(req)));
-                case 'POST /api/pipeline/simulation/start':
-                    return sendJson(res, 200, simulation.start(await readJsonBody(req)));
-                case 'POST /api/pipeline/simulation/stop':
-                    return sendJson(res, 200, simulation.stop());
                 case 'POST /api/pipeline/triage/evaluate':
                     return sendJson(res, 200, await handleTriageEvaluate(root, liaison, triageInFlight, await readJsonBody(req)));
                 case 'GET /api/pipeline/triage/status':
@@ -1863,8 +1736,7 @@ export function createStudioServer(options = {}) {
                     '/api/pipeline/tasks/abort', '/api/pipeline/tasks/runs', '/api/pipeline/tasks/logs', '/api/pipeline/worktrees',
                     '/api/pipeline/worktrees/action', '/api/pipeline/worktrees/diff', '/api/pipeline/benchmarks', '/api/pipeline/benchmarks/run',
                     '/api/pipeline/telemetry/detailed', '/api/pipeline/escalations', '/api/pipeline/escalations/resolve',
-                    '/api/pipeline/simulation/start', '/api/pipeline/simulation/stop', '/api/pipeline/triage/evaluate',
-                    '/api/pipeline/triage/status', '/api/pipeline/triage/config',
+                    '/api/pipeline/triage/evaluate', '/api/pipeline/triage/status', '/api/pipeline/triage/config',
                 ];
                 if (known.includes(url.pathname.replace(/\/+$/, '')))
                     throw new HttpError(405, 'METHOD_NOT_ALLOWED', `${req.method} not allowed on ${url.pathname}`);
@@ -1884,7 +1756,6 @@ export function createStudioServer(options = {}) {
     // Open SSE streams and in-flight agent runners would otherwise keep close() waiting forever.
     const closeServer = server.close.bind(server);
     server.close = ((callback) => {
-        simulation.stop();
         supervisor.shutdown('Studio server shutting down');
         events.close();
         return closeServer(callback);

package/dist/server/studio-ui/document.d.ts

@@ -0,0 +1,3 @@
+export declare function escapeHtml(value: string): string;
+export declare const documentStart: string;
+export declare const styleEnd = "</style>\n";

package/dist/server/studio-ui/document.js

@@ -0,0 +1,22 @@
+export function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[ch]);
+}
+// Runs before first paint so a saved theme never flashes the wrong colours.
+const themeScript = String.raw `(function () {
+  try {
+    var t = localStorage.getItem('nativ-studio:theme');
+    if (t === 'dark' || t === 'light') document.documentElement.setAttribute('data-theme', t);
+  } catch (e) { /* storage blocked */ }
+})();`;
+// Opening of the document up to the style block; the CSS chunks follow it.
+export const documentStart = String.raw `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light dark">
+<title>Nativ Studio</title>
+<script>${themeScript}</script>
+<style>
+`;
+export const styleEnd = '</style>\n';

package/dist/server/studio-ui/pages/benchmarks/index.d.ts

@@ -0,0 +1,2 @@
+import type { PageModule } from '../types.js';
+export declare const benchmarksPage: PageModule;

package/dist/server/studio-ui/pages/benchmarks/index.js

@@ -0,0 +1,11 @@
+import { ICON_PATHS } from '../../shell/icons.js';
+import { benchmarksCss } from './styles.js';
+import { benchmarksScript } from './script.js';
+export const benchmarksPage = {
+    id: 'benchmarks',
+    group: 'system',
+    label: 'Benchmarks',
+    icon: ICON_PATHS.benchmarks,
+    css: benchmarksCss,
+    script: benchmarksScript,
+};

package/dist/server/studio-ui/pages/benchmarks/script.d.ts

@@ -0,0 +1 @@
+export declare const benchmarksScript: string;

package/dist/server/studio-ui/pages/benchmarks/script.js

@@ -0,0 +1,104 @@
+// Benchmarks view script.
+export const benchmarksScript = String.raw `  // ─── View 4: Synthetic benchmarks ──────────────────────────────────────────
+  var SCENARIOS = [
+    { id: 'concurrency', label: 'Multi-Agent Concurrency' },
+    { id: 'telemetry', label: 'Telemetry Engine' },
+    { id: 'governor', label: 'Governor Invariants' },
+    { id: 'verification', label: 'Gatekeeper' },
+    { id: 'e2e_pipeline', label: 'E2E Lifecycle' }
+  ];
+
+  function renderBenchmarks() {
+    var running = !!pipe.busy.bench;
+    var runBtn = '<button class="btn primary" type="button" data-act="bench-run"' + (running ? ' disabled' : '') + '>' +
+      (running ? '<span class="spinner" aria-hidden="true"></span>Running…' : ICON.play + 'Run Benchmark') + '</button>';
+    var head = panelHead('Synthetic Benchmarks', 'Sandboxed stress runs of plan locking, telemetry, the contract governor, the verification gatekeeper and the full agent lifecycle.', runBtn);
+    if (!pipe.loaded.benchmarks) return head + '<div class="card section" aria-hidden="true"><div class="skeleton tall"></div></div><div class="scenario-grid" aria-hidden="true">' + skeletonCards(5, 'scenario') + '</div>';
+    if (pipe.errors.benchmarks && !pipe.report) return head + errorCard('benchmark report', pipe.errors.benchmarks, 'benchmarks');
+    var r = pipe.report;
+    if (!r) {
+      return head + '<div class="card state" aria-busy="' + running + '"><div class="state-icon">' + (running ? '<span class="spinner" aria-hidden="true"></span>' : ICON.gauge) + '</div>' +
+        '<h2>' + (running ? 'Running benchmark matrix…' : 'No benchmark report yet') + '</h2>' +
+        '<p>' + (running ? 'Scenarios run in throwaway sandboxes; this usually takes a few seconds.' : 'Run the synthetic matrix to measure throughput and score all five pipeline scenarios. Results are cached in .ai/benchmark_report.json.') + '</p></div>';
+    }
+    return head + staleNote('benchmarks') + benchHero(r, running) + '<div class="scenario-grid">' + scenarioCards(r) + '</div>';
+  }
+
+  function benchHero(r, running) {
+    var s = r.summary || {};
+    var env = r.environment || {};
+    var meta = [];
+    if (r.timestamp) meta.push('Ran ' + esc(fmtDate(r.timestamp)));
+    if (env.platform) meta.push(esc(env.platform + (env.arch ? ' ' + env.arch : '')));
+    if (env.nodeVersion) meta.push('Node ' + esc(env.nodeVersion));
+    if (env.cpuCount) meta.push(env.cpuCount + ' CPUs');
+    var score = clampPct(s.score);
+    return '<section class="card hero' + (running ? ' is-running' : '') + '" aria-labelledby="hero-h" aria-busy="' + running + '">' +
+      '<div><h2 class="eyebrow" id="hero-h">Average throughput</h2>' +
+      '<div class="hero-value">' + num(Math.round(s.averageThroughputOpsPerSec || 0)) + '<span class="badge badge-accent">ops/sec</span></div>' +
+      '<p class="hero-meta">' + meta.join(' · ') + '</p></div>' +
+      '<dl class="hero-stats">' +
+        '<div><dt>Score</dt><dd class="' + (score < 100 ? 'text-danger' : '') + '">' + score + '%</dd></div>' +
+        '<div><dt>Scenarios passed</dt><dd>' + num(s.passedScenarios) + '/' + num(s.totalScenarios) + '</dd></div>' +
+        '<div><dt>Total duration</dt><dd>' + fmtMs(s.totalDurationMs) + '</dd></div>' +
+        '<div><dt>Operations</dt><dd>' + num(s.totalOperations) + '</dd></div>' +
+      '</dl></section>';
+  }
+
+  function scenarioCards(r) {
+    var byId = {}, known = {};
+    (r.scenarios || []).forEach(function (s) { byId[s.id] = s; });
+    var cards = SCENARIOS.map(function (meta) { known[meta.id] = true; return scenarioCard(meta.label, byId[meta.id]); });
+    (r.scenarios || []).forEach(function (s) { if (!known[s.id]) cards.push(scenarioCard(s.name || s.id, s)); });
+    return cards.join('');
+  }
+
+  function scenarioCard(label, s) {
+    if (!s) {
+      return '<article class="card scenario is-idle"><header class="scenario-head"><h3>' + esc(label) + '</h3><span class="badge badge-neutral">Not run</span></header>' +
+        '<p class="muted">Not part of the last run. Run the full matrix to score it.</p></article>';
+    }
+    var total = (s.assertionsPassed || 0) + (s.assertionsFailed || 0);
+    var passed = s.status === 'passed';
+    var score = total ? Math.round((s.assertionsPassed || 0) / total * 100) : (passed ? 100 : 0);
+    var details = Object.keys(s.details || {}).slice(0, 4).map(function (k) {
+      var v = s.details[k];
+      // Lists (e.g. invariant names) get a full-width row of chips instead of a cramped value column.
+      if (Array.isArray(v)) {
+        return '<dt class="wide">' + esc(humanize(k)) + '</dt><dd class="wide">' + v.map(function (item) { return '<span class="chip">' + esc(detailValue(item)) + '</span>'; }).join('') + '</dd>';
+      }
+      return '<dt>' + esc(humanize(k)) + '</dt><dd>' + esc(detailValue(v)) + '</dd>';
+    }).join('');
+    var errors = (s.errors || []).length ? '<ul class="scenario-errors">' + s.errors.map(function (e) { return '<li>' + esc(e) + '</li>'; }).join('') + '</ul>' : '';
+    return '<article class="card scenario"><header class="scenario-head"><h3>' + esc(label) + '</h3>' +
+      '<span class="badge badge-' + (passed ? 'success' : 'danger') + '">' + (passed ? 'Passed' : 'Failed') + '</span></header>' +
+      (s.name && s.name !== label ? '<p class="scenario-sub">' + esc(s.name) + '</p>' : '') +
+      '<div class="metrics"><div><span class="metric-v">' + score + '%</span><span class="metric-l">Score</span></div>' +
+      '<div><span class="metric-v">' + fmtMs(s.durationMs) + '</span><span class="metric-l">Latency</span></div>' +
+      '<div><span class="metric-v">' + num(Math.round(s.throughputOpsPerSec || 0)) + '</span><span class="metric-l">ops/sec</span></div></div>' +
+      progressBar(score, 'sc-' + s.id, label + ' score', passed ? 'success' : 'danger') +
+      (details ? '<dl class="details">' + details + '</dl>' : '') + errors + '</article>';
+  }
+
+  function runBenchmark() {
+    if (pipe.busy.bench) return;
+    pipe.busy.bench = true;
+    repaint('benchmarks');
+    postJson('/api/pipeline/benchmarks/run', {}).then(function (r) {
+      if (r.report) { pipe.report = r.report; pipe.errors.benchmarks = null; pipe.loaded.benchmarks = true; }
+      var s = r.report && r.report.summary;
+      toast('Benchmark finished' + (s ? ': score ' + clampPct(s.score) + '%, ' + s.passedScenarios + '/' + s.totalScenarios + ' scenarios passed' : ''), 'ok');
+    }, function (e) {
+      toast('Benchmark run failed: ' + e.message);
+    }).then(function () {
+      pipe.busy.bench = false;
+      repaint('benchmarks');
+    });
+  }
+
+  Studio.registerPage('benchmarks', {
+    deps: ['benchmarks'],
+    render: function () { return renderBenchmarks(); },
+    actions: { 'bench-run': function () { runBenchmark(); } }
+  });
+`;

package/dist/server/studio-ui/pages/benchmarks/styles.d.ts

@@ -0,0 +1 @@
+export declare const benchmarksCss: string;

package/dist/server/studio-ui/pages/benchmarks/styles.js

@@ -0,0 +1,30 @@
+// Benchmarks view styles.
+export const benchmarksCss = String.raw `/* Benchmarks */
+.hero { display: grid; grid-template-columns: minmax(0, 1fr) auto; align-items: center; gap: 20px 32px; padding: 22px; margin-bottom: 16px; transition: opacity .2s; }
+.hero.is-running { opacity: .6; }
+.eyebrow { margin: 0; font-size: 12px; font-weight: 600; letter-spacing: .06em; text-transform: uppercase; color: var(--muted); }
+.hero-value { display: flex; align-items: center; gap: 10px; margin: 6px 0; font-size: 40px; font-weight: 650; letter-spacing: -0.03em; line-height: 1.1; font-variant-numeric: tabular-nums; }
+.hero-value .badge { font-size: 12px; letter-spacing: 0; }
+.hero-meta { margin: 0; font-size: 13.5px; color: var(--muted); }
+.hero-stats { display: grid; grid-template-columns: repeat(4, minmax(96px, auto)); gap: 4px 28px; margin: 0; }
+.hero-stats dt { font-size: 12.5px; color: var(--muted); }
+.hero-stats dd { margin: 0; font-size: 18px; font-weight: 600; font-variant-numeric: tabular-nums; white-space: nowrap; }
+.scenario-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(260px, 1fr)); gap: 14px; }
+.scenario { display: flex; flex-direction: column; gap: 10px; min-width: 0; padding: 16px; }
+.scenario.is-idle { box-shadow: none; border-style: dashed; }
+.scenario-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 8px; }
+.scenario-head h3 { margin: 0; font-size: 14.5px; font-weight: 600; }
+.scenario-sub { margin: -6px 0 0; font-size: 13px; color: var(--muted); }
+.scenario p { margin: 0; font-size: 13.5px; line-height: 1.5; }
+.metrics { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 8px; }
+.metric-v { display: block; font-size: 17px; font-weight: 600; font-variant-numeric: tabular-nums; white-space: nowrap; }
+.metric-l { display: block; font-size: 12px; color: var(--muted); }
+.details { display: grid; grid-template-columns: auto minmax(0, 1fr); gap: 4px 12px; margin: 0; padding-top: 10px; font-size: 12.5px; border-top: 1px solid var(--border); }
+.details dt { color: var(--muted); }
+.details dd { margin: 0; text-align: right; font-family: var(--mono); font-size: 12px; overflow-wrap: anywhere; }
+.details .wide { grid-column: 1 / -1; }
+.details dd.wide { display: flex; flex-wrap: wrap; gap: 4px; margin-bottom: 4px; text-align: left; }
+.details dd.wide .chip { font-size: 11px; }
+.scenario-errors { margin: 0; padding: 8px 10px 8px 26px; font-size: 12.5px; color: var(--danger); background: var(--danger-bg); border: 1px solid var(--danger-line); border-radius: var(--r-control); }
+
+`;

package/dist/server/studio-ui/pages/database/browser.d.ts

@@ -0,0 +1 @@
+export declare const databaseBrowserScript: string;