@giamme/forge 0.11.0 → 0.12.0

package/ui/forge_ui/static/runmodel.js

@@ -287,7 +287,9 @@
     return {
       integration: { status: integrationStatus(tasks.map(t => t.status)),
         merged, total: tasks.length, base: ig && ig.base || null, accepted: ig && ig.accepted || null },
-      verification: { status: v && v.status ? String(v.status).toUpperCase() : 'PENDING', command: v && v.command || null, runs: list(v && v.runs).length },
+      verification: { status: v && v.state === 'running' ? 'RUNNING' : v && v.status ? String(v.status).toUpperCase() : 'PENDING',
+        command: v && v.command || null, runs: list(v && v.runs).length, mode: v && v.mode === 'lanes' && list(v.lanes).length ? 'lanes' : 'single',
+        lanes: list(v && v.lanes).map(l => ({ name: l.name, state: l.state })), reruns: list(v && v.runs).filter(r => r.kind !== 'initial').length },
       final: { status: !frObj ? (run.settings && run.settings.final_qa ? 'PENDING' : 'NONE') : finalStatus(frObj),
         requested: !!(fr || run.settings && run.settings.final_qa), spec: frObj && frObj.spec || run.settings && run.settings.final_qa || null, findings: frObj && frObj.findings || null,
         count: list(run.final_reviews).length,
@@ -475,20 +477,68 @@
     }
     return items;
   }
