@azure-id/orc 2.0.2 → 2.1.1

package/bin/webui/js/06-edit.js

@@ -1,183 +1,193 @@
-"use strict";
-/* 06-edit.js — orc ui client
-   editSet, editBar, applyEdits — the staged-write machinery Settings AND Flow
-   both use. Nothing is written until Apply; the CLI is still the only writer and
-   the only validator.
-
-   Loaded by app.html in the order its numeric prefix names. Classic
-   script, no import/export: an ES module import carries no query string,
-   and every static request here needs the per-launch session token. */
-
-
-/* ============================================================ staged edits == */
-//
-// WRITES ARE BATCHED (v0.44.1). Every control used to commit on the spot: one
-// click, one `orc config set`, one full re-render of the panel. Changing four
-// keys meant four subprocesses and four re-renders, and each one scrolled the
-// list out from under you — so a routine "set these five things" was a fight.
-//
-// Nothing is written until Apply now. Edits accumulate here, the affected rows
-// mark themselves, and an edit bar at the bottom says how many are pending.
-// The CLI is still the only writer and still the only validator; what changed
-// is WHEN it is called, never by whom.
-//
-// An entry is `{kind: "set", value}` or `{kind: "reset"}` — a per-key reset is
-// `orc config reset <key>` (it REMOVES the key from the file), which is not the
-// same write as setting it to its default value, so it cannot be flattened into
-// one.
-function editSet(onChange) {
-  const map = new Map();
-  const api = {
-    map,
-    get size() {
-      return map.size;
-    },
-    // Staging a value back to what it already was CLEARS the edit rather than
-    // recording a no-op — otherwise "cancel" and "set it back by hand" would
-    // leave the bar claiming an unsaved change that would write nothing.
-    set(key, value, original) {
-      if (String(value) === String(original)) map.delete(key);
-      else map.set(key, { kind: "set", value: String(value), original: String(original) });
-      onChange(api);
-    },
-    reset(key) {
-      map.set(key, { kind: "reset" });
-      onChange(api);
-    },
-    // An ACTION entry (v0.49.2): a route and a body, staged like any other
-    // edit, applied by `applyActions`. `label` is what the pending list names —
-    // a count is not a change list.
-    action(key, route, body, label) {
-      map.set(key, { kind: "action", route, body, value: label });
-      onChange(api);
-    },
-    drop(key) {
-      map.delete(key);
-      onChange(api);
-    },
-    clear() {
-      map.clear();
-      onChange(api);
-    },
-    entries() {
-      return [...map.entries()];
-    },
-  };
-  return api;
-}
-
-// The bar. Apply is disabled with nothing pending; Reset is always offered
-// (it is a write in its own right, not an undo); **Cancel appears only when
-// there is something to cancel** — a permanently visible Cancel next to a
-// disabled Apply reads as though the panel is broken.
-function editBar(edits, { onApply, onReset, onCancel, resetLabel }) {
-  const bar = el("div", "edit-bar");
-  const summary = el("div", "edit-summary");
-  const actions = el("div", "edit-actions");
-
-  const apply = el("button", "btn btn-sm btn-primary", t("edits.apply"));
-  apply.type = "button";
-  apply.addEventListener("click", () => onApply(apply));
-
-  const reset = el("button", "btn btn-sm btn-ghost", resetLabel || t("edits.reset"));
-  reset.type = "button";
-  reset.addEventListener("click", onReset);
-
-  const cancel = el("button", "btn btn-sm btn-ghost", t("edits.cancel"));
-  cancel.type = "button";
-  cancel.addEventListener("click", onCancel);
-
-  bar.paint = () => {
-    const n = edits.size;
-    bar.classList.toggle("edit-bar-dirty", n > 0);
-    apply.disabled = n === 0;
-    apply.textContent = n ? t("edits.applyN", { n }) : t("edits.apply");
-    // The pending list is named, never counted: "3 changes" is not consent for
-    // three writes you can no longer see.
-    summary.replaceChildren();
-    if (!n) {
-      summary.append(el("span", "note", t("edits.none")));
-    } else {
-      summary.append(el("span", "note", t("edits.pending")));
-      const list = el("div", "edit-list");
-      for (const [key, e] of edits.entries()) {
-        const item = el("span", "edit-chip");
-        // Key names and values are CLI data — never translated.
-        item.append(el("span", "edit-key", key));
-        item.append(document.createTextNode(e.kind === "reset" ? " → " + t("edits.toDefault") : " → " + e.value));
-        list.append(item);
-      }
-      summary.append(list);
-    }
-    actions.replaceChildren();
-    actions.append(apply, reset);
-    if (n) actions.append(cancel);
-  };
-
-  bar.append(summary, actions);
-  bar.paint();
-  return bar;
-}
-
-// Apply runs the staged writes ONE AT A TIME, in the order they were staged —
-// the same sequence a terminal user would type, which matters because settings
-// can shadow each other. A failure does not abort the rest: the remaining
-// writes are independent, and stopping halfway would leave a state nobody
-// chose. Every failure is reported by key.
-async function applyEdits(edits, routes, button) {
-  const list = edits.entries();
-  if (!list.length) return { ok: true, failed: [] };
-  const label = button && button.textContent;
-  if (button) {
-    button.disabled = true;
-    button.textContent = t("edits.applying");
-  }
-  const failed = [];
-  for (const [key, e] of list) {
-    try {
-      const r = e.kind === "reset" ? await post(routes.reset, { key }) : await post(routes.set, { key, value: e.value });
-      if (!r.ok) failed.push(`${key}: ${(r.output || r.command || "").trim().split("\n")[0]}`);
-    } catch (err) {
-      failed.push(`${key}: ${err.message}`);
-    }
-  }
-  if (button) {
-    button.disabled = false;
-    if (label) button.textContent = label;
-  }
-  if (failed.length) toast(t("edits.someFailed", { n: failed.length }), "bad", failed.join("\n"));
-  else toast(t("edits.applied", { n: list.length }), "ok");
-  return { ok: !failed.length, failed };
-}
-
-// The same batching, for a panel whose edits are not key/value pairs (v0.49.2).
-// The house-rule ledger stages ADDs, REMOVEs, TOGGLEs and MOVEs — four routes,
-// four body shapes — so the entry carries its own `route` and `body` and this
-// runs them one at a time in staged order. Every other rule of `applyEdits`
-// holds exactly: a refused write NEVER aborts the rest, and every failure is
-// reported by the key it was staged under.
-async function applyActions(edits, button) {
-  const list = edits.entries();
-  if (!list.length) return { ok: true, failed: [] };
-  const label = button && button.textContent;
-  if (button) {
-    button.disabled = true;
-    button.textContent = t("edits.applying");
-  }
-  const failed = [];
-  for (const [key, e] of list) {
-    try {
-      const r = await post(e.route, e.body);
-      if (!r.ok) failed.push(`${key}: ${(r.output || r.command || "").trim().split("\n")[0]}`);
-    } catch (err) {
-      failed.push(`${key}: ${err.message}`);
-    }
-  }
-  if (button) {
-    button.disabled = false;
-    if (label) button.textContent = label;
-  }
-  if (failed.length) toast(t("edits.someFailed", { n: failed.length }), "bad", failed.join("\n"));
-  else toast(t("edits.applied", { n: list.length }), "ok");
-  return { ok: !failed.length, failed };
-}
+"use strict";
+/* 06-edit.js — orc ui client
+   editSet, editBar, applyEdits — the staged-write machinery Settings AND Flow
+   both use. Nothing is written until Apply; the CLI is still the only writer and
+   the only validator.
+
+   Loaded by app.html in the order its numeric prefix names. Classic
+   script, no import/export: an ES module import carries no query string,
+   and every static request here needs the per-launch session token. */
+
+
+/* ============================================================ staged edits == */
+//
+// WRITES ARE BATCHED (v0.44.1). Every control used to commit on the spot: one
+// click, one `orc config set`, one full re-render of the panel. Changing four
+// keys meant four subprocesses and four re-renders, and each one scrolled the
+// list out from under you — so a routine "set these five things" was a fight.
+//
+// Nothing is written until Apply now. Edits accumulate here, the affected rows
+// mark themselves, and an edit bar at the bottom says how many are pending.
+// The CLI is still the only writer and still the only validator; what changed
+// is WHEN it is called, never by whom.
+//
+// An entry is `{kind: "set", value}` or `{kind: "reset"}` — a per-key reset is
+// `orc config reset <key>` (it REMOVES the key from the file), which is not the
+// same write as setting it to its default value, so it cannot be flattened into
+// one.
+function editSet(onChange) {
+  const map = new Map();
+  const api = {
+    map,
+    get size() {
+      return map.size;
+    },
+    // Staging a value back to what it already was CLEARS the edit rather than
+    // recording a no-op — otherwise "cancel" and "set it back by hand" would
+    // leave the bar claiming an unsaved change that would write nothing.
+    set(key, value, original) {
+      if (String(value) === String(original)) map.delete(key);
+      else map.set(key, { kind: "set", value: String(value), original: String(original) });
+      onChange(api);
+    },
+    reset(key) {
+      map.set(key, { kind: "reset" });
+      onChange(api);
+    },
+    // An ACTION entry (v0.49.2): a route and a body, staged like any other
+    // edit, applied by `applyActions`. `label` is what the pending list names —
+    // a count is not a change list.
+    action(key, route, body, label) {
+      map.set(key, { kind: "action", route, body, value: label });
+      onChange(api);
+    },
+    drop(key) {
+      map.delete(key);
+      onChange(api);
+    },
+    clear() {
+      map.clear();
+      onChange(api);
+    },
+    entries() {
+      return [...map.entries()];
+    },
+  };
+  return api;
+}
+
+// The bar. Apply is disabled with nothing pending; Reset is always offered
+// (it is a write in its own right, not an undo); **Cancel appears only when
+// there is something to cancel** — a permanently visible Cancel next to a
+// disabled Apply reads as though the panel is broken.
+function editBar(edits, { onApply, onReset, onCancel, resetLabel }) {
+  const bar = el("div", "edit-bar");
+  const summary = el("div", "edit-summary");
+  const actions = el("div", "edit-actions");
+
+  const apply = el("button", "btn btn-sm btn-primary", t("edits.apply"));
+  apply.type = "button";
+  apply.addEventListener("click", () => onApply(apply));
+
+  const reset = el("button", "btn btn-sm btn-ghost", resetLabel || t("edits.reset"));
+  reset.type = "button";
+  reset.addEventListener("click", onReset);
+
+  const cancel = el("button", "btn btn-sm btn-ghost", t("edits.cancel"));
+  cancel.type = "button";
+  cancel.addEventListener("click", onCancel);
+
+  bar.paint = () => {
+    const n = edits.size;
+    bar.classList.toggle("edit-bar-dirty", n > 0);
+    apply.disabled = n === 0;
+    apply.textContent = n ? t("edits.applyN", { n }) : t("edits.apply");
+    // The pending list is named, never counted: "3 changes" is not consent for
+    // three writes you can no longer see.
+    summary.replaceChildren();
+    if (!n) {
+      summary.append(el("span", "note", t("edits.none")));
+    } else {
+      summary.append(el("span", "note", t("edits.pending")));
+      const list = el("div", "edit-list");
+      for (const [key, e] of edits.entries()) {
+        const item = el("span", "edit-chip");
+        // Key names and values are CLI data — never translated.
+        item.append(el("span", "edit-key", key));
+        item.append(document.createTextNode(e.kind === "reset" ? " → " + t("edits.toDefault") : " → " + e.value));
+        list.append(item);
+      }
+      summary.append(list);
+    }
+    actions.replaceChildren();
+    actions.append(apply, reset);
+    if (n) actions.append(cancel);
+  };
+
+  bar.append(summary, actions);
+  bar.paint();
+  return bar;
+}
+
+// Apply runs the staged writes ONE AT A TIME, in the order they were staged —
+// the same sequence a terminal user would type, which matters because settings
+// can shadow each other. A failure does not abort the rest: the remaining
+// writes are independent, and stopping halfway would leave a state nobody
+// chose. Every failure is reported by key.
+async function applyEdits(edits, routes, button) {
+  const list = edits.entries();
+  if (!list.length) return { ok: true, failed: [] };
+  const label = button && button.textContent;
+  if (button) {
+    button.disabled = true;
+    button.textContent = t("edits.applying");
+  }
+  const failed = [];
+  for (const [key, e] of list) {
+    try {
+      const r = e.kind === "reset" ? await post(routes.reset, { key }) : await post(routes.set, { key, value: e.value });
+      if (!r.ok) failed.push(`${key}: ${(r.output || r.command || "").trim().split("\n")[0]}`);
+    } catch (err) {
+      failed.push(`${key}: ${err.message}`);
+    }
+  }
+  if (button) {
+    button.disabled = false;
+    if (label) button.textContent = label;
+  }
+  if (failed.length) toast(t("edits.someFailed", { n: failed.length }), "bad", failed.join("\n"));
+  else toast(t("edits.applied", { n: list.length }), "ok");
+  return { ok: !failed.length, failed };
+}
+
+// The same batching, for a panel whose edits are not key/value pairs (v0.49.2).
+// The house-rule ledger stages ADDs, REMOVEs, TOGGLEs and MOVEs — four routes,
+// four body shapes — so the entry carries its own `route` and `body` and this
+// runs them one at a time in staged order. Every other rule of `applyEdits`
+// holds exactly: a refused write NEVER aborts the rest, and every failure is
+// reported by the key it was staged under.
+// `opts.stopOnFail` is the exception: POSITIONAL writes (the hook board) were
+// each computed assuming every earlier one succeeded, so after a refusal the
+// rest would hit the wrong part. It stops at the first failure; the panel
+// passes `opts.stoppedText(n)` to name the n writes that were NOT sent.
+async function applyActions(edits, button, opts) {
+  const o = opts || {};
+  const list = edits.entries();
+  if (!list.length) return { ok: true, failed: [] };
+  const label = button && button.textContent;
+  if (button) {
+    button.disabled = true;
+    button.textContent = t("edits.applying");
+  }
+  const failed = [];
+  for (const [key, e] of list) {
+    try {
+      const r = await post(e.route, e.body);
+      if (!r.ok) failed.push(`${key}: ${(r.output || r.command || "").trim().split("\n")[0]}`);
+    } catch (err) {
+      failed.push(`${key}: ${err.message}`);
+    }
+    if (o.stopOnFail && failed.length) {
+      const left = list.length - list.findIndex((x) => x[0] === key) - 1;
+      if (left > 0) failed.push(o.stoppedText ? o.stoppedText(left) : String(left));
+      break;
+    }
+  }
+  if (button) {
+    button.disabled = false;
+    if (label) button.textContent = label;
+  }
+  if (failed.length) toast(t("edits.someFailed", { n: o.stopOnFail ? 1 : failed.length }), "bad", failed.join("\n"));
+  else toast(t("edits.applied", { n: list.length }), "ok");
+  return { ok: !failed.length, failed };
+}

