smol-symphony 0.2.0 → 0.3.0

package/dist/{http.js → src/core/http/render.js}

@@ -1,145 +1,42 @@
-// HTTP server extension (SPEC §13.7) plus the local-tracker UI for creating issues and
-// watching status. The UI polls `/api/v1/state` so no SSE/WebSocket infrastructure is
-// needed.
-import { createServer } from 'node:http';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { log } from './logging.js';
-import { writeIssueFile } from './issues.js';
-import { matchRoute, resolvePartialName, extractBearerToken, classifyContentType, checkSteeringCsrf, checkTriageCsrf, extractFormText, extractJsonText, decideCreateIssue, decideTriageTransition, } from './http-handlers.js';
-import { listIssuesFromDisk, readIssueFromDisk, } from './http-disk.js';
-function jsonResponse(res, status, body) {
-    const text = JSON.stringify(body);
-    res.statusCode = status;
-    res.setHeader('content-type', 'application/json; charset=utf-8');
-    res.setHeader('content-length', Buffer.byteLength(text));
-    res.end(text);
-}
-function methodNotAllowed(res) {
-    jsonResponse(res, 405, { error: { code: 'method_not_allowed', message: 'method not allowed' } });
-}
-function notFound(res, code = 'not_found', message = 'not found') {
-    jsonResponse(res, 404, { error: { code, message } });
-}
-function badRequest(res, message) {
-    jsonResponse(res, 400, { error: { code: 'bad_request', message } });
-}
-async function readJsonBody(req, maxBytes = 1_000_000) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let size = 0;
-        req.on('data', (chunk) => {
-            size += chunk.length;
-            if (size > maxBytes) {
-                req.destroy();
-                reject(new Error('request body too large'));
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on('end', () => {
-            const text = Buffer.concat(chunks).toString('utf8');
-            if (text.length === 0)
-                return resolve({});
-            try {
-                resolve(JSON.parse(text));
-            }
-            catch (err) {
-                reject(new Error(`invalid JSON: ${err.message}`));
-            }
-        });
-        req.on('error', reject);
-    });
-}
-// Cross-site form POSTs are "simple" CORS requests that bypass preflight, so an
-// unauthenticated endpoint that accepts form-encoded bodies is CSRFable from any
-// origin. Steering reply uses this check (in addition to requiring HX-Request) to
-// reject form bodies whose Origin doesn't match the Host the request hit.
+// FCIS rewrite — PURE HTML/markdown render layer for the dashboard + issue-detail
+// pages and the HTMX partials. Ported faithfully from the original src/http.ts
+// render functions (renderDashboardHtml, board/column/row partials, header/health/
+// attention partials, renderSteeringInline, renderNewIssuePanel, renderTotalsPartial,
+// renderIssueDetailPage, the minimal Markdown engine, and the small formatters).
 //