+  // A verification run's status: exit 0 passed, any other exit failed, no exit is RUNNING while it runs and UNKNOWN after.
+  const runStatus = (exit, running) => exit === 0 ? 'PASS' : num(exit) !== null ? 'FAIL' : running ? 'RUNNING' : 'UNKNOWN';
+  const LANE_STATUS = { flaky: 'FLAKY', known: 'KNOWN' };
+  // The finish rows' verification items, each with its `row`: in lanes mode a row per lane of the newest verification,
+  // one item per run of it (the newest verification's earlier executions stay boxes on a VERIFY row); in single mode
+  // the newest verification split into its runs, back to back from its start (`approx`: the execution also covers
+  // discovery and fingerprinting, and a run's duration its fingerprint), else one box per execution.
+  function verifyItems(run, now) {
+    const v = run && run.verification, execs = list(run && run.timeline && run.timeline.verifications).filter(e => num(e.started) !== null);
+    const newest = execs.reduce((a, e) => !a || e.started >= a.started ? e : a, null);
+    const lanes = v && v.mode === 'lanes' ? list(v.lanes).filter(l => l && l.name) : [];
+    const out = [];
+    for (const e of execs) {
+      if (e === newest && lanes.length) continue;
+      const runs = e === newest ? list(v && v.runs) : [];
+      const running = e.state === 'running';
+      if (!runs.length) {
+        out.push({ id: e.id, kind: 'verification', row: 'verification', start: e.started, end: execEnd(e, now) || e.started,
+          status: running ? 'RUNNING' : e.exit_code === 0 ? 'PASS' : e.exit_code == null ? 'UNKNOWN' : 'FAIL', segs: [] });
+        continue;
+      }
+      let t = e.started;
+      runs.forEach((r, i) => {
+        const d = Math.max(0, num(r.duration_s) || 0), rerun = r.kind !== 'initial';
+        out.push({ id: `vrun:${e.id}:${r.n ?? i + 1}`, kind: 'verification', row: 'verification', exec: e.id, approx: true, rerun,
+          start: t, end: t + d, status: runStatus(num(r.exit), false), segs: [],
+          title: `verify · run ${r.n ?? i + 1}${rerun ? ' (' + String(r.kind).replace('_', ' ') + ')' : ''} · approximate placement` });
+        t += d;
+      });
+      // runs.tsv gains a row when a run ends: a verification still going is in a run that is not listed yet
+      if (running && num(now) !== null && now > t) out.push({ id: `vrun:${e.id}:now`, kind: 'verification', row: 'verification', exec: e.id, approx: true,
+        start: t, end: now, status: 'RUNNING', segs: [], title: 'verify · the current run · approximate placement' });
+    }
+    for (const l of lanes) {
+      const runs = list(l.runs);
+      runs.forEach((r, i) => {
+        const s = num(r.started); if (s === null) return;
+        const last = i === runs.length - 1, running = last && l.state === 'running' && num(r.ended) === null;
+        const end = num(r.ended) ?? (running && num(now) !== null ? Math.max(s, now) : s);
+        const status = last && LANE_STATUS[l.state] ? LANE_STATUS[l.state] : runStatus(num(r.exit), running);
+        const k = num(r.k) ?? i + 1, rerun = r.kind === 'rerun';
+        const notes = [l.group ? 'group ' + l.group : null, l.first ? 'runs first' : null].filter(Boolean);
+        out.push({ id: `vlane:${l.name}:${k}`, kind: 'verification', row: 'vlane:' + l.name, vlane: l.name, k, rerun, exec: newest ? newest.id : null,
+          start: s, end, running, status, segs: [], title: `verify · ${l.name} · ${rerun ? 'rerun ' + (k - 1) : 'run ' + k}${notes.length ? ' · ' + notes.join(' · ') : ''}` });
+      });
+    }
+    return { items: out, lanes: lanes.map(l => l.name) };
+  }
   // scale: {t0, t1} of a previous model, kept while every block still fits inside it, so a live run does not
   // change the time axis (and so every block) on each poll
   function execModel(run, { now = null, ghosts = true, maxParallel = null, scale = null } = {}) {
     const items = execItems(run, now);
     const cap = Math.max(1, num(maxParallel) || num(run && run.settings && run.settings.max_parallel) || 3);
-    const live = items.some(i => i.running) || list(run && run.tasks).some(t => t.status === 'RUNNING');
+    const live = items.some(i => i.running) || list(run && run.tasks).some(t => t.status === 'RUNNING')
+      || !!(run && run.verification && run.verification.state === 'running');
     const proj = ghosts && run && run.kind !== 'solo' ? projectSchedule(run, { now: now !== null ? now : undefined, maxParallel: cap }) : {};
     for (const [id, p] of Object.entries(proj)) if (p.ghost && p.start !== null) items.push({ id: 'ghost:' + id, task: id, ghost: true, start: p.start, end: p.end, status: 'PENDING', segs: [] });
-    const extra = [];
-    for (const v of list(run && run.timeline && run.timeline.verifications)) if (num(v.started) !== null) extra.push({ id: v.id, kind: 'verification', start: v.started, end: execEnd(v, now) || v.started, status: v.state === 'running' ? 'RUNNING' : v.exit_code === 0 ? 'PASS' : v.exit_code == null ? 'UNKNOWN' : 'FAIL', segs: [] });
+    const verify = verifyItems(run, now), extra = verify.items;
     for (const r of list(run && run.final_reviews)) {
       const s = num(r.started) ?? num(r.at); if (s === null) continue;
       const e = num(r.ended) ?? (r.state === 'running' && num(now) !== null ? now : s + 1);
-      extra.push({ id: 'review:' + r.name, kind: 'review', review: r.name, start: s, end: Math.max(s, e), status: r.state === 'running' ? 'RUNNING' : r.verdict || 'UNKNOWN', findings: r.findings || null, segs: [] });
+      extra.push({ id: 'review:' + r.name, kind: 'review', row: 'review', review: r.name, start: s, end: Math.max(s, e), status: r.state === 'running' ? 'RUNNING' : r.verdict || 'UNKNOWN', findings: r.findings || null, segs: [] });
     }
     const all = items.concat(extra);
     if (!all.length) return { items: [], extra: [], lanes: 0, cap, overLimit: false, t0: null, t1: null, k: 1, px: 900, py: 300, ruler: [], live, nowX: null };
@@ -515,13 +565,15 @@
     const x = t => EXEC_PAD + (t - t0) * k;
     for (const it of items) { it.x = x(it.start); it.w = Math.max(22, (it.end - it.start) * k); it.y = RULER + it.lane * LANE_D + (LANE_D - BLOCK_D) / 2; it.d = BLOCK_D; }
     const fy = RULER + lanes * LANE_D + 24;
-    const finishLanes = [['verification', 'VERIFY'], ['review', 'FINAL REVIEW']].filter(([k]) => extra.some(e => e.kind === k));
-    finishLanes.forEach(([kind], i) => extra.filter(e => e.kind === kind).forEach(e => { e.lane = 'f' + i; e.x = x(e.start); e.w = Math.max(22, (e.end - e.start) * k); e.y = fy + i * LANE_D + (LANE_D - BLOCK_D) / 2; e.d = BLOCK_D; }));
+    // finish rows: VERIFY (single-command verifications), a row per verification lane, FINAL REVIEW
+    const finishLanes = [['verification', 'verification', 'VERIFY', 'verify'], ...verify.lanes.map(n => ['vlane:' + n, 'verification', 'VERIFY · ' + n, 'verify · ' + n]),
+      ['review', 'review', 'FINAL REVIEW', 'final review']].filter(([row]) => extra.some(e => e.row === row));
+    finishLanes.forEach(([row], i) => extra.filter(e => e.row === row).forEach(e => { e.lane = 'f' + i; e.x = x(e.start); e.w = Math.max(22, (e.end - e.start) * k); e.y = fy + i * LANE_D + (LANE_D - BLOCK_D) / 2; e.d = BLOCK_D; }));
     const steps = [60, 300, 600, 900, 1800, 3600, 7200, 14400, 43200, 86400];
     const step = steps.find(s => span / s <= 10) || 86400;
     const ruler = [];
     for (let t = Math.ceil(t0 / step) * step; t <= t0 + span; t += step) ruler.push({ t, x: x(t), label: fmtDur(t - t0) });
-    return { items, extra, lanes, finishLanes: finishLanes.map(([k, name], i) => ({ kind: k, name, y: fy + i * LANE_D })), cap, overLimit: lanes > cap, t0, t1: t0 + span, k,
+    return { items, extra, lanes, finishLanes: finishLanes.map(([row, kind, name, label], i) => ({ kind, row, name, label, y: fy + i * LANE_D })), cap, overLimit: lanes > cap, t0, t1: t0 + span, k,
       px: EXEC_PAD * 2 + W, py: fy + finishLanes.length * LANE_D + 10, laneD: LANE_D, ruler, live, nowX: num(now) !== null && live ? x(now) : null, x };
   }
 
@@ -602,8 +654,36 @@
     const final = finalAt(run, last, t);
     const vs = list(run && run.timeline && run.timeline.verifications).filter(v => num(v.started) !== null && v.started <= t);
     const lv = vs.pop();
-    const verification = !lv ? 'PENDING' : num(lv.ended) !== null && lv.ended <= t ? (lv.exit_code === 0 ? 'PASS' : 'FAIL') : 'RUNNING';
-    return { t, tasks, final, verification, integration: integrationStatus(Object.values(tasks).map(s => s.status)) };
+    const verification = !lv ? 'PENDING' : num(lv.ended) !== null && lv.ended <= t ? runStatus(num(lv.exit_code), false) : 'RUNNING';
+    return { t, tasks, final, verification, lanes: lanesAt(run, t), integration: integrationStatus(Object.values(tasks).map(s => s.status)) };
+  }
+  // The finish node's verification LEDs: one per lane coloured by its state (at the replay time when `at` is
+  // stateAt's), else one per run of the command by its exit; a run with no exit is UNKNOWN, never FAIL.
+  const LED_STATE = { pass: 'PASS', fail: 'FAIL', running: 'RUNNING', flaky: 'FLAKY', known: 'KNOWN', interrupted: 'INTERRUPTED' };
+  function verifyLeds(run, at) {
+    const v = run && run.verification;
+    if (v && v.mode === 'lanes' && list(v.lanes).length) {
+      if (at && at.lanes) return at.lanes.map(l => l.status === 'PENDING' ? null : l.status);
+      return list(v.lanes).filter(l => l && l.name).map(l => LED_STATE[l.state] || null);
+    }
+    return list(v && v.runs).map(r => runStatus(num(r.exit), false));
+  }
+  // Each verification lane at time t (lanes mode, else null): PENDING before its first run, RUNNING during a run,
+  // between runs and after the last the status of the run that ended last, a flaky or known lane's own at its end.
+  function lanesAt(run, t) {
+    const v = run && run.verification;
+    if (!v || v.mode !== 'lanes' || !list(v.lanes).length) return null;
+    return list(v.lanes).filter(l => l && l.name).map(l => {
+      let status = 'PENDING';
+      const runs = list(l.runs);
+      runs.forEach((r, i) => {
+        const s = num(r.started), e = num(r.ended), last = i === runs.length - 1;
+        if (s === null || s > t) return;
+        if (e === null || e > t) { status = 'RUNNING'; return; }
+        status = last && LANE_STATUS[l.state] ? LANE_STATUS[l.state] : runStatus(num(r.exit), false);
+      });
+      return { name: l.name, status };
+    });
   }
   function timeRange(run, now) {
     const s = [], e = [];
@@ -618,6 +698,7 @@
     for (const m of list(run && run.integration && run.integration.merged)) if (num(m && m.at) !== null) e.push(m.at);
     for (const r of list(run && run.final_reviews)) { const v = num(r.started) ?? num(r.at); if (v !== null) s.push(v); if (num(r.ended) !== null) e.push(r.ended); }
     for (const v of list(run && run.timeline && run.timeline.verifications)) { if (num(v.started) !== null) s.push(v.started); if (num(v.ended) !== null) e.push(v.ended); }
+    for (const l of list(run && run.verification && run.verification.lanes)) for (const r of list(l && l.runs)) if (num(r && r.ended) !== null) e.push(r.ended);
     if (!s.length) return null;
     return { start: Math.min(...s), end: Math.max(...e, ...s) };
   }