package/bin/webui/js/panels/behaviour.js

@@ -19,6 +19,8 @@
    and every static request here needs the per-launch session token. */
 
 const BH_TABS = ["habits", "rhythm", "gotchas", "quality", "log"];
+// v2.1.0 (A13): the tabs that stay under `habits: off` — review learning is always on.
+const BH_TABS_OFF = ["quality", "gotchas"];
 const BH_WINDOWS = ["30d", "90d", "all"];
 const BH_SVG = "http://www.w3.org/2000/svg";
 let bhTab = "habits";
@@ -90,22 +92,31 @@ async function bhLoad(body, right, focusId) {
   }
   const d = hab.data || {};
   right.replaceChildren(bhModeSwitch(d, body, right));
-  // `habits: off` (exit 3) — ONE card instead of the tabs.
+  // `habits: off` (exit 3) — the off card INSTEAD of the habit tabs. v2.1.0 (A13):
+  // review learning is ALWAYS on, so Review quality and Gotchas stay below it.
   if (d.ok === false && Array.isArray(d.on)) {
+    const [gotchas, quality, cands] = await Promise.all([
+      read("/api/gotchas").catch(() => ({ data: null })),
+      read("/api/gotcha/quality?window=" + encodeURIComponent(bhWindow)).catch(() => ({ data: null })),
+      read("/api/gotcha/candidates").catch(() => ({ data: null })),
+    ]);
+    const tabs = bhTabs({ d: {}, tabs: BH_TABS_OFF, gotchas: gotchas.data, quality: quality.data, cands: cands.data, body, right });
     body.classList.toggle("bh-quiet", bhPainted);
-    body.replaceChildren(bhOffCard(d), bhFooter(null, true));
+    body.replaceChildren(bhOffCard(d), tabs.bar, tabs.panel, bhFooter(null, true));
+    tabs.fill();
     bhPainted = true;
     return;
   }
   right.append(bhWindowSwitch(body, right));