-// We treat the request as same-origin if either:
-//   • An Origin header is present and its host:port equals the Host header (the
-//     normal browser case), or
-//   • There is no Origin header at all AND no Referer header (curl, internal calls,
-//     non-browser tools). Browsers always send Origin on cross-origin form POSTs.
-function isSameOriginRequest(req) {
-    const host = (req.headers['host'] ?? '').toString().trim();
-    const origin = (req.headers['origin'] ?? '').toString().trim();
-    if (origin) {
-        try {
-            const parsed = new URL(origin);
-            return parsed.host === host;
-        }
-        catch {
-            return false;
-        }
-    }
-    // No Origin header — only trust if there's no Referer either (a real browser
-    // form POST sets at least one).
-    return !(req.headers['referer'] && req.headers['referer'].length > 0);
-}
-// HTMX's default response handling does not swap content on 4xx/5xx responses, so
-// returning a 4xx with an HTML partial silently leaves the region stale. For HTMX
-// callers (currently only steering-reply, which targets the #ticker region) we
-// return 200 with the ticker partial plus an inline error chip; the operator's
-// textarea content sits in the board row (separate hx-preserve cycle) and is
-// unaffected. JSON callers still get the appropriate status code and a structured
-// error.
-async function htmxOrJsonError(res, isHtmx, orch, view, jsonStatus, code, message) {
-    if (isHtmx) {
-        const p = await gatherPartialInputs(orch, view);
-        res.statusCode = 200;
-        res.setHeader('content-type', 'text/html; charset=utf-8');
-        res.setHeader('cache-control', 'no-store');
-        res.end(renderAttentionPartial(p, { errorMessage: message }));
-        return;
-    }
-    jsonResponse(res, jsonStatus, { error: { code, message } });
-}
-async function readTextBody(req, maxBytes = 1_000_000) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let size = 0;
-        req.on('data', (chunk) => {
-            size += chunk.length;
-            if (size > maxBytes) {
-                req.destroy();
-                reject(new Error('request body too large'));
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-        req.on('error', reject);
-    });
-}
-async function gatherPartialInputs(orch, view) {
-    const trackerRoot = view.trackerRoot ?? '(unset)';
-    let diskIssues = [];
-    if (view.trackerRoot) {
-        try {
-            diskIssues = await listIssuesFromDisk(view.trackerRoot);
-        }
-        catch {
-            diskIssues = [];
-        }
-    }
-    return {
-        workflowName: path.basename(view.workflowPath || 'workflow.md'),
-        workflowPath: view.workflowPath || '',
-        trackerRoot,
-        states: view.states,
-        snapshot: orch.snapshot(),
-        diskIssues,
-    };
+// EVERYTHING here is (data) -> string. ZERO IO, ZERO async, ZERO node: imports, no
+// process / fetch / wall-clock / randomness. Imports ONLY from src/types/**.
+//
+// Two faithful-port notes on purity:
+//   • formatTimeShort EXTRACTS the HH:MM:SS field straight out of a supplied ISO
+//     string with a regex — no `new Date`, no clock read, no randomness — so it
+//     is a pure (string)->(string) transform that the determinism gate accepts.
+//     It renders the UTC time component of the timestamp (the upstream values are
+//     always `…Z` produced by toISOString), giving a stable 24-hour clock.
+//   • basename() comes from the pure core/path.ts helper (no `node:path`) so the
+//     workflow name can be derived from a path string purely.
+//
+// The render-input view types (RunningRow / RetryRow / HealthView / PartialInputs
+// / RenderSnapshot / TotalsView / DetailView) live in src/types/http/render.ts
+// per the hexagonal rule; the four the unit test imports are re-exported below so
+// existing importers keep their specifier.
+import { asString, asStringList, asInt, asTimestamp } from '../coerce.js';
+import { basename } from '../path.js';
+import { isInFlowTransition } from '../state-resolve.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// Tiny formatters / escaping
+// ─────────────────────────────────────────────────────────────────────────────
+const HTML_ESCAPES = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+export function escapeHtml(s) {
+    return s.replace(/[&<>"']/g, (c) => HTML_ESCAPES[c]);
 }
-/**
- * Map a declared state name to its pill colour class. Active states pulse green
- * (`running`), terminals settle into the muted "done" palette, holdings (Triage)
- * use the same idle palette they always have. Unknown names — issues sitting in a
- * directory that's no longer declared in `states:` — fall back to idle so the
- * dashboard still renders something legible.
- */
-function pillClassForState(states, stateName) {
+export function pillClassForState(states, stateName) {
     const lower = stateName.toLowerCase();
     const match = states.find((s) => s.name.toLowerCase() === lower);
     if (!match)
@@ -165,14 +62,14 @@ function trackerStatus(snap) {
         return 'working';
     return 'idle';
 }
-function formatTokens(n) {
+export function formatTokens(n) {
     if (n < 1000)
         return String(n);
     if (n < 1_000_000)
         return `${(n / 1000).toFixed(n < 10_000 ? 1 : 0)}k`;
     return `${(n / 1_000_000).toFixed(1)}M`;
 }
-function formatRuntime(seconds) {
+export function formatRuntime(seconds) {
     const s = Math.max(0, Math.round(seconds));
     if (s < 60)
         return `${s}s`;
@@ -183,42 +80,121 @@ function formatRuntime(seconds) {
     const rem = m % 60;
     return rem === 0 ? `${h}h` : `${h}h${rem}m`;
 }
-// `hour12: false` pins the 24-hour clock so the dashboard reads e.g. `14:30:05`
-// instead of locale-default AM/PM (`02:30:05 PM`) on 12-hour locales like en-US.
+// Lifts the `HH:MM:SS` field straight out of an ISO timestamp (the upstream
+// values are always `…Z` from toISOString), giving a stable 24-hour clock such
+// as `14:30:05`. PURE: a regex over the supplied string — no `new Date`, no
+// current-wall-clock read — so the determinism gate accepts it. Returns '' for a
+// nullish or non-ISO input.
+const ISO_TIME_RE = /T(\d{2}:\d{2}:\d{2})/;
 export function formatTimeShort(iso) {
-    if (!iso)
-        return '';
-    const d = new Date(iso);
-    if (Number.isNaN(d.getTime()))
-        return '';
-    return d.toLocaleTimeString(undefined, {
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-        hour12: false,
-    });
+    return (iso && ISO_TIME_RE.exec(iso)?.[1]) || '';
 }
-function truncate(text, max) {
+export function truncate(text, max) {
     if (!text)
         return '';
     const trimmed = text.replace(/\s+/g, ' ').trim();
     return trimmed.length > max ? trimmed.slice(0, max - 1) + '…' : trimmed;
 }
-// The header partial returns ONLY the tracker-state badge content. Brand, workflow name,
-// tracker root, and the refresh button live in the static shell and never repoll, so the
-// 2s heartbeat doesn't flash the whole strip.
-function renderHeaderPartial(p) {
+// ─────────────────────────────────────────────────────────────────────────────
+// Header + system-health strip
+// ─────────────────────────────────────────────────────────────────────────────
+export function renderHeaderPartial(p) {
     const status = trackerStatus(p.snapshot);
     const statusLabel = status === 'attention' ? 'attention' : status === 'working' ? 'working' : 'idle';
     return `<span class="badge badge-${status}" aria-label="tracker state: ${statusLabel}">${statusLabel}</span>`;
 }
-// ─── Top-of-page attention ticker ───────────────────────────────────────
-// A horizontal strip listing what currently needs the operator's eyes: pending
-// steering replies and stuck retries. Each identifier is an anchor link to the
-// row inside the board — the operator scans the ticker, jumps to the column,
-// and replies in place. The steering reply form itself now lives inline on its
-// row in the board, so this ticker stays thin.
-function renderAttentionPartial(p, opts) {
+// Shorten a gondolin image ref for display: a content-addressed hex digest
+// collapses to its first 12 chars (the conventional "short digest"), a long
+// opaque ref is clipped, and a plain `name:tag` is shown as-is. The full value
+// always rides along in the field title so the exact identifier is never lost.
+function shortenImageRef(image) {
+    if (!image)
+        return 'unset';
+    const hex = /([0-9a-f]{12,64})/i.exec(image);
+    if (hex) {
+        const short = hex[1].slice(0, 12);
+        return image.startsWith('sha256:') ? `sha256:${short}` : short;
+    }
+    return image.length > 28 ? `${image.slice(0, 27)}…` : image;
+}
+function credentialField(creds) {
+    if (creds.length === 0)
+        return { key: 'cred', value: 'n/a' };
+    const missing = creds.filter((c) => !c.ok).map((c) => c.adapter);
+    if (missing.length === 0)
+        return { key: 'cred', value: 'ok' };
+    return { key: 'cred', value: `missing:${missing.join(',')}`, bad: true };
+}
+function trackerField(writable) {
+    if (writable === null)
+        return { key: 'tracker', value: 'unset', bad: true };
+    return writable
+        ? { key: 'tracker', value: 'writable' }
+        : { key: 'tracker', value: 'readonly', bad: true };
+}
+// One `<State>=<adapter>/<model>` field per active state, with per-state
+// overrides applied (a state inheriting the adapter's default renders
+// `/default`). Reported per state — never a single global `model=` — so the
+// readout cannot imply a default model for a state that overrides it.
+function dispatchFields(dispatch) {
+    if (dispatch.length === 0)
+        return [{ key: 'dispatch', value: '(no active states)' }];
+    return dispatch.map((d) => ({ key: d.state, value: `${d.adapter}/${d.model ?? 'default'}` }));
+}
+function healthFields(health) {
+    return [
+        ...dispatchFields(health.dispatch),
+        { key: 'image', value: shortenImageRef(health.gondolin_image), full: health.gondolin_image ?? 'unset' },
+        credentialField(health.credentials),
+        trackerField(health.tracker_root_writable),
+        { key: 'poll', value: formatTimeShort(health.last_poll_at) || '—' },
+    ];
+}
+function renderHealthField(f) {
+    const cls = `hf${f.bad ? ' hf-bad' : ''}`;
+    const title = f.full && f.full !== f.value ? ` title="${escapeHtml(f.full)}"` : '';
+    return `<span class="${cls}"${title}>${escapeHtml(`${f.key}=${f.value}`)}</span>`;
+}
+// One-time microVM image build banner (issue 206): while the reconcile loop is
+// converting `gondolin.oci_image` into a Gondolin asset, surface a prominent
+// (error-coloured, so it reads as "attention, but expected") banner explaining the
+// hold so "why is nothing dispatching" has an answer. Cleared once the asset caches.
+function renderBuildingImageBanner(building) {
+    const phase = building.phase ? ` · ${escapeHtml(building.phase)}` : '';
+    return (`<span class="hf hf-bad" title="${escapeHtml(building.ref)}">` +
+        `building microVM image (one-time setup) — this can take several minutes${phase}` +
+        `</span>`);
+}
+// Failed one-time microVM image build banner (issue 206 review): the conversion
+// threw and dispatch stays HELD (the reconcile gate suppresses an auto-retry for
+// this digest), so surface a PERSISTENT error banner with the failing ref + the
+// converter's message + remediation — otherwise a failed build reads as "nothing is
+// dispatching" with no explanation. Stays until the ref/digest converts or a fresh
+// digest supersedes it.
+function renderFailedImageBanner(failed) {
+    const detail = failed.message ? ` — ${escapeHtml(failed.message)}` : '';
+    return (`<span class="hf hf-bad" title="${escapeHtml(failed.ref)}">` +
+        `microVM image build failed (VM dispatch held)${detail} — ` +
+        `fix gondolin.oci_image or push a new image, then restart symphony to retry` +
+        `</span>`);
+}
+export function renderHealthPartial(health) {
+    if (!health)
+        return `<span class="hf">health=unavailable</span>`;
+    // An in-flight build takes precedence over a prior failure (they're mutually
+    // exclusive at the source, but render defensively): show "building" while
+    // converting, the failure banner only once the build cleared but dispatch is held.
+    const banner = health.building_image
+        ? renderBuildingImageBanner(health.building_image)
+        : health.failed_image
+            ? renderFailedImageBanner(health.failed_image)
+            : '';
+    return banner + healthFields(health).map(renderHealthField).join('');
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Top-of-page attention ticker
+// ─────────────────────────────────────────────────────────────────────────────
+export function renderAttentionPartial(p, opts) {
     const awaiting = p.snapshot.running.filter((r) => r.steering_requested);
     // Continuations are calm post-transition resumes, not failures — keep them
     // off the attention ticker so a clean handoff doesn't read as a stuck retry
@@ -237,9 +213,7 @@ function renderAttentionPartial(p, opts) {
         const links = retrying
             .map((r) => `<a href="#row-${escapeHtml(r.issue_identifier)}" class="tick-id">${escapeHtml(r.issue_identifier)}</a>`)
             .join(' ');
-        const label = stuck > 0
-            ? `${retrying.length} retrying · ${stuck} with error`
-            : `${retrying.length} retrying`;
+        const label = stuck > 0 ? `${retrying.length} retrying · ${stuck} with error` : `${retrying.length} retrying`;
         segments.push(`<span class="tick tick-retry"><span class="tick-label">${label}</span> ${links}</span>`);
     }
     if (errorMessage) {
@@ -247,28 +221,20 @@ function renderAttentionPartial(p, opts) {
     }
     return segments.join('');
 }
-// ─── Board (kanban) ─────────────────────────────────────────────────────
-// One column per declared state in workflow declaration order. Each on-disk
-// issue renders as a flat row in its state's column; transient orchestrator
-// state (running / retrying / awaiting steering) is overlaid via a pill, a
-// metadata trail, and — for awaiting — an inline question + reply form. Issues
-// sitting in an undeclared state directory (e.g. after a workflow rename) get
-// trailing columns so they stay visible until reconciled rather than silently
-// dropping out of the dashboard.
-function renderBoardPartial(p) {
+// ─────────────────────────────────────────────────────────────────────────────
+// Board (kanban)
+// ─────────────────────────────────────────────────────────────────────────────
+export function renderBoardPartial(p) {
     const runningById = new Map();
     for (const r of p.snapshot.running)
         runningById.set(r.issue_identifier, r);
     const retryingById = new Map();
     for (const r of p.snapshot.retrying)
         retryingById.set(r.issue_identifier, r);
-    // Group disk issues by lower-cased state name. LocalMarkdownTracker matches
-    // state directories case-insensitively against the declared `states:` keys
-    // (src/trackers/local.ts §scanAllAt: `declared.has(dirEntry.toLowerCase())`),
-    // so the dashboard must mirror that or a `todo/` directory under declared
-    // `Todo` would be misclassified as an orphan and split off into its own
-    // trailing column. `displayName` keeps the on-disk casing for orphan column
-    // headers (the only place we need to show a non-declared name).
+    // Group disk issues by lower-cased state name (LocalMarkdownTracker matches
+    // state directories case-insensitively against declared `states:` keys), so a
+    // `todo/` dir under declared `Todo` is not misclassified as an orphan.
+    // `displayName` keeps the on-disk casing for orphan column headers.
     const byStateLower = new Map();
     for (const i of p.diskIssues) {
         const key = i.state.toLowerCase();
@@ -279,22 +245,17 @@ function renderBoardPartial(p) {
             byStateLower.set(key, { displayName: i.state, items: [i] });
     }
     // Terminal columns (Done, Cancelled, …) are deliberately omitted from the
-    // board. The orchestrator's glance test — "is anything stuck, is anything
-    // running" — doesn't read off finished work, and a wall of archived rows
-    // dilutes the active surface. Terminal issues stay reachable through their
-    // /issues/<id> detail page; a dedicated history surface is the natural place
-    // to surface them again once we have something to anchor the row on (a PR
-    // link, a final token total, a closed-at timestamp).
+    // board: the glance test "is anything stuck, is anything running" doesn't read
+    // off finished work. Terminal issues stay reachable through /issues/<id>.
     const declared = p.states
         .filter((state) => state.role !== 'terminal')
         .map((state) => {
         const items = byStateLower.get(state.name.toLowerCase())?.items ?? [];
-        return renderColumn(state, items, runningById, retryingById);
+        return renderColumn(state, items, runningById, retryingById, p.states);
     });
-    // Orphan columns: on-disk state directories whose names are not in the
-    // declared `states:` set. These render even when they look "terminal" because
-    // they're an error condition the operator needs to see (a workflow rename
-    // left files behind), not a clean archive.
+    // Orphan columns: on-disk state directories whose names are not declared.
+    // These render even when terminal-looking because they signal an error the
+    // operator needs to see (a workflow rename left files behind).
     const declaredLower = new Set(p.states.map((s) => s.name.toLowerCase()));
     const orphans = [];
     for (const [key, entry] of byStateLower) {
@@ -303,10 +264,25 @@ function renderBoardPartial(p) {
         orphans.push({ name: entry.displayName, items: entry.items });
     }
     orphans.sort((a, b) => a.name.localeCompare(b.name));
-    const orphanColumns = orphans.map((o) => renderColumn({ name: o.name, role: 'terminal' }, o.items, runningById, retryingById, { orphan: true }));
-    return `<div class="kanban">${declared.join('')}${orphanColumns.join('')}</div>`;
+    const orphanColumns = orphans.map((o) => renderColumn({ name: o.name, role: 'terminal' }, o.items, runningById, retryingById, p.states, {
+        orphan: true,
+    }));
+    const emptyState = p.diskIssues.length === 0 ? renderBoardEmptyState(p.states) : '';
+    return `${emptyState}<div class="kanban">${declared.join('')}${orphanColumns.join('')}</div>`;
+}
+// Whole-board empty state (first run): rendered only when the entire tracker
+// holds zero issues. Teaches the two first-run affordances once (column `+` and
+// the on-disk `issues/<FirstActive>/<id>.md` path), then disappears.
+function renderBoardEmptyState(states) {
+    const firstActive = states.find((s) => s.role === 'active')?.name ?? 'Todo';
+    const esc = escapeHtml(firstActive);
+    return `<section class="board-empty" aria-label="no issues yet">
+  <p class="be-lead">no issues yet — dispatch your first</p>
+  <p class="be-how">press <span class="be-key">+</span> on a column, or add <code>issues/${esc}/&lt;id&gt;.md</code></p>
+  <p class="be-note dim">agents pick up <code>${esc}</code> on the next poll</p>
+</section>`;
 }
-function renderColumn(state, items, runningById, retryingById, opts) {
+function renderColumn(state, items, runningById, retryingById, allStates, opts) {
     const orphan = opts?.orphan === true;
     const canAdd = !orphan && state.role !== 'terminal';
     // Sort within a column so anything needing attention floats to the top:
@@ -334,7 +310,10 @@ function renderColumn(state, items, runningById, retryingById, opts) {
         return a.identifier.localeCompare(b.identifier);
     });
     const rowsHtml = sorted
-        .map((i) => renderIssueRow(i, state, runningById.get(i.identifier), retryingById.get(i.identifier), { orphan }))
+        .map((i) => renderIssueRow(i, state, runningById.get(i.identifier), retryingById.get(i.identifier), {
+        orphan,
+        allStates,
+    }))
         .join('');
     const addBtn = canAdd
         ? `<button type="button" class="col-add"
@@ -346,7 +325,7 @@ function renderColumn(state, items, runningById, retryingById, opts) {
         ? `<p class="col-empty">drop into <code>${escapeHtml(state.name)}/</code></p>`
         : '';
     const orphanBadge = orphan
-        ? `<span class="col-orphan" title="state not declared in workflow.md">undeclared</span>`
+        ? `<span class="col-orphan" title="state not declared in workflow.yaml">undeclared</span>`
         : '';
     return `<section class="col col-${escapeHtml(state.role)}${orphan ? ' col-orphan-wrap' : ''}" data-state="${escapeHtml(state.name)}">
   <header class="col-head">
@@ -359,19 +338,16 @@ function renderColumn(state, items, runningById, retryingById, opts) {
   <div class="col-body">${rowsHtml}${emptyHint}</div>
 </section>`;
 }
-function rowFlags(state, running, retrying, orphan) {
+function rowFlags(running, retrying, orphan) {
     const isAwaiting = !!running?.steering_requested;
-    // A `continuation` retry is the slot-holding resume of a clean handoff (e.g.
-    // Review → Todo): the orchestrator still holds the issue's slot and redispatches
-    // within ~1s, so the card stays "running" across the handoff instead of flashing
-    // a transient pill. Only `failure`-backoff retries are "retrying" (issues
-    // 146/154; the design system's Three-Pill Rule — running/retrying/idle only).
+    // A `continuation` retry is the slot-holding resume of a clean handoff: the
+    // card stays "running" across the handoff instead of flashing a transient
+    // pill. Only `failure`-backoff retries are "retrying" (Three-Pill Rule).
     const isContinuation = retrying?.kind === 'continuation';
     return {
         isAwaiting,
         isRunning: (!!running || isContinuation) && !isAwaiting,
         isRetrying: !!retrying && !isContinuation,
-        isHolding: !orphan && state.role === 'holding',
         orphan,
     };
 }
@@ -389,10 +365,9 @@ function rowMetaHtml(running, retrying) {
         const tokens = formatTokens(running.tokens.total_tokens || 0);
         return `<span class="row-meta">turn ${running.turn_count} · ${escapeHtml(tokens)} tok</span>`;
     }
-    // A `continuation` carries no operator-facing meta: the card reads as "running"
-    // across the handoff (see rowFlags), so the brief slot-holding window stays
-    // silent rather than surfacing an "attempt N · due" trail. Only `failure`
-    // retries show the backoff schedule.
+    // A `continuation` carries no operator-facing meta: the card reads as
+    // "running" across the handoff, so the slot-holding window stays silent. Only
+    // `failure` retries show the backoff schedule.
     if (retrying && retrying.kind !== 'continuation') {
         const dueAt = formatTimeShort(retrying.due_at) || '—';
         return `<span class="row-meta">attempt ${retrying.attempt} · due ${escapeHtml(dueAt)}</span>`;
@@ -410,21 +385,52 @@ function rowRetryErrHtml(retrying) {
         return '';
     return `<div class="row-err">${escapeHtml(truncate(retrying.error, 200))}</div>`;
 }
-function rowTriageActionsHtml(ident, f) {
-    if (!(f.isHolding && !f.isRunning && !f.isAwaiting && !f.isRetrying))
+// The `<option>` list for a move picker: every declared state except `current`,
+// each flagged `data-offflow` when the target is outside `current`'s non-null
+// `allowed_transitions` (the exact off-flow condition the agent path enforces).
+// Shared by the board row picker and the issue-detail picker so the two never
+// drift. Returns '' when `current` is the only declared state.
+function moveTargetOptionsHtml(current, allStates) {
+    const fromLower = current.name.toLowerCase();
+    const fromAllowed = current.allowed_transitions ?? null;
+    return allStates
+        .filter((s) => s.name.toLowerCase() !== fromLower)
+        .map((s) => {
+        const offAttr = isInFlowTransition(fromAllowed, current.name, s.name) ? '' : ' data-offflow="1"';
+        const esc = escapeHtml(s.name);
+        return `<option value="${esc}"${offAttr}>${esc}</option>`;
+    })
+        .join('');
+}
+// Per-row move picker (issue 126): a `<select>` of every declared state except
+// the row's own, rendered for every DECLARED row — settled OR mid-flight. On a
+// LIVE row (running / awaiting / retrying) the move is also the operator's cancel
+// verb (issue 189): picking a state stops the in-flight attempt and moves the
+// issue, so the placeholder reads `cancel / move to…` and the select carries
+// `data-live` so the dashboard script confirms before stopping the run. An orphan
+// row's directory is not a declared state to move within, so it is still skipped.
+// Each option carries a server-computed `data-offflow` flag (the target is outside
+// the from-state's non-null `allowed_transitions`); the script confirms before
+// POSTing an off-flow move. The endpoint never blocks — these are soft guardrails.
+function rowMoveActionsHtml(ident, current, f, allStates) {
+    if (f.orphan)
+        return '';
+    if (!allStates || allStates.length === 0)
+        return '';
+    const options = moveTargetOptionsHtml(current, allStates);
+    if (!options)
         return '';
     const enc = encodeURIComponent(ident);
+    const live = f.isRunning || f.isAwaiting || f.isRetrying;
+    const liveAttr = live ? ' data-live="1"' : '';
+    const placeholder = live ? 'cancel / move to…' : 'move to…';
     return `<div class="row-actions">
-    <form class="row-action"
-          hx-post="/api/v1/issues/${enc}/approve"
-          hx-target="#board" hx-swap="morph:innerHTML">
-      <button type="submit" class="ghost-sm" title="approve into the first active state">approve</button>
-    </form>
-    <form class="row-action"
-          hx-post="/api/v1/issues/${enc}/discard"
-          hx-target="#board" hx-swap="morph:innerHTML">
-      <button type="submit" class="ghost-sm danger" title="discard the proposal">discard</button>
-    </form>
+    <select class="row-move"${liveAttr}
+            data-ident="${enc}" data-from="${escapeHtml(current.name)}"
+            aria-label="move ${escapeHtml(ident)} to another state">
+      <option value="" selected disabled>${placeholder}</option>
+      ${options}
+    </select>
   </div>`;
 }
 function rowClassList(f, retryHasErr) {
@@ -438,8 +444,8 @@ function rowClassList(f, retryHasErr) {
         .filter(Boolean)
         .join(' ');
 }
-function renderIssueRow(i, state, running, retrying, opts) {
-    const f = rowFlags(state, running, retrying, opts?.orphan === true);
+export function renderIssueRow(i, state, running, retrying, opts) {
+    const f = rowFlags(running, retrying, opts?.orphan === true);
     const escIdent = escapeHtml(i.identifier);
     const href = `/issues/${encodeURIComponent(i.identifier)}`;
     const steering = f.isAwaiting ? renderSteeringInline(running) : '';
@@ -454,10 +460,13 @@ function renderIssueRow(i, state, running, retrying, opts) {
   <a class="row-title" href="${href}">${escapeHtml(i.title)}</a>
   ${rowPeekHtml(running, f.isAwaiting)}
   ${rowRetryErrHtml(retrying)}
-  ${rowTriageActionsHtml(i.identifier, f)}
+  ${rowMoveActionsHtml(i.identifier, state, f, opts?.allStates)}
   ${steering}
 </article>`;
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Inline steering on awaiting rows
+// ─────────────────────────────────────────────────────────────────────────────
 function steeringSummaryLabel(hasOriginalTask, hasContext) {
     if (hasOriginalTask && hasContext)
         return 'original task & agent’s context';
@@ -493,13 +502,18 @@ function steeringExtraPanel(title, body, context) {
     </div>
   </details>`;
 }
-function renderSteeringInline(r) {
+export function renderSteeringInline(r) {
     const question = (r.steering_question ?? '').trim() || '(no question text)';
     const context = (r.steering_context ?? '').trim();
     const issueTitle = (r.issue_title ?? '').trim();
     const issueBody = (r.issue_body ?? '').trim();
-    // Stable textarea id + hx-preserve so the every-2s board repoll keeps the
-    // operator's draft reply intact across morph swaps.
+    // Stable textarea id so the every-2s board repoll's idiomorph swap REUSES this
+    // node (focus + caret intact) rather than recreating it, and so the draft VALUE
+    // survives the swap via the board's `ignoreActiveValue` morph config (see
+    // renderDashboardHtml). The old `hx-preserve="true"` is gone on purpose: under a
+    // morph swap htmx's preserve logic detaches and re-inserts the live textarea on
+    // every poll, which blurred it and snapped the caret back to the top, making the
+    // box unwritable while a reply was being typed (issue 228).
     const textareaId = `reply-${r.issue_identifier}`;
     return `<div class="steering">
   <div class="steering-q">${renderMarkdown(question)}</div>
@@ -509,8 +523,7 @@ function renderSteeringInline(r) {
         hx-target="#ticker" hx-swap="morph:innerHTML">
     <textarea id="${escapeHtml(textareaId)}" name="text" required
               placeholder="your reply…"
-              aria-label="reply to ${escapeHtml(r.issue_identifier)}"
-              hx-preserve="true"></textarea>
+              aria-label="reply to ${escapeHtml(r.issue_identifier)}"></textarea>
     <div class="reply-row">
       <span class="hint dim">enter to send · shift+enter for newline</span>
       <button type="submit" class="ghost">send reply</button>
@@ -518,13 +531,10 @@ function renderSteeringInline(r) {
   </form>
 </div>`;
 }
-// ─── Right-side new-issue panel (the One Card) ─────────────────────────
-// The dashboard's only card-shaped surface (DESIGN.md §5 One-Card Rule). Slides
-// in from the right edge when the operator clicks a column's `+` button; the
-// column the click came from pre-selects the state field. Non-modal: the board
-// stays visible and interactive on the left. Esc closes; backdrop clicks do not
-// (avoid accidental discards of in-progress drafts).
-function renderNewIssuePanel(p) {
+// ─────────────────────────────────────────────────────────────────────────────
+// Right-side new-issue panel (the One Card)
+// ─────────────────────────────────────────────────────────────────────────────
+export function renderNewIssuePanel(p) {
     const targets = p.states.filter((s) => s.role !== 'terminal');
     const firstActive = p.states.find((s) => s.role === 'active');
     const defaultState = (firstActive ?? targets[0])?.name ?? '';
@@ -553,15 +563,15 @@ function renderNewIssuePanel(p) {
   </form>
 </aside>`;
 }
-function renderTotalsPartial(p) {
+export function renderTotalsPartial(p) {
     const t = p.snapshot.session_totals;
     if (!t || (t.input_tokens === 0 && t.output_tokens === 0 && t.seconds_running === 0))
         return '';
     return `${formatTokens(t.input_tokens)} in · ${formatTokens(t.output_tokens)} out · ${formatTokens(t.total_tokens)} total · ${formatRuntime(t.seconds_running)} runtime`;
 }
-// Dashboard CSS, hoisted to a top-level constant so renderDashboardHtml stays
-// within the imperative-shell max-lines budget. Pure presentation content — no
-// interpolated values — so it lives outside the function.
+// ─────────────────────────────────────────────────────────────────────────────
+// Dashboard CSS + client JS (hoisted top-level constants — pure presentation).
+// ─────────────────────────────────────────────────────────────────────────────
 const DASHBOARD_CSS = `
 :root {
   color-scheme: dark;
@@ -624,6 +634,20 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; fo
 #header .refresh:hover { border-color: var(--muted); }
 #header .refresh:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
 
+/* ── system-health strip ─────────────────────────────────────────────── */
+#health {
+  display: flex; flex-wrap: wrap; align-items: baseline;
+  gap: 0.25rem 1rem;
+  padding: 0.35rem 1.25rem;
+  background: var(--bench);
+  border-bottom: 1px solid var(--rule-soft);
+  font: 12px/1.4 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  color: var(--muted);
+  font-variant-numeric: tabular-nums;
+}
+#health .hf { color: var(--muted); white-space: nowrap; }
+#health .hf-bad { color: var(--err); }
+
 /* ── ticker ──────────────────────────────────────────────────────────── */
 #ticker {
   display: flex; flex-wrap: wrap; gap: 0.5rem 1.25rem; align-items: center;
@@ -698,6 +722,23 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; fo
 }
 .col-empty code { color: var(--muted); }
 
+/* ── whole-board empty state (first run) ─────────────────────────────── */
+.board-empty {
+  margin: 0 0 1.25rem; padding: 0 0 1rem;
+  border-bottom: 1px solid var(--rule-soft);
+  display: grid; gap: 0.25rem; max-width: 64ch;
+}
+.board-empty p { margin: 0; line-height: 1.5; }
+.board-empty .be-lead { color: var(--base); }
+.board-empty .be-how { color: var(--muted); }
+.board-empty .be-note { font-size: 0.9em; }
+.board-empty code { color: var(--muted); }
+.board-empty .be-key {
+  display: inline-block; padding: 0 0.35rem;
+  border: 1px solid var(--rule-firm); border-radius: 4px;
+  color: var(--muted);
+}
+
 /* ── row ─────────────────────────────────────────────────────────────── */
 .row {
   padding: 0.55rem 0.6rem; margin: 0 -0.6rem;
@@ -748,7 +789,18 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; fo
   overflow-wrap: anywhere; word-break: break-word;
 }
 .row-actions { display: flex; gap: 0.4rem; margin-top: 0.2rem; }
-.row-action { display: inline; margin: 0; padding: 0; }
+/* per-row move picker (issue 126): a compact select offering every other
+   declared state; off-flow options are confirmed in the client before POST. */
+.row-move {
+  background: transparent; color: var(--muted);
+  border: 1px solid var(--rule-firm); border-radius: 3px;
+  padding: 0.18rem 0.5rem; font: inherit; font-size: 0.82em; cursor: pointer;
+  max-width: 100%;
+  transition: color 160ms cubic-bezier(.22,1,.36,1), border-color 160ms cubic-bezier(.22,1,.36,1);
+}
+.row-move:hover { color: var(--strong); border-color: var(--muted); }
+.row-move:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
+.row-move:disabled { opacity: 0.6; cursor: default; }
 .ghost {
   background: var(--chip); color: var(--base);
   border: 1px solid var(--rule-firm); border-radius: 4px;
@@ -757,15 +809,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; fo
 }
 .ghost:hover { border-color: var(--muted); }
 .ghost:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
-.ghost-sm {
-  background: transparent; color: var(--muted);
-  border: 1px solid var(--rule-firm); border-radius: 3px;
-  padding: 0.18rem 0.6rem; font: inherit; font-size: 0.82em; cursor: pointer;
-  transition: color 160ms cubic-bezier(.22,1,.36,1), border-color 160ms cubic-bezier(.22,1,.36,1);
-}
-.ghost-sm:hover { color: var(--strong); border-color: var(--muted); }
-.ghost-sm.danger:hover { color: var(--err); border-color: var(--err); }
-.ghost-sm:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
 
 /* ── inline steering on awaiting rows ────────────────────────────────── */
 .steering {
@@ -932,9 +975,54 @@ footer.totals:empty { display: none; }
 .htmx-request .refresh { opacity: 0.6; }
 .htmx-settling .row-peek { opacity: 0.85; }
 `;
-// Dashboard new-issue panel controller. Stored as a top-level constant so the
-// renderDashboardHtml shell stays inside the imperative-shell line budget.
+// Shared client move-submit logic, embedded by BOTH the dashboard board picker
+// (event-delegated — the board morphs every poll) and the issue-detail picker
+// (one static select, page reloads). Defines `__symphonyMove(sel, onSuccess)`:
+// confirm first when the move stops a live run (issue 189: a `data-live` select)
+// and/or the chosen option is off-flow, POST the move (the server never blocks —
+// soft guardrail), then run `onSuccess`. The two warnings collapse into ONE
+// confirm so a live off-flow move never double-prompts. Factored out so the
+// confirm text and the POST shape can't drift between the two pages.
+const MOVE_SUBMIT_JS = `
+async function __symphonyMove(sel, onSuccess) {
+  const target = sel.value;
+  if (!target) return;
+  const ident = sel.getAttribute('data-ident') || '';
+  const from = sel.getAttribute('data-from') || '';
+  const opt = sel.options[sel.selectedIndex];
+  const offFlow = !!opt && opt.getAttribute('data-offflow') === '1';
+  const live = sel.getAttribute('data-live') === '1';
+  const decId = decodeURIComponent(ident);
+  let warn = '';
+  if (live) warn = 'Stop the in-flight attempt for ' + decId + ' and move it to "' + target + '"?';
+  else if (offFlow) warn = 'Move ' + decId + ' to "' + target + '"?';
+  if (warn && offFlow) warn += ' That is outside the declared flow from "' + from + '".';
+  if (warn && !window.confirm(warn)) {
+    sel.value = '';
+    return;
+  }
+  sel.disabled = true;
+  try {
+    const res = await fetch('/api/v1/issues/' + ident + '/move', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ state: target, from_state: from }),
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => null);
+      throw new Error((data && data.error && data.error.message) || ('HTTP ' + res.status));
+    }
+    onSuccess();
+  } catch (err) {
+    sel.disabled = false;
+    sel.value = '';
+    window.alert('move failed: ' + err.message);
+  }
+}
+`;
+// Dashboard new-issue panel controller. Top-level constant — pure presentation.
 const DASHBOARD_SCRIPT = `
+${MOVE_SUBMIT_JS}
 (() => {
   const $ = (id) => document.getElementById(id);
   const panel = $('new-panel');
@@ -989,6 +1077,18 @@ const DASHBOARD_SCRIPT = `
     }
   });
 
+  // Per-row move picker (issue 126): selecting a target state moves the issue
+  // (event-delegated because the board morphs every poll). On success the board
+  // is refreshed; __symphonyMove handles the off-flow confirm + the POST.
+  document.addEventListener('change', (ev) => {
+    const sel = ev.target;
+    if (!(sel instanceof HTMLSelectElement) || !sel.classList.contains('row-move')) return;
+    __symphonyMove(sel, () => {
+      fetch('/api/v1/refresh', { method: 'POST' }).catch(() => {});
+      document.body.dispatchEvent(new CustomEvent('refreshed', { bubbles: true }));
+    });
+  });
+
   form.addEventListener('submit', async (ev) => {
     ev.preventDefault();
     setMsg('creating…');
@@ -1017,7 +1117,7 @@ const DASHBOARD_SCRIPT = `
   });
 })();
 `;
-function renderDashboardHtml(p) {
+export function renderDashboardHtml(p, health) {
     return `<!doctype html>
 <html lang="en"><head>
 <meta charset="utf-8">
@@ -1041,13 +1141,17 @@ function renderDashboardHtml(p) {
           aria-label="refresh now" title="poll &amp; reconcile">⟳</button>
 </header>
 
+<div id="health" aria-label="system health"
+     hx-get="/api/v1/partials/health" hx-trigger="every 2s, refreshed from:body"
+     hx-swap="morph:innerHTML">${renderHealthPartial(health)}</div>
+
 <div id="ticker"
      hx-get="/api/v1/partials/attention" hx-trigger="every 2s, refreshed from:body"
      hx-swap="morph:innerHTML">${renderAttentionPartial(p)}</div>
 
 <main id="board"
       hx-get="/api/v1/partials/board" hx-trigger="every 2s, refreshed from:body"
-      hx-swap="morph:innerHTML">${renderBoardPartial(p)}</main>
+      hx-swap='morph:{"morphStyle":"innerHTML","ignoreActiveValue":true,"restoreFocus":true}'>${renderBoardPartial(p)}</main>
 
 ${renderNewIssuePanel(p)}
 
@@ -1059,9 +1163,6 @@ ${renderNewIssuePanel(p)}
 
 </body></html>`;
 }
-function escapeHtml(s) {
-    return s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
-}
 const FENCE_OPEN_RE = /^```([\w-]*)\s*$/;
 const FENCE_CLOSE_RE = /^```\s*$/;
 const HEADER_RE = /^(#{1,6})\s+(.+?)\s*#*\s*$/;
@@ -1116,12 +1217,12 @@ function matchBlockquote(lines, i) {
     return { html: `<blockquote>${renderMarkdown(buf.join('\n'))}</blockquote>`, nextI: j };
 }
 function isBlockBoundary(line) {
-    return line.trim() === ''
-        || FENCE_OPEN_RE.test(line)
-        || /^#{1,6}\s+/.test(line)
-        || UL_RE.test(line)
-        || OL_RE.test(line)
-        || BLOCKQUOTE_RE.test(line);
+    return (line.trim() === '' ||
+        FENCE_OPEN_RE.test(line) ||
+        /^#{1,6}\s+/.test(line) ||
+        UL_RE.test(line) ||
+        OL_RE.test(line) ||
+        BLOCKQUOTE_RE.test(line));
 }
 function matchParagraph(lines, i) {
     const para = [];
@@ -1141,23 +1242,23 @@ export function renderMarkdown(input) {
             i++;
             continue;
         }
-        const m = matchFencedCode(lines, i)
-            ?? matchHeader(lines, i)
-            ?? matchList(lines, i, UL_RE, UL_ITEM_RE, 'ul')
-            ?? matchList(lines, i, OL_RE, OL_ITEM_RE, 'ol')
-            ?? matchBlockquote(lines, i)
-            ?? matchParagraph(lines, i);
+        const m = matchFencedCode(lines, i) ??
+            matchHeader(lines, i) ??
+            matchList(lines, i, UL_RE, UL_ITEM_RE, 'ul') ??
+            matchList(lines, i, OL_RE, OL_ITEM_RE, 'ol') ??
+            matchBlockquote(lines, i) ??
+            matchParagraph(lines, i);
         blocks.push(m.html);
         i = m.nextI;
     }
     return blocks.join('\n');
 }
-function renderInlineMarkdown(input) {
+export function renderInlineMarkdown(input) {
     const codes = [];
     let text = input.replace(/`([^`\n]+)`/g, (_m, code) => {
         const idx = codes.length;
         codes.push(`<code>${escapeHtml(code)}</code>`);
-        return `C${idx}`;
+        return ` C${idx} `;
     });
     text = escapeHtml(text);
     text = text.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, (m, label, url) => {
@@ -1170,38 +1271,22 @@ function renderInlineMarkdown(input) {
     text = text.replace(/(^|[^*\w])\*([^*\n]+)\*(?!\w)/g, '$1<em>$2</em>');
     text = text.replace(/(^|[^_\w])_([^_\n]+)_(?!\w)/g, '$1<em>$2</em>');
     text = text.replace(/\n/g, '<br>');
-    text = text.replace(/C(\d+)/g, (_m, idx) => codes[Number(idx)]);
+    text = text.replace(/ C(\d+) /g, (_m, idx) => codes[Number(idx)]);
     return text;
 }
 // ─────────────────────────────────────────────────────────────────────────────
-// Issue-detail page. Linked from the identifier on every "on disk" and triage
-// row. Shows what the on-disk Markdown file says: the front-matter metadata
-// (labels, priority, blocked_by, provenance, timestamps) and the body rendered
-// through the same minimal Markdown engine the steering panel uses. Read-only
-// — actions live on the dashboard, not here. Follows the design system's
-// quiet-workshop rules: flat panels, tabular numerics, no shadows, status pill
-// uses the existing palette.
+// Issue-detail page. Read-only HTML view of one on-disk issue: front-matter
+// metadata (labels, priority, blocked_by, provenance, timestamps) + the Markdown
+// body rendered through the same minimal engine the steering panel uses.
 // ─────────────────────────────────────────────────────────────────────────────
-function asStringList(v) {
-    if (Array.isArray(v))
-        return v.filter((x) => typeof x === 'string');
-    return [];
-}
-function asString(v) {
-    return typeof v === 'string' && v.length > 0 ? v : null;
-}
-function asNumber(v) {
-    if (typeof v === 'number' && Number.isFinite(v))
-        return v;
-    return null;
-}
-function formatTimestamp(v) {
-    if (typeof v === 'string' && v.length > 0)
-        return v;
-    if (v instanceof Date)
-        return v.toISOString();
-    return null;
-}
+// Front-matter coercers (asString/asStringList/asInt/asTimestamp) are the
+// canonical ones from core/coerce.ts. NOTE(drift resolved): the old local copies
+// here carried a `v.length > 0` length-guard on asString and `formatTimestamp`
+// that the issue parser did not; the canonical asString has NO length-guard
+// (matching issue/parse.ts:toIssue), so the detail page now coerces front-matter
+// IDENTICALLY to the way an Issue is normalized — they can no longer drift. The
+// old formatTimestamp folds into asTimestamp (which DID keep the empty-string→
+// null guard). See core/coerce.ts header + tests/core/coerce.test.ts.
 function detailRow(label, value) {
     return `<div class="meta-row"><dt>${escapeHtml(label)}</dt><dd>${value}</dd></div>`;
 }
@@ -1239,18 +1324,22 @@ function detailTimestampRow(label, ts) {
     return detailRow(label, `<span class="num">${escapeHtml(ts)}</span>`);
 }
 // Pill colour follows the declared role: active → running, terminal → done,
-// holding → idle. An undeclared state (stale directory, file dropped by hand
-// into a name not in `states:`) falls back to idle so the detail page still
-// renders legibly.
+// holding → idle. An undeclared state falls back to idle.
 function buildDetailMetaRows(fm, stateClass, stateName) {
     const branchName = asString(fm['branch_name']);
-    const priority = asNumber(fm['priority']);
-    const createdAt = formatTimestamp(fm['created_at']);
-    const updatedAt = formatTimestamp(fm['updated_at']);
+    // priority via asInt (the Issue-normalization coercer), so a fractional value
+    // truncates here exactly as it does in issue/parse.ts:toIssue.
+    const priority = asInt(fm['priority']);
+    const createdAt = asTimestamp(fm['created_at']);
+    const updatedAt = asTimestamp(fm['updated_at']);
     const showUpdated = updatedAt && updatedAt !== createdAt ? updatedAt : null;
+    // NOTE(drift resolved): the Issue normalization (issue/parse.ts:toIssue)
+    // lowercases labels; this detail page used to render them un-cased. Lowercase
+    // here too so the detail page and the board/Issue agree. Pinned by render.test.
+    const labels = asStringList(fm['labels']).map((l) => l.toLowerCase());
     return [
         detailRow('state', `<span class="pill ${stateClass}">${escapeHtml(stateName)}</span>`),
-        detailLabelsRow(asStringList(fm['labels'])),
+        detailLabelsRow(labels),
         priority !== null ? detailRow('priority', `<span class="num">${escapeHtml(String(priority))}</span>`) : '',
         detailBlockedByRow(asStringList(fm['blocked_by'])),
         branchName ? detailRow('branch', `<code>${escapeHtml(branchName)}</code>`) : '',
@@ -1258,11 +1347,10 @@ function buildDetailMetaRows(fm, stateClass, stateName) {
         detailTimestampRow('created', createdAt),
         detailTimestampRow('updated', showUpdated),
         detailProposedByRow(asString(fm['proposed_by'])),
-        detailTimestampRow('proposed at', formatTimestamp(fm['proposed_at'])),
+        detailTimestampRow('proposed at', asTimestamp(fm['proposed_at'])),
     ].join('');
 }
-// Issue-detail CSS, hoisted out of renderIssueDetailPage so the function stays
-// within the imperative-shell line budget. Pure presentation content.
+// Issue-detail CSS, hoisted out of renderIssueDetailPage. Pure presentation.
 const DETAIL_PAGE_CSS = `
 :root {
   color-scheme: dark;
@@ -1349,6 +1437,24 @@ main {
   align-self: baseline; padding-top: 0.15rem;
 }
 .issue-meta dd { margin: 0; color: var(--base); }
+
+/* operator move control (issue 126): terminal issues are off the board, so the
+   detail page is where they stay reachable for a move. Mirrors the board's
+   .row-move select; an off-flow target is confirmed client-side before POST. */
+.detail-move { display: flex; align-items: center; gap: 0.6rem; margin: 0 0 1.4rem; }
+.detail-move-label {
+  color: var(--dim); font-size: 0.85em;
+  letter-spacing: 0.05em; text-transform: uppercase;
+}
+.detail-move .row-move {
+  background: transparent; color: var(--muted);
+  border: 1px solid var(--rule-firm); border-radius: 3px;
+  padding: 0.2rem 0.55rem; font: inherit; font-size: 0.85em; cursor: pointer;
+  transition: color 160ms cubic-bezier(.22,1,.36,1), border-color 160ms cubic-bezier(.22,1,.36,1);
+}
+.detail-move .row-move:hover { color: var(--strong); border-color: var(--muted); }
+.detail-move .row-move:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
+.detail-move .row-move:disabled { opacity: 0.6; cursor: default; }
 .label-chips { display: flex; flex-wrap: wrap; gap: 0.3rem; }
 .label-chip {
   display: inline-block; padding: 0.05rem 0.5rem; border-radius: 4px;
@@ -1407,15 +1513,61 @@ h2.section-title {
 }
 .empty { padding: 0.5rem 0; }
 `;
-function renderIssueDetailPage(issue, view) {
+// Operator move control on the issue-detail page (issue 126). The board's move
+// picker only renders on board ROWS, and terminal columns are deliberately kept
+// off the board (the glance view skips finished work) — so a terminal issue
+// (Done/Cancelled) has no board picker. The detail page is where terminal issues
+// stay reachable, so the move control lives here for them, closing the gap that
+// the operator couldn't move an issue OUT of a terminal state from the dashboard.
+//
+// Scoped to terminal states on purpose: a terminal issue is never mid-flight
+// (dispatch stops at terminal states), so this control needs no running-state
+// guard — whereas a non-terminal issue might be running, which is exactly why the
+// board picker (which has the running-state info to skip mid-flight rows) owns
+// those. The endpoint is the same generalized `/move`, so an off-flow target is
+// confirmed and `off_flow` echoed identically; a re-opened active target gets the
+// same immediate-pickup nudge approve did.
+function detailMoveControlHtml(identifier, stateName, states) {
+    const current = states.find((s) => s.name.toLowerCase() === stateName.toLowerCase());
+    if (!current || current.role !== 'terminal')
+        return '';
+    const options = moveTargetOptionsHtml(current, states);
+    if (!options)
+        return '';
+    const enc = encodeURIComponent(identifier);
+    return `<div class="detail-move">
+    <label class="detail-move-label" for="detail-move-select">move out of ${escapeHtml(current.name)}</label>
+    <select class="row-move" id="detail-move-select"
+            data-ident="${enc}" data-from="${escapeHtml(current.name)}"
+            aria-label="move ${escapeHtml(identifier)} to another state">
+      <option value="" selected disabled>move to…</option>
+      ${options}
+    </select>
+  </div>`;
+}
+// Issue-detail client script: binds the single move <select> (rendered for
+// terminal issues only) to the shared __symphonyMove, reloading on success so the
+// new state pill re-renders. Self-contained — the detail page does NOT load the
+// dashboard script (which wires the board + new-issue panel that don't exist here).
+const DETAIL_PAGE_SCRIPT = `
+${MOVE_SUBMIT_JS}
+(() => {
+  const sel = document.getElementById('detail-move-select');
+  if (sel instanceof HTMLSelectElement) {
+    sel.addEventListener('change', () => __symphonyMove(sel, () => location.reload()));
+  }
+})();
+`;
+export function renderIssueDetailPage(issue, view) {
     const fm = issue.frontMatter;
     const title = asString(fm['title']) ?? issue.identifier;
     const stateClass = pillClassForState(view.states, issue.state);
     const metaRows = buildDetailMetaRows(fm, stateClass, issue.state);
+    const moveControl = detailMoveControlHtml(issue.identifier, issue.state, view.states);
     const bodyHtml = issue.body.length > 0
         ? `<div class="issue-body">${renderMarkdown(issue.body)}</div>`
         : `<p class="empty dim">no description</p>`;
-    const workflowName = path.basename(view.workflowPath || 'workflow.md');
+    const workflowName = basename(view.workflowPath || 'workflow.yaml');
     return `<!doctype html>
 <html lang="en"><head>
 <meta charset="utf-8">
@@ -1441,436 +1593,18 @@ function renderIssueDetailPage(issue, view) {
   </section>
 
   <dl class="issue-meta">${metaRows}</dl>
+  ${moveControl}
 
   <h2 class="section-title">description</h2>
   ${bodyHtml}
 
   <p class="file-path" title="path on disk">${escapeHtml(issue.filePath)}</p>
 </main>
-
+${moveControl ? `\n<script>${DETAIL_PAGE_SCRIPT}</script>\n` : ''}
 </body></html>`;
 }
-// Resolves once the server has either bound the requested port or rejected with the bind
-// error so CLI startup can surface EADDRINUSE / EACCES instead of an unhandled rejection.
-// Returns the *actually bound* port (relevant for --port 0, where the kernel picks an
-// ephemeral port) so callers can advertise the live address.
-export async function startHttpServer(orch, opts) {
-    const server = createServer((req, res) => {
-        void handleRequest(req, res, orch, opts).catch((err) => {
-            log.error('http handler error', { error: err.message });
-            try {
-                jsonResponse(res, 500, {
-                    error: { code: 'internal_error', message: err.message },
-                });
-            }
-            catch {
-                /* response already started */
-            }
-        });
-    });
-    server.on('clientError', (err, socket) => {
-        log.debug('http client error', { error: err.message });
-        try {
-            socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
-        }
-        catch {
-            /* socket may already be closed */
-        }
-    });
-    let boundPort = opts.port;
-    await new Promise((resolve, reject) => {
-        const onError = (err) => {
-            server.removeListener('listening', onListening);
-            reject(err);
-        };
-        const onListening = () => {
-            server.removeListener('error', onError);
-            const addr = server.address();
-            const port = typeof addr === 'object' && addr ? addr.port : opts.port;
-            boundPort = port;
-            log.info('http server listening', { host: opts.host, port });
-            resolve();
-        };
-        server.once('error', onError);
-        server.once('listening', onListening);
-        server.listen(opts.port, opts.host);
-    });
-    // After bind succeeds, install a permanent error handler so later runtime errors
-    // (sockets resetting, ENOTCONN, etc.) are logged rather than crashing the process.
-    server.on('error', (err) => {
-        log.warn('http server error', { error: err.message });
-    });
-    return {
-        port: boundPort,
-        close: () => new Promise((resolve) => {
-            server.close(() => resolve());
-        }),
-    };
-}
-async function handleRequest(req, res, orch, opts) {
-    // URL parsing inside the handler so a malformed Host header doesn't crash the listener.
-    let pathname;
-    try {
-        pathname = new URL(req.url ?? '/', 'http://symphony.local').pathname;
-    }
-    catch {
-        return badRequest(res, 'invalid request URL');
-    }
-    const method = (req.method ?? 'GET').toUpperCase();
-    const view = opts.getTrackerView();
-    const route = matchRoute(pathname);
-    const handler = ROUTE_HANDLERS[route.kind];
-    await handler({ req, res, orch, opts, view, method, route });
-}
-async function handleDashboard(ctx) {
-    if (ctx.method !== 'GET')
-        return methodNotAllowed(ctx.res);
-    const p = await gatherPartialInputs(ctx.orch, ctx.view);
-    ctx.res.statusCode = 200;
-    ctx.res.setHeader('content-type', 'text/html; charset=utf-8');
-    ctx.res.end(renderDashboardHtml(p));
-}
-// Static preview for impeccable live mode. The file under .impeccable/preview/ is a
-// captured snapshot of the dashboard with polling disabled, used as a variant playground.
-// Read on every request so live-wrap edits land immediately.
-async function handlePreview(ctx) {
-    if (ctx.method !== 'GET')
-        return methodNotAllowed(ctx.res);
-    try {
-        const html = await readFile('.impeccable/preview/dashboard.html', 'utf8');
-        ctx.res.statusCode = 200;
-        ctx.res.setHeader('content-type', 'text/html; charset=utf-8');
-        ctx.res.setHeader('cache-control', 'no-store');
-        ctx.res.end(html);
-    }
-    catch (err) {
-        notFound(ctx.res, 'preview_missing', `preview not available: ${err.message}`);
-    }
-}
-// HTMX partials. Each region polls its own endpoint at 2s; this is what the dashboard
-// <section hx-get=...> elements consume. They return only the inner HTML; the outer
-// wrapper is in the dashboard shell.
-async function handlePartial(ctx) {
-    if (ctx.method !== 'GET')
-        return methodNotAllowed(ctx.res);
-    const name = resolvePartialName(ctx.route.slug);
-    if (!name) {
-        return notFound(ctx.res, 'partial_not_found', `partial ${ctx.route.slug} does not exist`);
-    }
-    const p = await gatherPartialInputs(ctx.orch, ctx.view);
-    const body = name === 'header' ? renderHeaderPartial(p)
-        : name === 'attention' ? renderAttentionPartial(p)
-            : name === 'board' ? renderBoardPartial(p)
-                : renderTotalsPartial(p);
-    ctx.res.statusCode = 200;
-    ctx.res.setHeader('content-type', 'text/html; charset=utf-8');
-    ctx.res.setHeader('cache-control', 'no-store');
-    ctx.res.end(body);
-}
-async function handleState(ctx) {
-    if (ctx.method !== 'GET')
-        return methodNotAllowed(ctx.res);
-    jsonResponse(ctx.res, 200, ctx.orch.snapshot());
-}
-async function handleRefresh(ctx) {
-    if (ctx.method !== 'POST')
-        return methodNotAllowed(ctx.res);
-    const status = ctx.orch.triggerRefresh();
-    jsonResponse(ctx.res, 202, {
-        ...status,
-        requested_at: new Date().toISOString(),
-        operations: ['poll', 'reconcile'],
-    });
-}
-async function handleIssues(ctx) {
-    if (ctx.method === 'GET')
-        return handleListIssues(ctx);
-    if (ctx.method === 'POST')
-        return handleCreateIssue(ctx);
-    methodNotAllowed(ctx.res);
-}
-async function handleListIssues(ctx) {
-    const root = ctx.view.trackerRoot;
-    if (!root)
-        return jsonResponse(ctx.res, 200, { issues: [] });
-    const issues = await listIssuesFromDisk(root);
-    jsonResponse(ctx.res, 200, { issues });
-}
-async function handleCreateIssue(ctx) {
-    const root = ctx.view.trackerRoot;
-    if (!root)
-        return badRequest(ctx.res, 'tracker.root not configured');
-    let body;
-    try {
-        body = await readJsonBody(ctx.req);
-    }
-    catch (err) {
-        return badRequest(ctx.res, err.message);
-    }
-    const decision = decideCreateIssue(body, ctx.view.states);
-    if (!decision.ok) {
-        return jsonResponse(ctx.res, decision.status, {
-            error: { code: decision.code, message: decision.message },
-        });
-    }
-    try {
-        const created = await writeIssueFile({
-            trackerRoot: root,
-            identifier: decision.identifier,
-            title: decision.title,
-            state: decision.state,
-            description: decision.description,
-            priority: decision.priority,
-            labels: decision.labels,
-            blocked_by: decision.blocked_by,
-        });
-        log.info('issue created via http', { identifier: created.identifier, state: created.state });
-        jsonResponse(ctx.res, 201, created);
-    }
-    catch (err) {
-        jsonResponse(ctx.res, 409, {
-            error: { code: 'create_failed', message: err.message },
-        });
-    }
-}
-// MCP JSON-RPC endpoint: agent (inside the smolvm) POSTs JSON-RPC envelopes here. The
-// URL is per-issue (the agent only knows its own /<id>/mcp), backed by a bearer token
-// generated at dispatch. Both layers are belt-and-braces against the no-auth 8787 socket.
-async function handleMcp(ctx) {
-    if (ctx.method !== 'POST')
-        return methodNotAllowed(ctx.res);
-    const mcp = ctx.opts.mcp;
-    if (!mcp)
-        return notFound(ctx.res, 'mcp_disabled', 'mcp endpoint not enabled');
-    const { identifier } = ctx.route;
-    const auth = (ctx.req.headers['authorization'] ?? ctx.req.headers['Authorization']);
-    const token = extractBearerToken(auth);
-    if (!token)
-        return jsonResponse(ctx.res, 401, { error: { code: 'unauthorized', message: 'bearer token required' } });
-    if (!mcp.isActive(identifier, token)) {
-        return jsonResponse(ctx.res, 404, {
-            error: { code: 'not_found', message: 'issue not active or token mismatch' },
-        });
-    }
-    let body;
-    try {
-        body = await readJsonBody(ctx.req);
-    }
-    catch (err) {
-        return badRequest(ctx.res, err.message);
-    }
-    const reply = await mcp.handleJsonRpc(identifier, token, body);
-    if (reply === null) {
-        // JSON-RPC notification (no id) → 204 No Content
-        ctx.res.statusCode = 204;
-        ctx.res.end();
-        return;
-    }
-    jsonResponse(ctx.res, 200, reply);
-}
-// Steering reply: the dashboard (or any operator with access) submits the human's
-// response to a queued request_human_steering call. The orchestrator-side runner is
-// awaiting on the registry; this POST unblocks it.
-//
-// Two callers:
-//  • Dashboard via HTMX (form-encoded body, `HX-Request: true`, same-origin). We accept
-//    only this combination for form bodies and reply with an HTML partial that swaps
-//    into #attention.
-//  • Direct API client (JSON body). Replies with a structured JSON acknowledgement.
-//
-// The form-encoded branch is gated on `HX-Request: true` and a same-origin check so a
-// simple cross-site form POST cannot inject a steering reply: form-encoded is a "simple"
-// CORS request that bypasses preflight, and the steering endpoint is unauthenticated.
-// HTMX errors land at 200 OK with an inline `.steering-error` message because HTMX's
-// default response-handling does not swap on 4xx/5xx; returning 200 keeps the operator's
-// form in sync with reality (their textarea text is preserved by hx-preserve regardless).
-async function handleSteeringReply(ctx) {
-    if (ctx.method !== 'POST')
-        return methodNotAllowed(ctx.res);
-    const mcp = ctx.opts.mcp;
-    if (!mcp)
-        return notFound(ctx.res, 'mcp_disabled', 'steering endpoint not enabled');
-    const { identifier } = ctx.route;
-    const isHtmx = ctx.req.headers['hx-request'] === 'true';
-    const ctype = classifyContentType(ctx.req.headers['content-type']);
-    const csrf = checkSteeringCsrf(ctype, isHtmx, isSameOriginRequest(ctx.req));
-    if (!csrf.ok) {
-        return jsonResponse(ctx.res, csrf.status, {
-            error: { code: csrf.code, message: csrf.message },
-        });
-    }
-    const text = await readSteeringText(ctx, ctype);
-    if (text === null)
-        return;
-    if (!text) {
-        return htmxOrJsonError(ctx.res, isHtmx, ctx.orch, ctx.view, 400, 'bad_request', 'text is required and must be a non-empty string');
-    }
-    if (!mcp.submitSteeringReply(identifier, text)) {
-        return htmxOrJsonError(ctx.res, isHtmx, ctx.orch, ctx.view, 409, 'no_pending_steering', 'no agent is awaiting steering for this issue');
-    }
-    await respondSteeringAccepted(ctx, isHtmx, identifier);
-}
-async function respondSteeringAccepted(ctx, isHtmx, identifier) {
-    if (isHtmx) {
-        const p = await gatherPartialInputs(ctx.orch, ctx.view);
-        ctx.res.statusCode = 200;
-        ctx.res.setHeader('content-type', 'text/html; charset=utf-8');
-        ctx.res.end(renderAttentionPartial(p));
-        return;
-    }
-    jsonResponse(ctx.res, 202, { identifier, accepted_at: new Date().toISOString() });
-}
-// Returns null when the body read errored and a response has already been written;
-// otherwise returns the extracted text (empty string if absent/blank, caller treats
-// that as the "no text supplied" case).
-async function readSteeringText(ctx, ctype) {
-    const isHtmx = ctx.req.headers['hx-request'] === 'true';
-    if (ctype.isFormBody) {
-        try {
-            return extractFormText(await readTextBody(ctx.req));
-        }
-        catch (err) {
-            await htmxOrJsonError(ctx.res, isHtmx, ctx.orch, ctx.view, 400, 'bad_request', err.message);
-            return null;
-        }
-    }
-    try {
-        return extractJsonText(await readJsonBody(ctx.req));
-    }
-    catch (err) {
-        badRequest(ctx.res, err.message);
-        return null;
-    }
-}
-// Triage approve / discard. The dashboard renders these as buttons inside the triage
-// section; an operator clicks one and we move the issue file out of Triage/. Approve
-// sends it to the first active state (typically Todo) where the orchestrator will pick
-// it up on the next poll; discard sends it to the first terminal state that looks like a
-// cancellation (case-insensitive "Cancelled" match preferred) so the proposal is
-// archived rather than deleted — operators can still grep for what was proposed and
-// turned down.
-//
-// CSRF posture mirrors the steering-reply endpoint: form-encoded requires HX-Request
-// + same-origin; JSON requires application/json (preflight-triggering). HTMX errors
-// come back as 200 with a partial so the section doesn't go stale.
-async function handleTriage(ctx) {
-    if (ctx.method !== 'POST')
-        return methodNotAllowed(ctx.res);
-    const tracker = ctx.opts.tracker;
-    if (!tracker || !tracker.moveIssueToState) {
-        return notFound(ctx.res, 'tracker_no_state_transitions', 'tracker does not support state transitions');
-    }
-    const root = ctx.view.trackerRoot;
-    if (!root)
-        return badRequest(ctx.res, 'tracker.root not configured');
-    const { identifier, action } = ctx.route;
-    const ctype = classifyContentType(ctx.req.headers['content-type']);
-    const csrf = checkTriageCsrf(ctype, ctx.req.headers['hx-request'] === 'true', isSameOriginRequest(ctx.req));
-    if (!csrf.ok) {
-        return jsonResponse(ctx.res, csrf.status, {
-            error: { code: csrf.code, message: csrf.message },
-        });
-    }
-    const transition = decideTriageTransition(action, ctx.view.states);
-    if (!transition.ok) {
-        return jsonResponse(ctx.res, transition.status, {
-            error: { code: transition.code, message: transition.message },
-        });
-    }
-    await runTriageMove(ctx, tracker, root, identifier, action, transition.toState, transition.fromState);
-}
-async function runTriageMove(ctx, tracker, root, identifier, action, toState, fromState) {
-    const isHtmx = ctx.req.headers['hx-request'] === 'true';
-    try {
-        const result = await tracker.moveIssueToState(identifier, toState, { fromRoot: root, fromState });
-        log.info('triage action', { identifier, action, from: result.fromState, to: result.toState });
-        // Nudge the orchestrator to pick the freshly approved issue up immediately instead
-        // of waiting for the next poll tick. Best-effort: triggerRefresh is idempotent.
-        if (action === 'approve') {
-            try {
-                ctx.orch.triggerRefresh();
-            }
-            catch { /* refresh request is fire-and-forget */ }
-        }
-        if (isHtmx)
-            return writeBoardPartial(ctx);
-        jsonResponse(ctx.res, 200, {
-            identifier, action, from_state: result.fromState, to_state: result.toState,
-        });
-    }
-    catch (err) {
-        const code = err.code ?? 'triage_failed';
-        const status = code === 'local_issue_not_found' ? 404 : 409;
-        if (isHtmx)
-            return writeBoardPartial(ctx);
-        jsonResponse(ctx.res, status, { error: { code, message: err.message } });
-    }
-}
-// Re-render the whole board after a triage move. HTMX morph keeps unchanged columns
-// stable; only the row that moved (or "failed" and stayed) redraws.
-async function writeBoardPartial(ctx) {
-    const p = await gatherPartialInputs(ctx.orch, ctx.view);
-    ctx.res.statusCode = 200;
-    ctx.res.setHeader('content-type', 'text/html; charset=utf-8');
-    ctx.res.setHeader('cache-control', 'no-store');
-    ctx.res.end(renderBoardPartial(p));
-}
-// Read-only HTML view of one issue. Linked from the identifier on every "on disk" and
-// triage row; renders front-matter (labels, priority, blockers, provenance) plus the
-// Markdown body so an operator can read the full task without leaving the browser. No
-// editing surface — actions stay on the dashboard. Source of truth is the on-disk .md
-// file, found by walking every state directory under tracker.root for a basename match.
-async function handleDetailHtml(ctx) {
-    if (ctx.method !== 'GET')
-        return methodNotAllowed(ctx.res);
-    const root = ctx.view.trackerRoot;
-    if (!root) {
-        ctx.res.statusCode = 404;
-        ctx.res.setHeader('content-type', 'text/html; charset=utf-8');
-        ctx.res.end(renderIssueNotFoundPage('(tracker root not configured)', ctx.view));
-        return;
-    }
-    const { identifier } = ctx.route;
-    const issue = await readIssueFromDisk(root, identifier);
-    if (!issue) {
-        ctx.res.statusCode = 404;
-        ctx.res.setHeader('content-type', 'text/html; charset=utf-8');
-        ctx.res.end(renderIssueNotFoundPage(identifier, ctx.view));
-        return;
-    }
-    ctx.res.statusCode = 200;
-    ctx.res.setHeader('content-type', 'text/html; charset=utf-8');
-    ctx.res.setHeader('cache-control', 'no-store');
-    ctx.res.end(renderIssueDetailPage(issue, ctx.view));
-}
-async function handleDetailJson(ctx) {
-    if (ctx.method !== 'GET')
-        return methodNotAllowed(ctx.res);
-    const { identifier } = ctx.route;
-    const detail = ctx.orch.detailByIdentifier(identifier);
-    if (!detail)
-        return notFound(ctx.res, 'issue_not_found', `issue ${identifier} is not tracked`);
-    jsonResponse(ctx.res, 200, detail);
-}
-async function handleNotFoundRoute(ctx) {
-    notFound(ctx.res);
-}
-const ROUTE_HANDLERS = {
-    dashboard: handleDashboard,
-    preview: handlePreview,
-    partial: handlePartial,
-    state: handleState,
-    refresh: handleRefresh,
-    issues: handleIssues,
-    mcp: handleMcp,
-    steering: handleSteeringReply,
-    triage: handleTriage,
-    detail_html: handleDetailHtml,
-    detail_json: handleDetailJson,
-    not_found: handleNotFoundRoute,
-};
-function renderIssueNotFoundPage(identifier, view) {
-    const workflowName = path.basename(view.workflowPath || 'workflow.md');
+export function renderIssueNotFoundPage(identifier, view) {
+    const workflowName = basename(view.workflowPath || 'workflow.yaml');
     return `<!doctype html>
 <html lang="en"><head>
 <meta charset="utf-8">
@@ -1898,4 +1632,4 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; co
 </main>
 </body></html>`;
 }
-//# sourceMappingURL=http.js.map
+//# sourceMappingURL=render.js.map