@@ -777,6 +858,6 @@
 
   return { liveNow, runState, execStatus, matchRun, filterOptions, atlasModel, columns, planModel, finishState,
     finalStatus, runReviewStatus, reviewSinceLine, reviewAt, taskStatus, taskVerdict, attemptStatus, taskParts,
-    taskTimes, metricValue, overlap, projectSchedule, execModel, criticalPath, concurrency, stateAt, timeRange, events, lineage, structureKey, innerKey,
+    taskTimes, metricValue, overlap, projectSchedule, execModel, verifyLeds, criticalPath, concurrency, stateAt, timeRange, events, lineage, structureKey, innerKey,
     fmtDur, alias, basename, weight, searchIndex, searchRank, statusEvents, fractalTree };
 });

package/ui/forge_ui/static/scene3d.js

@@ -289,7 +289,11 @@ export async function createStage(host, cb = {}) {
   function finishInfo(id) {
     const F = st.plan && st.plan.finish, run = st.run; if (!F) return {};
     if (id === 'f:integration') return { title: 'INTEGRATION', sub: `${F.integration.merged}/${F.integration.total} merged`, status: F.integration.status, line: F.integration.accepted ? 'at ' + String(F.integration.accepted).slice(0, 10) : 'into forge/' + (run.run_id || '…') + '-integration' };
-    if (id === 'f:verification') return { title: 'VERIFICATION', sub: F.verification.command || 'no command recorded', status: F.verification.status, line: F.verification.runs ? `${F.verification.runs} run${F.verification.runs > 1 ? 's' : ''}` : 'not run yet' };
+    if (id === 'f:verification') {
+      const V = F.verification, n = V.lanes.length, plural = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`;
+      const line = V.mode === 'lanes' ? `${plural(n, 'lane')} · ${plural(V.reruns, 'rerun')}` : V.runs ? plural(V.runs, 'run') : 'not run yet';
+      return { title: 'VERIFICATION', sub: V.command || (V.mode === 'lanes' ? V.lanes.map(l => l.name).join(' · ') : 'no command recorded'), status: V.status, line };
+    }
     const status = finishStatus(id, { status: F.final.status });
     const src = status === 'OUTDATED' && st.replay !== null ? (RM.reviewAt(run, st.replay) || F.final) : F.final;
     const f = F.final.findings;
@@ -313,7 +317,7 @@ export async function createStage(host, cb = {}) {
     }, 'cover', { x: x + 12, y: y + 8, z: h });
     if (m.id === 'f:final') { leds(el, 4, x + 18, y + d - 13, h + .16, { step: 11, s: 3 }); }
     else if (m.id === 'f:integration') leds(el, Math.min(40, list(st.run.tasks).length), x + 17, y + d - 13, h + .16, { step: 8, s: 2.4, perRow: 22 });
-    else leds(el, Math.max(1, Math.min(12, list(st.run.verification && st.run.verification.runs).length)), x + 17, y + d - 13, h + .16, { step: 9, s: 2.8 });
+    else leds(el, Math.max(1, Math.min(12, RM.verifyLeds(st.run).length)), x + 17, y + d - 13, h + .16, { step: 9, s: 2.8 });
     finishLeds(el);
     display(el, e => finishInfo(e.id).line || '', { w: w - 24, x: x + 12, y: y + d, z: h - 8 });
     halo(el);
@@ -326,7 +330,7 @@ export async function createStage(host, cb = {}) {
   function finishLeds(el) {
     if (el.id === 'f:final') { const f = finishInfo(el.id).findings || {}; setLeds(el, ['P0', 'P1', 'P2', 'P3'].map(s => f[s] ? E.sevColor(s) : null)); }
     else if (el.id === 'f:integration') setLeds(el, list(st.run.tasks).map(t => { const s = taskStatus(t); return s === 'MERGED' || s === 'ACCEPTED' ? s : null; }));
-    else setLeds(el, list(st.run.verification && st.run.verification.runs).map(r => r.exit === 0 ? 'PASS' : 'FAIL'));
+    else setLeds(el, RM.verifyLeds(st.run, st.replay !== null ? st.replayState : null));
   }
   function buildPlan(g) {
     const P = RM.planModel(st.run); st.plan = P;
@@ -512,7 +516,7 @@ export async function createStage(host, cb = {}) {
     const lw = Math.max(10, it.w - 10);
     el.roof = label(el, lw, it.d - 14, 4, (cx, s, C, e) => {
       const item = e.data.item, sel = e.cur.sel > .5;
-      const title = item.kind === 'verification' ? 'verification' : item.kind === 'review' ? 'final review' : item.task + (item.attempt ? ' · A' + item.attempt : '');
+      const title = item.vlane ? 'verify · ' + item.vlane : item.kind === 'verification' ? 'verification' : item.kind === 'review' ? 'final review' : item.task + (item.attempt ? ' · A' + item.attempt : '');
       const f = Math.min(11, Math.max(4, (lw - 4) / Math.max(4, title.length * E.CW)));
       E.font(cx, f, s, 600); cx.fillStyle = sel ? C.accHi : item.ghost ? C.ink : C.inkHi; cx.fillText(E.ellipsis(title, Math.floor((lw - 2) / (f * E.CW))), 1 * s, (f + 1) * s);
       // segments: when the dwarf and the review ran inside this attempt
@@ -1135,7 +1139,7 @@ export async function createStage(host, cb = {}) {
     if (el.kind === 'finish') return { kind: el.id === 'f:final' ? 'final' : el.id === 'f:verification' ? 'verification' : 'integration' };
     const it = el.data.item; if (!it) return null;
     if (it.kind === 'review') return { kind: 'final', name: it.review };
-    if (it.kind === 'verification') return { kind: 'execution', task: null, exec: it.id };
+    if (it.kind === 'verification') return it.vlane || it.approx ? { kind: 'verification' } : { kind: 'execution', task: null, exec: it.id };
     if (it.ghost || String(it.id).startsWith('span:')) return { kind: 'task', id: it.task };
     return { kind: 'execution', task: it.task, id: it.task, exec: it.id };
   }

package/ui/forge_ui/static/settings.js

@@ -85,13 +85,25 @@
     return { editor: { base: fresh, draft: e.draft }, dirty: true, moved: norm(fresh) !== norm(e.base) };
   }
   const edited = (editor, draft) => ({ base: editor.base, draft: text(draft) });
+  // The editor after typing in a textarea drawn from the file text `from`. When a read moved `base` on since the textarea
+  // was drawn (a held body is not redrawn), the typing sits on the old text, so the save would overwrite the new file.
+  function typed(editor, draft, from) {
+    const e = edited(editor, draft), dirty = isDirty(e);
+    return { editor: e, dirty, moved: dirty && norm(from) !== norm(e.base) };
+  }
   const shown = editor => editor.draft !== null ? editor.draft : editor.base;
+  // What a failed GET /api/config does: with a good read of this run on the page, it stays and a note names the
+  // failure; with none yet, the message replaces the page. Status 0 is no answer at all.
+  function readFailure(res, hasData) {
+    const message = (res && res.status !== 0 && (res.detail || res.error)) || 'could not reach forge-ui';
+    return { keep: !!hasData, message };
+  }
 
   /* ---------- DOM ---------- */
   function render(host, ctx) {
     const UI = root.ForgeUI, c = ctx || {};
     const el = (tag, t, cls) => UI.el(tag, t, cls);
-    const s = { run: null, data: null, dataText: null, error: null, writes: false, loading: true, editors: {}, moved: {}, hold: 0, redraw: false, seq: 0, gen: 0, runsSig: null, ready: false, loadedAt: 0, repo: null, gone: false };
+    const s = { run: null, data: null, dataText: null, error: null, writes: false, loading: true, editors: {}, moved: {}, hold: 0, redraw: false, seq: 0, gen: 0, runsSig: null, ready: false, loadedAt: 0, repo: null, gone: false, asking: 0, asks: 0, pickerLate: false };
     const key_ = (label, cls, onclick) => { const b = el('button', label, cls); b.type = 'button'; if (onclick) b.addEventListener('click', onclick); return b; };
 
     const head = el('header', undefined, 'set-head');
@@ -101,10 +113,17 @@
     const body = el('div', undefined, 'set-body');
     const note = el('p', 'This page is read-only: this server has no write token, or has controls off.', 'muted set-readonly');
     note.hidden = true;
-    host.replaceChildren(head, picker, note, body);
+    // A failed read over a good one: the page stays, and this says the shown values may be old. Outside the body, so a
+    // held body (an open confirm) still gets it.
+    const stale = el('p', undefined, 'warn set-problem set-stale'); stale.setAttribute('role', 'status');
+    stale.hidden = true;
+    host.replaceChildren(head, picker, note, stale, body);
+    const staleNote = msg => { stale.hidden = !msg; stale.textContent = msg ? `The last read of the configuration failed: ${msg}. This shows the read before it; the next refresh tries again.` : ''; };
 
     /* the repository picker */
     function drawPicker() {
+      // The switch confirm lives in the picker: while it is open the rebuild waits, and runs when it is answered.
+      if (s.asking) { s.pickerLate = true; return; }
       const runs = c.runs ? c.runs() : [];
       const groups = groupRuns(runs);
       const before = s.run, usable = withRepo(runs);
@@ -138,7 +157,14 @@
       }
       sel.addEventListener('change', async () => {
         const unsaved = FILES.filter(n => s.editors[n] && isDirty(s.editors[n]));
-        if (unsaved.length && !(await UI.confirmInline(picker, `Switch repository and discard the unsaved edits to ${unsaved.map(n => '.forge/' + n).join(', ')}?`, { danger: true }))) { sel.value = s.gone ? '' : s.run; return; }
+        if (unsaved.length) {
+          const ask = s.asking = ++s.asks;
+          const yes = await UI.confirmInline(picker, `Switch repository and discard the unsaved edits to ${unsaved.map(n => '.forge/' + n).join(', ')}?`, { danger: true });
+          if (s.asking !== ask) return;                           // a later change asked again, and that confirm decides
+          const late = s.pickerLate;
+          s.asking = 0; s.pickerLate = false;
+          if (!yes) { sel.value = s.gone ? '' : s.run; if (late) drawPicker(); return; }
+        }
         pick(sel.value);
       });
       const lab = el('label', undefined, 'set-field'); lab.htmlFor = 'set-run';
@@ -151,11 +177,13 @@
     }
     // A new run: nothing of the old one stays, and confirms of the old body (now detached) no longer hold a redraw.
     function resetRun() {
+      staleNote(null);
       s.data = null; s.dataText = null; s.error = null; s.editors = {}; s.moved = {}; s.loading = s.run != null;
       s.gen++; s.hold = 0; s.redraw = false;
     }
     function pick(key) {
       s.run = key; resetRun();
+      s.asking = 0; s.pickerLate = false;                         // a switch confirm still open goes with the old picker
       s.runsSig = null; drawPicker(); drawBody();
       if (c.onPick) c.onPick(key);
       load();
@@ -171,12 +199,12 @@
       if (seq !== s.seq || run !== s.run) return;                 // a later pick or load answered
       s.loading = false;
       if (!res.ok) {
-        const msg = res.status === 0 ? null : res.detail || res.error;
-        if (msg === null && s.data) return;                       // a poll that did not reach the server keeps the last good page
+        const failed = readFailure(res, s.data);
+        if (failed.keep) { staleNote(failed.message); return; }   // the last good page, its editors and their unsaved text stay
         if (s.hold > 0) return;                                   // a confirm or a write is open: its strip must not be torn down
-        s.error = msg || 'could not reach forge-ui'; s.data = null; s.dataText = null; drawBody(); return;
+        s.error = failed.message; s.data = null; s.dataText = null; drawBody(); return;
       }
-      s.error = null;
+      s.error = null; staleNote(null);
       const files = object(object(res.data.repo).files);
       for (const name of FILES) {
         const next = dirtyState(s.editors[name], object(files[name]).content);
@@ -305,7 +333,9 @@
       const top = el('div', undefined, 'set-file-head'); top.append(h, status);
       art.append(top, el('p', blurb, 'muted set-file-blurb'));
       if (file.note) art.append(el('p', text(file.note), 'warn set-file-note'));
-      if (isDirty(ed) && s.moved[name]) art.append(el('p', 'The file changed on disk after you began editing; saving replaces it with your text.', 'warn set-file-note'));
+      const movedNote = el('p', 'The file changed on disk after you began editing; saving replaces it with your text.', 'warn set-file-note');
+      movedNote.hidden = !(isDirty(ed) && s.moved[name]);              // sync() keeps it current as the text is typed
+      art.append(movedNote);
       if (!s.writes) {
         status.replaceChildren(el('i', undefined, 'lamp ' + (file.exists ? 'st-pass' : '')), el('span', file.exists ? (unreadable ? 'present, not shown' : 'present') : 'absent'));
         art.append(unreadable ? el('p', file.exists ? 'The content is not shown.' : 'Not set.', 'muted') : el('pre', text(file.content), 'set-pre'));
@@ -316,6 +346,7 @@
       ta.dataset.editor = name; ta.rows = Math.max(3, Math.min(14, shown(ed).split('\n').length + 1));
       ta.spellcheck = false; ta.setAttribute('autocapitalize', 'off'); ta.setAttribute('autocomplete', 'off');
       ta.value = shown(ed);
+      let from = ed.base;                                         // the file text this textarea was drawn from
       if (unreadable && file.exists) { ta.disabled = true; ta.placeholder = 'The content is not shown, so it cannot be edited here.'; }
       const problem = el('p', undefined, 'warn set-problem'); problem.hidden = true; problem.id = id + '-problem';
       const result = el('div', undefined, 'set-result');
@@ -328,10 +359,15 @@
         if (bad) { ta.setAttribute('aria-invalid', 'true'); ta.setAttribute('aria-describedby', problem.id); }
         else { ta.removeAttribute('aria-invalid'); ta.removeAttribute('aria-describedby'); }
         save.disabled = !dirtyNow || !!bad;
+        movedNote.hidden = !(dirtyNow && s.moved[name]);
         status.replaceChildren(el('i', undefined, 'lamp ' + (dirtyNow ? 'set-amber' : file.exists ? 'st-pass' : '')),
           el('span', dirtyNow ? 'unsaved edits' : file.exists ? (unreadable ? 'present, not shown' : 'present') : 'absent'));
       };
-      ta.addEventListener('input', () => { s.editors[name] = edited(s.editors[name], ta.value); sync(); });
+      ta.addEventListener('input', () => {
+        const next = typed(s.editors[name], ta.value, from);
+        s.editors[name] = next.editor; s.moved[name] = next.moved || (next.dirty && !!s.moved[name]);
+        sync();
+      });
       remove.disabled = !file.exists;
       save.addEventListener('click', async () => {
         const cur = s.editors[name], bad = valueProblem(name, cur.draft);
@@ -342,7 +378,7 @@
         if (!yes) { ta.readOnly = false; remove.disabled = !file.exists; release(); sync(); save.focus({ preventScroll: true }); return; }
         const res = await UI.post('/api/config', configBody(s.run, repoKey(name), cur.draft));
         UI.outcome(result, res, `Saved ${target}.`);
-        if (res.ok && gen === s.gen) s.editors[name] = editorOf(cur.draft.endsWith('\n') ? cur.draft : cur.draft + '\n');
+        if (res.ok && gen === s.gen) { s.editors[name] = editorOf(cur.draft.endsWith('\n') ? cur.draft : cur.draft + '\n'); s.moved[name] = false; from = s.editors[name].base; }
         ta.readOnly = false; remove.disabled = !file.exists; release(); sync();
         if (res.ok && gen === s.gen) await reload();
       });
@@ -353,7 +389,7 @@
         if (!yes) { ta.readOnly = false; release(); sync(); remove.disabled = !file.exists; remove.focus({ preventScroll: true }); return; }
         const res = await UI.post('/api/config', configBody(s.run, repoKey(name), null, true));
         UI.outcome(result, res, `Removed ${target}.`);
-        if (res.ok && gen === s.gen) s.editors[name] = editorOf('');
+        if (res.ok && gen === s.gen) { s.editors[name] = editorOf(''); s.moved[name] = false; from = ''; }
         ta.readOnly = false; release();
         if (res.ok && gen === s.gen) await reload(); else if (!res.ok) { remove.disabled = !file.exists; sync(); }
       });
@@ -395,5 +431,5 @@
   }
 
   return { render, configBody, repoKey, targetPath, subsetOk, valueProblem, pickDefault, groupRuns, optionLabel,
-    editorOf, isDirty, dirtyState, edited, shown, FILES, VALUE_MAX };
+    editorOf, isDirty, dirtyState, edited, typed, shown, readFailure, FILES, VALUE_MAX };
 });

package/ui/forge_ui/static/style.css

@@ -99,6 +99,9 @@
 .st-fail, .st-error, .st-conflict, .st-infra, .st-timeout, .st-blocked { --st: var(--lamp-red); --st-lit: var(--lit-red); }
 [class^="st-"], [class*=" st-"] { --st-fill: var(--st); --st-ring: var(--lamp-edge); }
 .st-accepted, .st-nochanges, .st-interrupted, .st-infra, .st-timeout, .st-blocked, .st-outdated { --st-fill: transparent; --st-ring: var(--st); }
+/* verification lanes: flaky passed on a rerun (amber, hollow), known passed with only baseline failures (green, hollow) */
+.st-flaky { --st: var(--lamp-amber); --st-lit: var(--lit-amber); --st-fill: transparent; --st-ring: var(--st); }
+.st-known { --st: var(--lamp-green); --st-lit: var(--lit-green); --st-fill: transparent; --st-ring: var(--st); }
 /* review severity is a shape (P0 spike, P1 diamond, P2 cone, P3 pin) on a ramp of its own, never a status lamp */
 .sev-P0 { --sev: var(--sev-p0); --sev-shape: polygon(50% 0, 100% 100%, 0 100%); }
 .sev-P1 { --sev: var(--sev-p1); --sev-shape: polygon(50% 0, 100% 50%, 50% 100%, 0 50%); }
@@ -563,6 +566,51 @@ summary:hover { color: var(--ink-2); }
 ul.plain { list-style: none; padding: 0; margin: 4px 0; display: grid; gap: 4px; font-size: var(--t-sm); }
 ul.plain li.current { font-weight: 650; }
 pre.cmd { max-height: none; }
+/* the verification inspector (verifyview.js): live state, failing tests, lanes and their logs */
+.vfy-num { font-variant-numeric: tabular-nums; }
+.vfy-live { margin: var(--s-3) 0 0; padding: var(--s-3); border-radius: var(--r-key); background: var(--module-2); box-shadow: inset 0 0 0 1px var(--rule); }
+.vfy-now { margin: 0; font-size: var(--t-sm); }
+.vfy-step { font-weight: 600; }
+.vfy-last { margin: var(--s-2) 0 0; font-size: var(--t-xs); color: var(--ink-2); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.vfy-idle { margin: var(--s-2) 0 0; padding: 2px var(--s-2); border-radius: var(--r-small); background: var(--warn-wash); font-size: var(--t-xs); width: fit-content; }
+.vfy-group { margin: var(--s-3) 0 0; }
+.vfy-group-head { display: flex; gap: var(--s-2); align-items: baseline; margin: 0 0 var(--s-1); font-size: var(--t-sm); }
+.vfy-tests { gap: var(--s-2); }
+.vfy-test { padding: var(--s-2) var(--s-3); border-radius: var(--r-key); background: var(--module-2); box-shadow: inset 3px 0 0 var(--lamp-red); }
+.vfy-test.vfy-known { box-shadow: inset 3px 0 0 var(--lamp-off); }
+.vfy-test-head { display: flex; flex-wrap: wrap; gap: var(--s-2); align-items: baseline; }
+.vfy-test-name { overflow-wrap: anywhere; font-size: var(--t-xs); }
+.vfy-badge { padding: 0 6px; border-radius: var(--r-small); font-size: var(--t-xs); font-weight: 650; text-transform: uppercase; letter-spacing: .04em; }
+.vfy-badge-new { background: var(--lamp-red); color: var(--plate-ink); }
+.vfy-badge-known { box-shadow: inset 0 0 0 1px var(--rule-2); color: var(--muted); }
+.vfy-message { margin: var(--s-1) 0 0; font-size: var(--t-sm); overflow-wrap: anywhere; }
+.vfy-excerpt summary { cursor: pointer; font-size: var(--t-xs); color: var(--muted); }
+/* a link-like button: none of the key's plate type, face or press */
+.vfy-link { display: inline; min-height: 0; padding: 0; border: 0; background: none; box-shadow: none; color: var(--ink); text-decoration: underline; text-underline-offset: 2px;
+  font-family: var(--font-ui); font-weight: 400; font-size: var(--t-xs); letter-spacing: normal; text-transform: none; line-height: inherit; white-space: normal; text-align: left; }
+.vfy-link.mono { font-family: var(--mono); }
+.vfy-link:hover:not(:disabled) { background: none; color: var(--ink-2); }
+.vfy-section-head { display: flex; align-items: center; justify-content: space-between; gap: var(--s-2); margin: 0 0 var(--s-2); }
+.vfy-section-head h3 { margin: 0; }
+.vfy-nowrap { white-space: nowrap; }
+.vfy-table-wrap { overflow-x: auto; }
+.vfy-table { width: 100%; border-collapse: collapse; font-size: var(--t-sm); }
+.vfy-table th { text-align: left; font-weight: 600; color: var(--muted); font-size: var(--t-xs); padding: 0 var(--s-2) var(--s-1) 0; }
+.vfy-table td { padding: var(--s-1) var(--s-2) var(--s-1) 0; border-top: 1px solid var(--rule); vertical-align: top; }
+.vfy-table tr.vfy-followed td { background: var(--module-2); }
+.vfy-lane .vfy-link { font-size: var(--t-sm); }
+.vfy-label { margin-left: var(--s-1); font-size: var(--t-xs); }
+.vfy-lane-now { display: grid; gap: 2px; margin-top: 2px; max-width: 28ch; }
+.vfy-lane-now .vfy-last { margin: 0; }
+.vfy-log { display: grid; padding: var(--s-2) 0; font-family: var(--mono); font-size: var(--t-xs); line-height: 1.5; white-space: pre; overflow: auto; }
+.vfy-line { display: flex; gap: var(--s-3); padding: 0 var(--s-3); }
+.vfy-line.vfy-hl { background: var(--warn-wash); color: var(--warn-ink); }
+.vfy-ln { flex: none; min-width: 5ch; text-align: right; color: var(--glass-dim); font-variant-numeric: tabular-nums; user-select: none; }
+.vfy-line.vfy-hl .vfy-ln { color: inherit; }
+.vfy-lt { white-space: pre-wrap; overflow-wrap: anywhere; }
+.vfy-note { font-size: var(--t-xs); margin: var(--s-1) 0 0; }
+.vfy-summary, .vfy-endstep, .vfy-mutated { margin: var(--s-3) 0 0; font-size: var(--t-sm); }
+.vfy-lanes + .fields, .vfy-tail + .fields { margin-top: var(--s-4); }
 .phase-bar { display: flex; height: 8px; border-radius: 4px; overflow: hidden; margin: 6px 0; background: var(--module-2); }
 .phase { min-width: 2px; }
 .phase-legend { display: flex; flex-wrap: wrap; gap: 4px 12px; font-size: var(--t-xs); color: var(--muted); }
@@ -624,6 +672,17 @@ p.ctl-why::before { content: ''; width: 7px; height: 7px; border-radius: 50%; ba
 .ctl-pin-now { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 8px; }
 p.ctl-stop { display: flex; align-items: center; gap: 7px; margin: 0; padding: 4px var(--s-2); border-radius: var(--r-small); background: var(--warn-wash); color: var(--warn-ink); font-weight: 600; }
 .ctl-log { margin-top: var(--s-1); }
+/* the run's keys (drain, resume, stop), its drained or stopping state, pauses and a queued retry's answer */
+.ctl-keys { display: flex; flex-wrap: wrap; gap: var(--s-2); }
+.ctl-state { font-variant-numeric: tabular-nums; }
+.ctl-stopping, .ctl-drained { background: var(--warn-wash); color: var(--warn-ink); border-color: transparent; }
+.ctl-pauses { display: grid; gap: var(--s-1); }
+.ctl-pause-list { list-style: none; margin: 0; padding: 0; display: grid; gap: 4px; font-size: var(--t-xs); }
+.ctl-pause { display: flex; align-items: baseline; gap: 7px; }
+.ctl-pause-text { font-variant-numeric: tabular-nums; overflow-wrap: anywhere; }
+.ctl-exhausted .ctl-pause-text { color: var(--warn-ink); font-weight: 600; }
+p.ctl-request { display: flex; align-items: center; gap: 7px; margin: 0; font-size: var(--t-sm); }
+p.ctl-request-refused { color: var(--warn-ink); font-weight: 600; }
 .ctl-changes { list-style: none; margin: 4px 0 0; padding: 0; display: grid; gap: 4px; font-size: var(--t-xs); }
 .ctl-changes li { display: flex; flex-wrap: wrap; align-items: baseline; gap: 2px 8px; }
 .ctl-what { color: var(--ink); font-weight: 600; }
@@ -702,6 +761,7 @@ th:hover .th-sort, .th-sort.on { color: var(--ink); }
 .gt-item.gt-sel .gt-box { stroke: var(--route); stroke-width: 2.5; }
 .gt-item.gt-crit .gt-box { stroke-width: 2.4; }
 .gt-ghost .gt-box { fill-opacity: .04; stroke-dasharray: 4 3; }
+.gt-item.gt-approx .gt-box { stroke-dasharray: 2 2; }   /* a verification run placed from durations, not from its own times */
 .gt-future { opacity: .3; }
 .gt-seg { fill: var(--st, var(--lamp-off)); }
 .gt-seg.gt-dwarf { fill-opacity: .55; }