-  const [log, states, gotchas, quality, cands] = await Promise.all([
+  const [log, states, gotchas, quality, cands, points] = await Promise.all([
     read("/api/habits/log").catch(() => ({ data: null })),
     read("/api/habits/states").catch(() => ({ data: null })),
     read("/api/gotchas").catch(() => ({ data: null })),
     read("/api/gotcha/quality?window=" + encodeURIComponent(bhWindow)).catch(() => ({ data: null })),
     read("/api/gotcha/candidates").catch(() => ({ data: null })),
+    read("/api/habits/points").catch(() => ({ data: null })),
   ]);
-  const ctx = { d, log: log.data, states: states.data, gotchas: gotchas.data, quality: quality.data, cands: cands.data, body, right };
+  const ctx = { d, log: log.data, states: states.data, gotchas: gotchas.data, quality: quality.data, cands: cands.data, points: points.data, body, right };
   body.classList.toggle("bh-quiet", bhPainted);
   const out = frag();
   out.append(bhHero(d));
@@ -285,8 +296,9 @@ function bhTabs(ctx) {
     gotchas: g ? g.rows.length : null,
     log: ctx.log && ctx.log.events ? ctx.log.events.length : null,
   };
+  const TABS = ctx.tabs || BH_TABS;
   const btns = [];
-  for (const id of BH_TABS) {
+  for (const id of TABS) {
     const b = el("button", "bh-tab");
     b.type = "button";
     b.id = "bh-tab-" + id;
@@ -300,12 +312,12 @@ function bhTabs(ctx) {
     }
     b.addEventListener("click", () => select(id, false));
     b.addEventListener("keydown", (e) => {
-      const i = BH_TABS.indexOf(id);
+      const i = TABS.indexOf(id);
       const to =
-        e.key === "ArrowRight" ? BH_TABS[(i + 1) % BH_TABS.length]
-        : e.key === "ArrowLeft" ? BH_TABS[(i - 1 + BH_TABS.length) % BH_TABS.length]
-        : e.key === "Home" ? BH_TABS[0]
-        : e.key === "End" ? BH_TABS[BH_TABS.length - 1]
+        e.key === "ArrowRight" ? TABS[(i + 1) % TABS.length]
+        : e.key === "ArrowLeft" ? TABS[(i - 1 + TABS.length) % TABS.length]
+        : e.key === "Home" ? TABS[0]
+        : e.key === "End" ? TABS[TABS.length - 1]
         : null;
       if (!to) return;
       e.preventDefault();
@@ -335,7 +347,7 @@ function bhTabs(ctx) {
     ({ habits: bhHabits, rhythm: bhRhythm, gotchas: bhGotchas, quality: bhQuality, log: bhLog })[id](panel, ctx);
     requestAnimationFrame(moveInk);
   }
-  return { bar, panel, fill: () => select(BH_TABS.includes(bhTab) ? bhTab : "habits", false) };
+  return { bar, panel, fill: () => select(TABS.includes(bhTab) ? bhTab : TABS[0], false) };
 }
 
 // ── Habits ──────────────────────────────────────────────────────────────────
@@ -866,6 +878,8 @@ function bhQuality(slot, ctx) {
   const floor = (c) => c.append(el("div", "bh-floor", Q.floor_line || ""));
   const g = el("div", "grid grid-2");
   const cc = card(t("behaviour.q.cats"), el("span", "note", tn(Q.reviews || 0, "behaviour.q.reviews")));
+  // v2.1.0 — a review the project asked for is counted on its own line (the CLI sums it).
+  if (Q.project_reviews) cc.append(el("div", "note", t("behaviour.q.projectReviews").replace("{n}", String(Q.project_reviews))));
   if (Q.below_floor) floor(cc);
   else {
     const bands = Q.bands || {};
@@ -948,19 +962,70 @@ function bhQuality(slot, ctx) {
   }
   g2.append(sp);
   slot.append(g2);
+  bhFixes(slot, Q);
+}
+
+// v2.1.0 — "Fixes after review" (`orc fix record`). Every number is the CLI's:
+// the count, each cause's `n` and its bar `share`, and the misses list.
+function bhFixes(slot, Q) {
+  const F = Q.fixes;
+  if (!F) return;
+  const M = Q.misses || { total: 0, list: [] };
+  const g = el("div", "grid grid-2");
+  const fc = card(t("behaviour.q.fixes"), el("span", "note", tn(F.total || 0, "behaviour.q.fixCount")));
+  if (!F.total) fc.append(empty(t("behaviour.q.fixesNone")));
+  else {
+    (F.causes || []).forEach((c, i) => {
+      const row = el("div", "bh-cat");
+      const bar = el("div", "bh-cat-bar");
+      const s = el("span", "bh-grow-x");
+      s.style.width = Math.round((c.share || 0) * 100) + "%";
+      s.dataset.band = c.id === "other" ? "warn" : "bad";
+      s.style.animationDelay = i * 90 + "ms";
+      bar.append(s);
+      const label = { sonar: t("behaviour.q.cause.sonar"), orc: t("behaviour.q.cause.orc"), ai: t("behaviour.q.cause.ai"), other: t("behaviour.q.cause.other") }[c.id] || c.id;
+      row.append(el("div", "bh-cat-name", label), bar, el("div", "bh-cat-num mono", String(c.n)));
+      fc.append(row);
+    });
+    fc.append(el("div", "note", t("behaviour.q.fixesNote")));
+  }
+  g.append(fc);
+  const mc = card(t("behaviour.q.misses"), el("span", "note", String(M.total || 0)));
+  if (!(M.list || []).length) mc.append(empty(t("behaviour.q.missesNone")));
+  for (const m of M.list || []) {
+    const row = el("div", "bh-lesson");
+    row.append(el("div", "bh-lesson-id mono", m.obs || ""));
+    const mid = el("div");
+    mid.append(el("div", "bh-lesson-rule mono", `${m.path || "—"}${m.lines && m.lines.length ? ":" + m.lines.join("-") : ""}`));
+    const sub = el("div", "bh-lesson-sub");
+    if (m.rule) sub.append(el("span", "mono", m.rule));
+    if (m.category) sub.append(el("span", "mono", m.category));
+    if (m.missed_by) sub.append(el("span", null, t("behaviour.q.missedBy", { run: m.missed_by })));
+    mid.append(sub);
+    row.append(mid);
+    mc.append(row);
+  }
+  g.append(mc);
+  slot.append(g);
 }
 
 // ── Answer log ──────────────────────────────────────────────────────────────
 function bhLog(slot, ctx) {
   const c = card(t("behaviour.log.title"), el("span", "note", t("behaviour.log.from")));
   const events = (ctx.log && ctx.log.events) || [];
+  const titles = {};
+  for (const p of (ctx.points && ctx.points.points) || []) titles[p.qid] = p.title;
   if (!events.length) c.append(empty(t("behaviour.emptyTitle"), t("behaviour.emptyHint")));
   const list = el("div", "bh-log");
   events.forEach((e, i) => {
     const row = el("div", "bh-log-row");
     row.style.animationDelay = Math.min(i, 12) * 70 + "ms";
     const q = el("span", "bh-log-q");
-    q.append(el("span", "mono", e.qid), document.createTextNode(" → "), el("b", null, e.chose));
+    // v2.1.0 (A12): the question's title from the registry, the id kept as a hint.
+    const title = titles[e.qid];
+    const qn = el("span", title ? null : "mono", title || e.qid);
+    if (title) qn.title = e.qid;
+    q.append(qn, document.createTextNode(" → "), el("b", null, e.chose));
     const by = chip(e.by);
     by.dataset.by = e.by;
     row.append(el("span", "t mono", new Date(e.at).toLocaleString()), el("span", "ln mono", e.lane), q, by);