create-pmos 0.123.0 → 0.125.0

package/workspace/public/pm/new-initiative-sheet.js

@@ -1,19 +1,33 @@
 /* pm/new-initiative-sheet.js — the New-initiative form (pm-os-absorb Run 2, slice 2D; PRD R17, R25).
  *
  * Title, Lane, Anchor, Add. An initiative with no anchor is refused here, before any request, and again by the server.
+ * One line of intent can be drafted first (POST /api/intake/draft): it shows the lane guess with its confidence, the anchor
+ * suggestion (offered, never filled in: null reads 'no anchor yet') and any prior rejection. A refused draft blocks Add until the
+ * PM ticks the acknowledgement, which re-drafts with acknowledged:true. The stage shown at the start is Discover; it is derived.
  * The new initiative starts in Later: only the PM's press moves it into Now. The anchors on offer are the ones the List
  * already shows (a KR or a `health:<id>`), plus one typed by hand.
  *
  *   openNewInitiative({ repo, ws, anchors: string[], prefill?: { title, lane, from }, onAdded(id) })
  *   `prefill` is a triaged capture that still needs an anchor: the title and the lane are filled in, and `from` names the capture.
+ *
+ * R4b: the sheet body is the mockup's new-initiative intake (console3.html c3niLine and c3niCard, lines 4786 and 4787): the one-line
+ * add `.c3add > .form` (the input and the spark button), the suggestion as `section.card.sect` with `.sh2`, then `.case > .sit +
+ * .chgl` rows (the lane guess, the anchor, the prior rejection as `li.ok` or `li.warn` or `li.bad` with a `.tag`), and the
+ * fields as `.c3jf` label rows. The sheet itself is the real dialog (primitives sheet), and its Cancel and Add are the sheet's.
+ * Not lifted: the microphone (nothing transcribes), the "try" example pills (invented lines), the four-step progress list
+ * (the draft answers at once), the lane options with a slide (Add is a press, as before), the anchor pills (the anchor stays a
+ * select, since the page and its tests set it by value), and the phone bottom sheet. The anchors on offer are the List's.
  */
 
 import { el } from './dom.js';
-import { button, field, sheet, toast, ensureComponentsCss } from './primitives.js';
+import { button, sheet, toast, ensureComponentsCss } from './primitives.js';
 import { repoLanes, repoProfile } from './data.js';
 import { COPY } from './initiatives-copy.js';
 import { createInitiative } from './initiatives-api.js';
+import { pmPost } from './http.js';
 import { changed } from './initiative-sheet.js';
+import { ensureC3Css, c3ic, c3ib } from './pm-work-view.js';
+import { renderCase } from './c3-case.js';
 
 const OTHER = '__other__';
 
@@ -24,38 +38,114 @@ export function laneNames(repo) {
   return lanes.length ? lanes : null;
 }
 
+const row = (label, control) => el('label', null, el('span', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, label), control);
+
 export function openNewInitiative({ repo, ws, anchors, prefill, onAdded }) {
   ensureComponentsCss();
+  ensureC3Css();
   const anchorList = Array.from(new Set((anchors || []).filter(Boolean)));
-  const t = field({ label: COPY.newForm.titleLabel, kind: 'title', value: prefill && prefill.title, attrs: { 'data-in-new-title': '' } });
+  const t = el('input', { type: 'text', 'aria-label': COPY.newForm.titleLabel, 'data-in-new-title': '', autocomplete: 'off', value: (prefill && prefill.title) || '' });
   const lanes = laneNames(repo);
-  const l = lanes
-    ? field({ label: COPY.newForm.laneLabel, kind: 'select', value: prefill && lanes.includes(prefill.lane) ? prefill.lane : lanes[0], options: lanes.map((x) => ({ value: x, label: x })), attrs: { 'data-in-new-lane': '' } })
-    : field({ label: COPY.newForm.laneLabel, kind: 'text', value: prefill && prefill.lane, placeholder: COPY.newForm.laneHint, attrs: { 'data-in-new-lane': '' } });
-  const opts = [{ value: '', label: COPY.newForm.anchorPick }, ...anchorList.map((a) => ({ value: a, label: a })), { value: OTHER, label: COPY.newForm.anchorOther }];
-  const a = field({ label: COPY.newForm.anchorLabel, kind: 'select', value: '', options: opts, attrs: { 'data-in-new-anchor': '' } });
-  const typed = field({ label: COPY.newForm.anchorLabel, kind: 'text', placeholder: COPY.newForm.anchorHint, attrs: { 'data-in-new-anchor-text': '' } });
+  let l;
+  if (lanes) {
+    l = el('select', { 'aria-label': COPY.newForm.laneLabel, 'data-in-new-lane': '' }, lanes.map((x) => el('option', { value: x }, x)));
+    l.value = prefill && lanes.includes(prefill.lane) ? prefill.lane : lanes[0];
+  } else l = el('input', { type: 'text', 'aria-label': COPY.newForm.laneLabel, 'data-in-new-lane': '', placeholder: COPY.newForm.laneHint, value: (prefill && prefill.lane) || '' });
+  const a = el('select', { 'aria-label': COPY.newForm.anchorLabel, 'data-in-new-anchor': '' }, [{ value: '', label: COPY.newForm.anchorPick }, ...anchorList.map((x) => ({ value: x, label: x })), { value: OTHER, label: COPY.newForm.anchorOther }].map((o) => el('option', { value: o.value }, o.label)));
+  a.value = '';
+  const typed = el('input', { type: 'text', 'aria-label': COPY.newForm.anchorLabel, 'data-in-new-anchor-text': '', placeholder: COPY.newForm.anchorHint, autocomplete: 'off' });
   typed.hidden = true;
-  a.control.addEventListener('change', () => { typed.hidden = a.control.value !== OTHER; if (!typed.hidden) typed.control.focus(); });
-  const err = el('p', { class: 'in-error', role: 'alert', 'data-in-error': '' });
+  a.addEventListener('change', () => { typed.hidden = a.value !== OTHER; if (!typed.hidden) typed.focus(); });
+  // One-line intake draft (planning-flows run 4). It only suggests: the create below is unchanged and still needs a PM-chosen anchor.
+  const line = el('input', { type: 'text', id: 'c3nit', 'aria-label': 'Describe it in one line', 'data-in-new-line': '', placeholder: 'Start something new: one line is enough (e.g. Cut checkout drop-off, KR2)', autocomplete: 'off' });
+  const draftBtn = el('button', { type: 'button', class: 'ib pri', title: 'Draft: an agent runs the intake', 'aria-label': 'Draft: an agent runs the intake', 'data-in-draft-go': '' }, c3ic('spark'));
+  const draftOut = el('div', { 'data-in-draft': '' });
+  draftOut.hidden = true;
+  const startNote = el('div', { class: 'fold', 'data-in-start-stage': '' }, c3ic('init', 'sm'), 'Starts in stage: Discover.');
+  let refused = false;
+  let ack = false;
+  const ackInput = el('input', { type: 'checkbox', 'data-in-ack': '' });
+  const ackBox = el('label', { class: 'chips2' }, ackInput, el('span', { style: 'font-size:var(--fs-3)' }, 'I have read the prior rejection and still want to create this'));
+  ackBox.hidden = true;
+  ackInput.addEventListener('change', () => { ack = ackInput.checked; gate(); if (ack) runDraft(true); });
+  const gate = () => { add.disabled = busy || (refused && !ack); };
+  /* the intake as the mockup shows it (console3.html c3niCard, line 4787): four steps tick while the draft is made, then "The agent suggests" with the lane, the
+   * anchor and any prior rejection as a case file, options, and a slide to create. The draft is the real one (POST /api/intake/draft); the steps pace it. */
+  const STEPS = ['Checking what was rejected before', 'Running the sharpness test', 'Choosing a lane', 'Finding an anchor'];
+  let last = null;   // the last draft, so a change to the anchor or the lane redraws the case
+  const anchorNow = () => (a.value === OTHER ? typed.value : a.value).trim();
+  const stepsCard = (text, n) => el('section', { class: 'card sect', id: 'c3ni', 'data-in-draft-run': '' }, el('div', { class: 'sh2' }, el('h2', null, c3ic('spark', 'sm'), text)),
+    el('ul', { class: 'chgl' }, STEPS.map((st, i) => el('li', { class: i < n ? 'ok' : '' }, i < n ? c3ic('check', 'sm') : i === n ? el('span', { class: 'c3spin' }, c3ic('spark', 'sm')) : el('span', { style: 'width:14px' }), el('span', { class: i > n ? 'dim' : '' }, st)))));
+  const suggest = (d, acknowledged) => {
+    last = { d, acknowledged };
+    const pr = d.prior_rejections || []; const anc = anchorNow() || d.anchor_suggestion || '';
+    const blocked = !anchorNow() ? 'Pick an anchor below first: unanchored work is not created.' : refused && !ack ? 'A prior rejection is on record. Tick the acknowledgement first.' : '';
+    const lane = l.value || d.lane || 'feature'; const conf = typeof d.confidence === 'number' ? Math.round(d.confidence * 100) : 0;
+    const model = { id: 'ni:new', sit: 'The line reads as a ' + (d.lane || 'feature') + '. Nothing is created until you slide, and the anchor is yours to choose.', conf: conf || 60, cta: 'Slide to create', outboxReason: blocked,
+      chg: [['init', 'Lane guess: ' + (d.lane || 'none') + ' (confidence ' + (typeof d.confidence === 'number' ? d.confidence : 'unknown') + ')', 'Lane'], [d.anchor_suggestion ? 'target' : 'alert', d.anchor_suggestion ? 'Anchor suggestion: ' + d.anchor_suggestion : 'no anchor yet', 'Anchor', d.anchor_suggestion ? 'ok' : 'bad'],
+        [pr.length ? 'alert' : 'check', pr.length ? 'Prior rejections: ' + pr.map((r) => r.title || r.path || String(r)).join('; ') : 'Prior rejections: none', 'prior rejection', pr.length ? 'warn' : 'ok']],
+      opts: [{ id: 'mk', l: 'Create it as a ' + lane + ' initiative', rec: 1, outward: !!blocked, fx: [['check', 'Starts in Later; only your press moves it into Now', 'ok'], [anc ? 'target' : 'alert', anc ? 'Anchored to ' + anc : 'No anchor yet', anc ? 'ok' : 'warn']] },
+        ...(lane !== 'discovery' && (!conf || conf < 70) ? [{ id: 'ds', l: 'Start with discovery first', outward: !!blocked, fx: [['clock', 'A spike brief with a stop rule, no score', '']] }] : []), { id: 'no', l: 'Not now', fx: [] }],
+      unsure: conf && conf < 70 ? 'A keyword match is not a judgment.' : '' };
+    const c = renderCase(model, { onConfirm: async ({ option }) => {
+      if (option.id === 'no') { draftOut.hidden = true; return; }
+      if (option.id === 'ds' && l.tagName === 'SELECT') l.value = [...l.options].some((o) => o.value === 'discovery') ? 'discovery' : l.value;
+      add.click();
+    } });
+    ['lane', 'anchor', 'prior'].forEach((k, i) => { const li = c.querySelectorAll('.chgl li')[i]; if (li) li.setAttribute('data-in-draft-' + k, ''); });
+    const kids = [];
+    if (d.anchor_suggestion) kids.push(el('div', { class: 'chips2' }, el('button', { type: 'button', class: 'chip2 lk', 'data-in-use-anchor': '', onClick: () => {
+      if (anchorList.includes(d.anchor_suggestion)) a.value = d.anchor_suggestion;
+      else { a.value = OTHER; typed.hidden = false; typed.value = d.anchor_suggestion; }
+      suggest(d, acknowledged);
+    } }, c3ic('target', 'sm'), 'Use ' + d.anchor_suggestion)));
+    kids.push(c);
+    if (d.refused) kids.push(el('div', { class: 'fold w', role: 'alert', 'data-in-draft-refused': '' }, c3ic('alert', 'sm'), d.refused_reason || 'Refused: a prior rejection is on record.'));
+    draftOut.replaceChildren(el('section', { class: 'card sect', id: 'c3ni' }, el('div', { class: 'sh2' }, el('h2', null, c3ic('spark', 'sm'), 'The agent suggests'), el('span', { class: 'r' }, c3ib('Start over', 'x', { 'data-in-draft-reset': '', onClick: () => { draftOut.hidden = true; last = null; line.value = ''; line.focus(); } }, 'sm'))), ...kids));
+  };
+  async function runDraft(acknowledged) {
+    const text = line.value.trim();
+    if (!text) return;
+    draftOut.hidden = false;
+    let n = 0; if (!acknowledged) draftOut.replaceChildren(stepsCard(text, n));
+    const pace = acknowledged ? null : setInterval(() => { if (n < STEPS.length - 1) { n++; draftOut.replaceChildren(stepsCard(text, n)); } }, 260);
+    const started = Date.now();
+    const out = await pmPost('/api/intake/draft', { line: text, ...(acknowledged ? { acknowledged: true } : {}) });
+    if (!acknowledged) { const wait = Math.max(0, 260 * (STEPS.length - 1) + 160 - (Date.now() - started)); if (wait) await new Promise((r) => setTimeout(r, wait)); }
+    if (pace) clearInterval(pace);
+    if (!out || !out.ok || !out.draft) { draftOut.hidden = false; draftOut.replaceChildren(el('div', { class: 'fold w' }, c3ic('alert', 'sm'), (out && out.error) || 'The draft did not answer.')); return; }
+    const d = out.draft;
+    if (!t.value.trim() && d.title) t.value = d.title;
+    if (!prefill && lanes && lanes.includes(d.lane)) l.value = d.lane;
+    refused = !!d.refused && !acknowledged;
+    if (!acknowledged) { ack = false; ackInput.checked = false; }
+    suggest(d, acknowledged);
+    ackBox.hidden = !d.refused;
+    gate();
+  }
+  const redraw = () => { if (last && !draftOut.hidden) suggest(last.d, last.acknowledged); };
+  a.addEventListener('change', redraw); typed.addEventListener('input', redraw); l.addEventListener('change', redraw);
+  line.addEventListener('keydown', (e) => { if (e.key === 'Enter') { e.preventDefault(); runDraft(false); } });
+  draftBtn.addEventListener('click', () => runDraft(false));
+  const err = el('div', { class: 'fold w', role: 'alert', 'data-in-error': '' });
   err.hidden = true;
-  const lands = el('p', { class: 'in-note' }, COPY.newForm.lands);
+  const lands = el('div', { class: 'dim', style: 'font-size:var(--fs-2)' }, COPY.newForm.lands);
   const fail = (text) => { err.textContent = text; err.hidden = false; };
 
   let busy = false;
   const add = button({
     label: COPY.newForm.add, variant: 'primary', attrs: { 'data-in-new-add': '' },
     onClick: async () => {
-      if (busy) return;
+      if (busy || (refused && !ack)) return;
       err.hidden = true;
-      const title = t.control.value.trim();
-      const pick = a.control.value;
-      const anchor = (pick === OTHER ? typed.control.value : pick).trim();
-      if (!title) { fail(COPY.newForm.noTitle); t.control.focus(); return; }
+      const title = t.value.trim();
+      const pick = a.value;
+      const anchor = (pick === OTHER ? typed.value : pick).trim();
+      if (!title) { fail(COPY.newForm.noTitle); t.focus(); return; }
       if (!anchor) { fail(COPY.newForm.noAnchor); return; }
-      busy = true; add.disabled = true;
-      const out = await createInitiative(ws, { title, ...(l.control.value.trim() ? { lane: l.control.value.trim() } : {}), anchor, ...(prefill && prefill.from ? { from: prefill.from } : {}) });
-      busy = false; add.disabled = false;
+      busy = true; gate();
+      const out = await createInitiative(ws, { title, ...(l.value.trim() ? { lane: l.value.trim() } : {}), anchor, ...(prefill && prefill.from ? { from: prefill.from } : {}) });
+      busy = false; gate();
       if (out && out.ok) {
         const id = (out.initiative && out.initiative.id) || out.id || (out.ids && out.ids[0]) || null;
         s.close();
@@ -65,10 +155,15 @@ export function openNewInitiative({ repo, ws, anchors, prefill, onAdded }) {
       } else fail(COPY.refused((out && out.error) || 'The server did not answer.'));
     },
   });
+  const body = el('div', { class: 'c3 c3e' },
+    el('div', { class: 'c3add' }, el('div', { class: 'form' }, line, draftBtn)),
+    draftOut, ackBox,
+    el('div', { class: 'c3jf' }, row(COPY.newForm.titleLabel, t), row(COPY.newForm.laneLabel, l), row(COPY.newForm.anchorLabel, a), typed),
+    startNote, lands, err);
   const s = sheet({
-    mode: 'auto', title: COPY.newForm.title, body: [t, l, a, typed, lands, err], attrs: { 'data-in-sheet': 'new' },
+    mode: 'auto', title: COPY.newForm.title, body: [body], attrs: { 'data-in-sheet': 'new' },
     actions: [button({ label: COPY.cancel, variant: 'outline', onClick: () => s.close(), attrs: { 'data-in-cancel': '' } }), add],
   });
-  t.control.focus();
+  if (prefill && prefill.title && !prefill.lane && !prefill.from) { line.value = prefill.title; runDraft(false); } else t.focus();
   return s;
 }

package/workspace/public/pm/outbox-panel.js

@@ -0,0 +1,125 @@
+/* pm/outbox-panel.js — the outbox queue view (console3 wave B3), on the console3 mockup's own markup and CSS (R4b).
+ *
+ *   mountOutbox(host, ctx)   draws the queue from GET /api/outbox; ctx is optional: { get, post } (defaults to http.js)
+ *   disposeOutbox(host)      removes it and its slides
+ *
+ * The markup is the mockup's message queue (console3.html lines 4283 to 4284, r2queue 4338): `section.card.sect > .sh2` with the
+ * count in `.bdg.g`, `ul.list > li.nrow` with `.ki`, `.nb > .tt + .chips + .xp > .xi`, and the case file `.case > .sit + .qd
+ * + .chgl + .slt`. Each entry shows its channel, recipient, an editable body (editing voids the hash, and the panel says so),
+ * the claim check result as `.chgl` rows, a slide bound to the CURRENT hash and, after a slide, the plain result. No channel
+ * is connected in this wave, so a slide ends in "no channel connected" and the entry stays queued. Nothing is sent.
+ * Not lifted: the mockup's swipe on a message row (right = send, left = hold): a send here is only the slide; the mockup's
+ * three states (draft, held, sent) and its "external, you approve" chip, which the entry does not carry. */
+import { el } from './dom.js';
+import { pmGet, pmPost } from './http.js';
+import { mountSlide, disposeSlide } from './slide-confirm.js';
+import { ensureC3Css, c3ic } from './pm-work-view.js';
+
+const live = new WeakMap();   // host → { slideHosts: [], gone }
+
+export function disposeOutbox(host) {
+  const s = live.get(host);
+  if (!s) return;
+  s.gone = true;
+  s.slideHosts.forEach(disposeSlide);
+  live.delete(host);
+  host.textContent = '';
+}
+
+export async function mountOutbox(host, ctx = {}) {
+  disposeOutbox(host);
+  ensureC3Css();
+  const get = ctx.get || pmGet, post = ctx.post || pmPost;
+  const st = { slideHosts: [], gone: false };
+  live.set(host, st);
+  const results = {};   // id → plain result text, kept across redraws
+  const voided = {};    // id → true after an edit, until the next press
+  const open = {};      // id → false when the PM folded the row
+
+  async function draw() {
+    const r = await get('/api/outbox');
+    if (st.gone) return;
+    st.slideHosts.forEach(disposeSlide);
+    st.slideHosts = [];
+    const root = el('div', { class: 'c3 c3e', 'data-outbox': '' });
+    if (!r || r.ok === false) {
+      root.append(el('div', { class: 'fold w', role: 'alert' }, c3ic('alert', 'sm'), (r && r.error) || 'Could not read the outbox.'));
+    } else {
+      const entries = r.entries || [];
+      root.append(el('section', { class: 'card sect' },
+        el('div', { class: 'sh2' }, el('h2', null, c3ic('out', 'sm'), 'Outbox ', el('span', { class: 'bdg g' }, String(entries.length))),
+          el('span', { class: 'dim', style: 'font-size:var(--fs-2)' }, 'Nothing here is sent. No channel is connected.')),
+        el('ul', { class: 'list' }, entries.length ? entries.map((e) => row(e)) : el('li', { class: 'fold' }, c3ic('check', 'sm'), 'The outbox is empty.'))));
+    }
+    host.replaceChildren(root);
+  }
+
+  function row(e) {
+    const op = open[e.id] !== false;
+    const li = el('li', { class: 'nrow', 'data-row': '', 'data-outbox-entry': e.id, tabindex: '0', 'aria-expanded': String(op) });
+    const xp = el('div', { class: 'xp' + (op ? ' open' : '') });
+    const toggle = () => { open[e.id] = !(open[e.id] !== false); li.setAttribute('aria-expanded', String(open[e.id])); xp.classList.toggle('open', open[e.id]); };
+    li.addEventListener('click', (ev) => { if (ev.target.closest('.xi')) return; toggle(); });
+    li.addEventListener('keydown', (ev) => { if (ev.target === li && (ev.key === 'Enter' || ev.key === ' ')) { ev.preventDefault(); toggle(); } });
+    const claimTone = e.claims.ok ? 'ok' : 'bad';
+    xp.append(el('div', { class: 'xi' }, theCase(e)));
+    li.append(
+      el('span', { class: 'ki' }, c3ic('out')),
+      el('div', { class: 'nb' },
+        el('span', { class: 'tt' }, e.recipient || e.channel),
+        el('div', { class: 'chips' },
+          el('span', { class: 'chip2' }, e.state),
+          el('span', { class: 'chip2' }, c3ic('user', 'sm'), e.recipient || 'no recipient'),
+          el('span', { class: 'tag' }, e.channel),
+          el('span', { class: 'tag' }, e.origin),
+          el('span', { class: 'st ' + claimTone }, c3ic(e.claims.ok ? 'check' : 'alert', 'sm'), e.claims.ok ? 'claims labelled' : 'blocked')),
+        xp));
+    return li;
+  }
+
+  function theCase(e) {
+    const ta = el('textarea', { 'aria-label': 'Body of the entry for ' + (e.recipient || e.channel), style: 'width:100%;min-height:84px;box-sizing:border-box' });
+    ta.value = e.body;
+    const save = el('button', { type: 'button', class: 'pill', disabled: true }, c3ic('check', 'sm'), 'Save edit');
+    const hashLine = el('span', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, 'hash ' + e.hash.slice(0, 10));
+    const slideHost = el('div');
+    ta.addEventListener('input', () => {
+      const changed = ta.value !== e.body;
+      save.disabled = !changed;
+      hashLine.textContent = changed ? 'Editing voids hash ' + e.hash.slice(0, 10) + '. Save, then slide on the new hash.' : 'hash ' + e.hash.slice(0, 10);
+      slideHost.style.display = changed ? 'none' : '';
+    });
+    save.addEventListener('click', async () => {
+      const r = await post('/api/outbox/edit', { id: e.id, body: ta.value });
+      if (r && r.ok) { voided[e.id] = true; delete results[e.id]; await draw(); } else hashLine.textContent = (r && r.error) || 'The edit failed.';
+    });
+    const chg = el('ul', { class: 'chgl' });
+    if (!e.claims.ok) {
+      chg.append(el('li', { class: 'bad' }, c3ic('alert', 'sm'), el('span', null, 'Blocked: these claim lines have no label ([fact], [estimate], [assumption], [reported] or a ticket key).'), el('span', { class: 'tag' }, 'claims check')));
+      for (const l of e.claims.refused) chg.append(el('li', { class: 'bad' }, c3ic('x', 'sm'), el('span', { class: 'mono' }, l)));
+    } else chg.append(el('li', { class: 'ok' }, c3ic('check', 'sm'), el('span', null, 'Claim check passed.'), el('span', { class: 'tag' }, 'claims check')));
+    const c = el('div', { class: 'case', 'data-case': e.id, style: '--tc:var(--acc)' },
+      el('p', { class: 'sit' }, results[e.id] || e.last_result || 'Nothing has been sent. The slide below sends exactly this text, bound to its hash.'),
+      ta,
+      el('div', { class: 'chips2' }, save, hashLine),
+      voided[e.id] ? el('div', { class: 'fold w' }, c3ic('alert', 'sm'), 'The old hash is void. The slide below is bound to the new content.') : null,
+      chg,
+      slideHost);
+    if (e.claims.ok) {
+      st.slideHosts.push(slideHost);
+      mountSlide(slideHost, {
+        label: 'Slide to confirm', hash: e.hash,
+        onConfirm: async (hash) => {
+          const r = await post('/api/outbox/confirm', { id: e.id, hash });
+          const text = !r ? 'No answer.' : r.ok ? 'Confirmed.' : (r.reason || r.error || 'Refused.');
+          results[e.id] = text;
+          delete voided[e.id];
+          await draw();
+        },
+      });
+    } else slideHost.appendChild(el('div', { class: 'cft' }, el('span', null, c3ic('lock', 'sm'), 'The slide is held until every claim line has a label.')));
+    return c;
+  }
+
+  await draw();
+}