@azure-id/orc 1.4.0 → 1.4.2

package/bin/cli.js

@@ -34405,6 +34405,43 @@ const STATUSLINE_RENDERERS = {
   pulse: { kind: "motif", sub: "pulse", needs: "motif" },
 };
 
+// WHICH RENDERERS DRAW A LABEL. Seven of thirty-five, and the other
+// twenty-eight ignore `label` entirely — a bar with a word in front of it is a
+// different renderer (`plain`), which is the design. That was invisible in the
+// panel: the Name box was offered on every shape, took the text, wrote it to
+// disk correctly, and then nothing appeared on the bar. A control that cannot
+// do anything must SAY so.
+//
+// It is a mirror of the switch in `slLowerItem`, and a golden test reads that
+// switch and compares — the `DIY_STEPS` shape. Adding a `pushLabel` branch
+// without adding the name here fails the test rather than shipping a control
+// that lies.
+const SL_LABEL_RENDERERS = new Set(["plain", "label-value", "bracket", "angle", "badge", "pill", "stack"]);
+
+// The item fields a renderer CONSUMES. Everything else on the chip is ignored
+// by that shape, and the panel greys it out with this as the reason.
+//
+// The split is the compiler's own: only a `text` (and `link`) renderer lowers
+// the FORMAT — `case`, `prefix`, `suffix`, `format`, `compact`, `min_width`,
+// `precision`, `truncate` all ride inside it — while a bar takes `width`,
+// `ramp` and `threshold`, a series takes `width`, and a state or a motif takes
+// neither. Colour and emphasis apply everywhere, so they are never listed as
+// unusable.
+function slRendererUses(name) {
+  const rend = STATUSLINE_RENDERERS[name];
+  if (!rend) return [];
+  const out = [];
+  if (SL_LABEL_RENDERERS.has(name)) out.push("label");
+  if (rend.kind === "text" || rend.kind === "link")
+    out.push("case", "prefix", "suffix", "format", "compact", "min_width", "precision", "truncate");
+  if (rend.width) out.push("width");
+  if (rend.kind === "bar" || name === "bar") {
+    out.push("ramp");
+    if (!out.includes("width")) out.push("width");
+  }
+  return out;
+}
+
 // ── The glyph sets (design-language.md §2) ──────────────────────────────────
 // R1: every glyph here is EXACTLY one column in a monospaced terminal, and a
 // test walks all of them. Fullwidth forms, bare emoji and combining marks are
@@ -34533,6 +34570,38 @@ const STATUSLINE_HIDE_WHEN = [
   { id: "wide", says: "hide above this component's max_cols" },
 ];
 
+// The separators a line can put BETWEEN its parts. A free-text box asked the
+// user to invent a rhythm and to type a character their keyboard may not have;
+// this is the closed set, and the panel renders it as a dropdown because the
+// panel names none of these itself. `value` is what is written into the layout,
+// `name` is what a person reads. A layout may still carry any string — a value
+// outside this set is kept and offered back, the way an unset `fixed_executor`
+// leads its own dropdown.
+const SL_SEPARATORS = [
+  { value: " · ", name: "middle dot" },
+  { value: " ", name: "one space" },
+  { value: "  ", name: "two spaces" },
+  { value: " │ ", name: "upright line" },
+  { value: " — ", name: "long dash" },
+  { value: " - ", name: "hyphen" },
+  { value: " / ", name: "slash" },
+  { value: " • ", name: "bullet" },
+  { value: " ▸ ", name: "small arrow" },
+  { value: " » ", name: "double arrow" },
+  { value: ", ", name: "comma" },
+  { value: " | ", name: "pipe" },
+];
+
+// What each colour set is FOR. The names are the CLI's own and are never
+// translated; this sentence is why a person would pick one, and without it the
+// picker is four words with no meaning.
+const SL_THEME_ABOUT = {
+  terminal: "the default: your terminal's own colours, one accent",
+  dim: "everything quiet — labels and values both greyed",
+  "high-contrast": "the brightest slot of every colour, for a pale terminal",
+  mono: "no colour at all; weight and shape carry every state",
+};
+
 const SL_FORMATS = ["percent", "ratio", "fraction", "decimal", "plain"];
 const SL_COMPACT = ["off", "si", "bytes"];
 const SL_CASES = ["none", "upper", "lower", "title"];
@@ -34787,6 +34856,15 @@ const SL_BY_ID = new Map(STATUSLINE_COMPONENTS.map((c) => [c.id, c]));
 // compiler, the IR, every renderer, the glyph sets, the colour model and the
 // validator — what differs is the component set, the file names and the config
 // key. A second compiler is exactly what this table exists to prevent.
+// HOW MUCH ONE LINE MAY SAY (v1.4.2). Six, not five. The limit is about
+// reading, not about rendering: a line is scanned at a glance, and past about
+// half a dozen facts the glance becomes a read. Six is where people actually
+// stopped asking for one more — and it is ONE number, here, because a slot cap
+// spelled out at each of its five call sites is a cap that drifts on the first
+// change. A structural part (a spacer, a divider, a fill) is not a thing the
+// line SAYS and still does not count against it.
+const SL_MAX_PER_LINE = 6;
+
 const SL_BOARDS = {
   status: {
     id: "status",
@@ -34973,7 +35051,7 @@ function slValidate(layout) {
       E(`line ${i + 1} holds ${rawCounts[i]} component${rawCounts[i] === 1 ? "" : "s"} but line ${i} is empty — fill line ${i} first`);
   }
   layout.lines.forEach((l, i) => {
-    if (counts[i] > 5) E(`line ${i + 1} holds ${counts[i]} components (max 5) — remove one`);
+    if (counts[i] > SL_MAX_PER_LINE) E(`line ${i + 1} holds ${counts[i]} components (max ${SL_MAX_PER_LINE}) — remove one`);
   });
 
   const seenIds = new Set();
@@ -35280,6 +35358,13 @@ function slCompile(layout) {
         pad_r: (r.padding && r.padding[1]) || 0,
         children,
       };
+      // WHETHER THIS ONE COUNTS AGAINST THE LINE'S CAP (v1.4.2). The hook's
+      // cheap shape guard has to count the same way the validator does, and it
+      // cannot: the compiled op carries an INSTANCE id, never a component type.
+      // So the compiler — which is the one place that knows — says so. Without
+      // it the guard counted spacers too, and a legal line of six plus a fill
+      // fell back to the shipped lines with no visible reason.
+      if (slIsStructural(item.type)) itemOp.s = 1;
       if (r.min_cols) itemOp.min_cols = r.min_cols;
       if (r.max_cols) itemOp.max_cols = r.max_cols;
       ops.push(itemOp);
@@ -35343,6 +35428,13 @@ function slCompile(layout) {
     providers: [...providers].sort(),
     series: [...seriesWanted].sort(),
     needs_refresh_interval: timeBased ? 5 : null,
+    // THE CAP TRAVELS WITH THE PROGRAM (v1.4.2). A hook cannot call this CLI —
+    // a status line re-renders on every keystroke — so before this it simply
+    // held its own `5`, and raising the cap here left every legal six-part line
+    // falling back to the shipped lines with the reason only in a ledger file.
+    // The lock is already gated on `orc_version`, so a stale copy cannot
+    // outlive the build that wrote it.
+    max_per_line: SL_MAX_PER_LINE,
     warnings: [],
   };
   return { compiled, lock };
@@ -36055,6 +36147,8 @@ function statusline() {
       return slRemoveCmd(claudeDir, p);
     case "line":
       return slLineCmd(claudeDir, p);
+    case "doc":
+      return slDocCmd(claudeDir, p);
     case "presets":
       return slPresetsCmd(claudeDir);
     case "apply":
@@ -36075,6 +36169,7 @@ function statusline() {
        orc statusline move <from-line>:<pos> <to-line>:<pos>
        orc statusline remove <line>:<pos>
        orc statusline line <n> --separator "…" [--max-width N] [--theme T]
+       orc statusline doc [--theme T] [--glyphs G] [--ansi auto|off] [--align-columns on|off]
        orc statusline group <line>:<pos> <line>:<pos> [...]   wrap 2-4 as one object
        orc statusline expand <line>:<pos>                     a composite, or a group, back into its parts
        orc statusline clone <line>:<pos>
@@ -36113,6 +36208,10 @@ function slComponentsCmd() {
       binding: c.binding,
       composite: c.composite || null,
       time_based: !!c.time_based,
+      // Whether this one eats a slot. A spacer is not a thing the line SAYS, so
+      // it does not count against the five — and the panel cannot work that out
+      // for itself without owning a second idea of the catalogue.
+      structural: slIsStructural(c.id),
       previews: slRendererPreviews(c),
     };
     out.push(row);
@@ -36126,7 +36225,12 @@ function slComponentsCmd() {
       count: out.length,
       groups: SL_GROUP_NAMES,
       components: out,
-      renderers: Object.fromEntries(Object.entries(STATUSLINE_RENDERERS).map(([k, v]) => [k, { kind: v.kind, form: v.form || null, needs: v.needs, width: v.width || null, decoration: !!v.decoration }])),
+      // `uses` is the field list this shape actually consumes. The panel greys
+    // out the controls it does not, rather than offering a Name box on a bar.
+    renderers: Object.fromEntries(Object.entries(STATUSLINE_RENDERERS).map(([k, v]) => [k, { kind: v.kind, form: v.form || null, needs: v.needs, width: v.width || null, decoration: !!v.decoration, uses: slRendererUses(k) }])),
+    // Which shapes DO draw a label, so a refusal can name them instead of
+    // saying "not here".
+    label_renderers: [...SL_LABEL_RENDERERS],
       glyph_sets: Object.keys(STATUSLINE_GLYPHSETS),
       ramps: Object.fromEntries(Object.entries(STATUSLINE_RAMPS).map(([k, v]) => [k, { stops: v.stops, colors: v.colors, why: v.why }])),
       themes: STATUSLINE_THEMES,
@@ -36138,9 +36242,11 @@ function slComponentsCmd() {
       emphasis: Object.keys(SL_EMPHASIS),
       refused_emphasis: SL_REFUSED_EMPHASIS,
       colors: Object.keys(SL_ANSI_SLOTS),
+      separators: SL_SEPARATORS,
+      themes_about: SL_THEME_ABOUT,
       board: board.id,
       boards: Object.keys(SL_BOARDS),
-      max_per_line: 5,
+      max_per_line: SL_MAX_PER_LINE,
       lines: board.lines,
       config_key: board.key,
       setting: board.setting,
@@ -36204,6 +36310,31 @@ function slLoadOrDefault(claudeDir) {
   return slReadLayout(claudeDir, b) || slBuildPreset(b.id === "subagent" ? "agent-default" : "orc-default");
 }
 
+// EVERY field a chip can carry, in the order the editor asks about them. It is
+// ONE list: `show --json` emits all of them, and the panel's editor reads them
+// back. A field that is settable and not listed here is a write with no way to
+// see it again, which is the v1.4.2 defect this exists to make impossible.
+const SL_ITEM_FIELDS = [
+  "render", "label", "color", "label_color", "value_color", "bg", "ramp",
+  "glyphs", "format", "case", "truncate", "compact", "prefix", "suffix",
+  "emphasis", "hide_when", "width", "precision", "min_width", "min_cols",
+  "max_cols", "priority", "max_len", "align", "draw_empty", "unknown",
+];
+// The ones whose absence is an empty LIST rather than a null — a control that
+// iterates a null throws, and a null here would read as "unknown" when it means
+// "nothing selected".
+const SL_ITEM_LIST_FIELDS = new Set(["emphasis", "hide_when"]);
+
+function slAuthoredFields(it) {
+  const out = {};
+  for (const k of Object.keys(it || {})) {
+    if (k === "id" || k === "type" || k === "children") continue;
+    if (it[k] === null || it[k] === undefined) continue;
+    out[k] = it[k];
+  }
+  return out;
+}
+
 function slShowCmd(claudeDir) {
   const layout = slReadLayout(claudeDir);
   const eff = layout || slBuildPreset("orc-default");
@@ -36221,23 +36352,29 @@ function slShowCmd(claudeDir) {
     max_width: l.max_width || 0,
     count: (l.items || []).length,
     counted: (l.items || []).filter((it) => !slIsStructural(it.type)).length,
-    full: (l.items || []).filter((it) => !slIsStructural(it.type)).length >= 5,
+    full: (l.items || []).filter((it) => !slIsStructural(it.type)).length >= SL_MAX_PER_LINE,
+    // `--json is not a summary` (v0.49.1), found once more (v1.4.2). This
+    // emitted TWELVE of the twenty-four fields a chip can carry, so a user who
+    // set `case`, `prefix`, `min_cols` or `precision` got a write that landed on
+    // disk and a panel that could never read it back — the editor reopened with
+    // the control blank and the change looked like it had done nothing. Every
+    // resolved field ships now, and `authored` carries the raw item so a
+    // control can say which values are the USER'S rather than inherited.
     items: (l.items || []).map((it, pi) => {
       const r = slResolveItem(it, eff, l);
-      return {
+      const row = {
         pos: pi + 1,
         id: it.id,
         type: it.type,
-        render: r ? r.render : it.render,
-        label: r ? r.label : null,
-        label_color: r ? r.label_color || null : null,
-        value_color: r ? r.value_color || null : null,
-        ramp: r ? r.ramp || null : null,
-        emphasis: r ? r.emphasis || [] : [],
-        hide_when: r ? r.hide_when || [] : [],
-        unknown: r ? r.unknown : null,
         known: SL_BY_ID.has(it.type),
+        // WHAT THE USER SET, verbatim — never the resolution. A control that
+        // cannot tell "you chose the theme's colour" from "you chose nothing"
+        // cannot offer to clear it.
+        authored: slAuthoredFields(it),
       };
+      for (const k of SL_ITEM_FIELDS) row[k] = r && r[k] !== undefined && r[k] !== null ? r[k] : SL_ITEM_LIST_FIELDS.has(k) ? [] : null;
+      if (it.children) row.children = it.children.map((k) => ({ id: k.id, type: k.type, authored: slAuthoredFields(k) }));
+      return row;
     }),
   }));
   if (wantsJson())
@@ -36262,7 +36399,7 @@ function slShowCmd(claudeDir) {
   console.log("");
   for (const l of lines) {
     const cells = l.items.map((i) => ui.color.cyan(i.type) + ui.color.gray("/" + i.render)).join(ui.color.gray("  ·  "));
-    console.log(`  ${ui.color.gray("line " + l.line)}  ${cells || ui.color.gray("(empty)")}   ${l.full ? ui.color.yellow("5/5") : ui.color.gray(l.counted + "/5")}`);
+    console.log(`  ${ui.color.gray("line " + l.line)}  ${cells || ui.color.gray("(empty)")}   ${l.full ? ui.color.yellow(l.counted + "/" + SL_MAX_PER_LINE) : ui.color.gray(l.counted + "/" + SL_MAX_PER_LINE)}`);
   }
   if (preview) {
     console.log("");
@@ -36318,7 +36455,17 @@ function slValidateCmd(claudeDir) {
 }
 
 function slPreviewCmd(claudeDir) {
-  const layout = slLoadOrDefault(claudeDir);
+  const saved = slLoadOrDefault(claudeDir);
+  // A RENDER-ONLY OVERRIDE (v1.4.2). `--theme` and `--glyphs` draw the SAVED
+  // layout under a different colour set or symbol set WITHOUT writing one — so
+  // the panel can show what each choice actually looks like instead of asking
+  // somebody to pick a colour set from its name. It is the same engine and the
+  // same layout; only the two document fields move, on a copy.
+  const layout = JSON.parse(JSON.stringify(saved));
+  const asTheme = flag("--theme");
+  const asGlyphs = flag("--glyphs");
+  if (typeof asTheme === "string" && STATUSLINE_THEMES[asTheme]) layout.theme = asTheme;
+  if (typeof asGlyphs === "string" && STATUSLINE_GLYPHSETS[asGlyphs]) layout.glyphs = asGlyphs;
   const v = slValidate(layout);
   if (!v.ok) {
     if (wantsJson()) return emitJson({ ok: false, reason: "invalid", errors: v.errors }, 1);
@@ -36357,6 +36504,11 @@ function slPreviewCmd(claudeDir) {
   const out = {
     ok: true,
     width: cols,
+    // WHAT THIS PICTURE WAS DRAWN WITH. The panel compares colour sets by
+    // asking for the same layout several times; without these two it could not
+    // label the answers.
+    theme: layout.theme,
+    glyphs: layout.glyphs,
     state,
     fixture: (SL_FIXTURES[state] || SL_FIXTURES.healthy).label,
     fixtures: Object.fromEntries(Object.entries(SL_FIXTURES).map(([k, f]) => [k, f.label])),
@@ -36499,6 +36651,51 @@ function slLineCmd(claudeDir, p) {
   return slSaveAndCompile(claudeDir, layout, { action: "line", line: n });
 }
 
+// THE DOCUMENT-LEVEL SETTINGS, and they are a separate command on purpose.
+// `line <n> --theme` sets ONE line's override; the colour set a user picks in
+// the panel is the WHOLE layout's, and writing it onto line 1 changed one third
+// of the bar while `show --json` kept reporting the document theme — so the
+// picker looked dead and was in fact half working, which is worse. One command
+// per scope, and the panel calls the one that matches the control.
+function slDocCmd(claudeDir, p) {
+  const layout = slLoadOrDefault(claudeDir);
+  const th = flag("--theme");
+  if (typeof th === "string") {
+    if (!STATUSLINE_THEMES[th]) {
+      if (wantsJson()) return emitJson({ ok: false, reason: "unknown-theme", theme: th, known: Object.keys(STATUSLINE_THEMES) }, 2);
+      console.error(`unknown colour set "${th}" — known: ${Object.keys(STATUSLINE_THEMES).join(", ")}`);
+      process.exit(2);
+    }
+    layout.theme = th;
+    // A per-LINE override outranks the document, so a colour set chosen here
+    // would be invisible on any line that carries one. The overrides are
+    // cleared and the answer NAMES the lines it cleared — a setting silently
+    // shadowed is the one failure this whole command exists to fix.
+    for (const l of layout.lines) l.theme = null;
+  }
+  const gl = flag("--glyphs");
+  if (typeof gl === "string") {
+    if (!STATUSLINE_GLYPHSETS[gl]) {
+      if (wantsJson()) return emitJson({ ok: false, reason: "unknown-glyphs", glyphs: gl, known: Object.keys(STATUSLINE_GLYPHSETS) }, 2);
+      console.error(`unknown symbol set "${gl}" — known: ${Object.keys(STATUSLINE_GLYPHSETS).join(", ")}`);
+      process.exit(2);
+    }
+    layout.glyphs = gl;
+  }
+  const an = flag("--ansi");
+  if (typeof an === "string") {
+    if (!["auto", "off"].includes(an)) {
+      if (wantsJson()) return emitJson({ ok: false, reason: "unknown-ansi", ansi: an, known: ["auto", "off"] }, 2);
+      console.error(`--ansi takes auto or off`);
+      process.exit(2);
+    }
+    layout.ansi = an;
+  }
+  const align = flag("--align-columns");
+  if (typeof align === "string") layout.align_columns = align === "on";
+  return slSaveAndCompile(claudeDir, layout, { action: "doc", theme: layout.theme, glyphs: layout.glyphs, ansi: layout.ansi, align_columns: !!layout.align_columns });
+}
+
 function slPresetsCmd(claudeDir) {
   const layout = slReadLayout(claudeDir);
   const rows = slPresetsFor(slBoard().id).map(([name, p]) => {

package/bin/webui/api.js

@@ -269,6 +269,11 @@ const READS = {
     const argv = ["statusline", "preview", ...slBoard(q)];
     if (q.width) argv.push("--width", String(q.width));
     if (q.state) argv.push("--state", String(q.state));
+    // v1.4.2 — a RENDER-ONLY override, so the panel can draw the same layout
+    // under each colour set and each symbol set. It writes nothing: the CLI
+    // applies these to a copy of the saved layout before it compiles.
+    if (q.theme) argv.push("--theme", String(q.theme));
+    if (q.glyphs) argv.push("--glyphs", String(q.glyphs));
     return argv;
   },
   "/api/statusline/explain": (q) => ["statusline", "explain", String(q.at || "1:1"), ...slBoard(q)],
@@ -483,6 +488,17 @@ const WRITES = {
   },
   // A preset REPLACES the layout, so the panel always confirms it and names
   // the loss — the `orc diy init --force` rule.
+  // THE DOCUMENT-LEVEL SETTINGS. `line` is per-LINE and `doc` is the whole
+  // layout; the colour set is a document fact, and routing it through `line`
+  // wrote one third of the bar while the picker read the other value back.
+  "/api/statusline/doc": (b) => {
+    const argv = ["statusline", "doc"];
+    if (b.theme) argv.push("--theme", String(b.theme));
+    if (b.glyphs) argv.push("--glyphs", String(b.glyphs));
+    if (b.ansi) argv.push("--ansi", String(b.ansi));
+    if (b.align_columns !== undefined) argv.push("--align-columns", b.align_columns ? "on" : "off");
+    return argv.concat(slBoard(b));
+  },
   "/api/statusline/apply": (b) => ["statusline", "apply", String(b.name), ...slBoard(b)],
   // v1.3.0 W5. `group` wraps 2-4 as one object, `expand` is its inverse and is
   // also how a composite becomes editable, `clone` is for two `config` chips on

package/bin/webui/css/04-motion.css

@@ -37,6 +37,61 @@
   from { opacity: 0; transform: translateY(8px); }
   to   { opacity: 1; transform: none; }
 }
+/* ── the CLI Hook Interface (v1.4.1) ─────────────────────────────────────── */
+/* The board is a thing you BUILD, so it moves the way a thing you build moves:
+   a chip arrives, a chip you just staged breathes once so you can find it, and
+   a row in the part picker slides in as the list narrows under your typing.
+   Every one of them is a FINITE animation with a real end state, so the cap in
+   the reduced-motion block below leaves each one at rest rather than frozen
+   part-way. */
+.hk-chip { animation: hk-chip-in 200ms var(--ease) backwards; }
+@keyframes hk-chip-in {
+  from { opacity: 0; transform: translateY(6px) scale(0.97); }
+  to   { opacity: 1; transform: none; }
+}
+/* Staged, not written — and the one thing on the board that has to be findable
+   the instant it appears. Three pulses and it stops: an infinite one would have
+   to be REMOVED below rather than capped, and this one reads correctly at rest.
+   */
+.hk-chip-new { animation: hk-chip-in 200ms var(--ease) backwards, hk-chip-mark 900ms var(--ease) 3; }
+@keyframes hk-chip-mark {
+  0%, 100% { box-shadow: inset 0 0 0 0 var(--accent); }
+  50%      { box-shadow: inset 0 0 0 2px var(--accent); }
+}
+/* Position, drop marker, and the zone's own border: transitions rather than
+   animations, so an interrupted drag never leaves a chip mid-flight. */
+.hk-chip, .hk-zone, .hk-add, .hk-act, .hk-pick-row, .hk-theme, .hk-sample {
+  transition: border-color var(--dur) var(--ease), background var(--dur) var(--ease),
+              box-shadow var(--dur) var(--ease), opacity var(--dur) var(--ease),
+              transform var(--dur) var(--ease);
+}
+.hk-chip:hover:not(.hk-chip-dragging) { transform: translateY(-2px); }
+.hk-add:hover:not(:disabled) { transform: translateY(-2px); }
+.hk-pick-row { animation: hk-row-in 160ms var(--ease) backwards; }
+@keyframes hk-row-in {
+  from { opacity: 0; transform: translateX(-6px); }
+  to   { opacity: 1; transform: none; }
+}
+button.hk-pick-row:hover { transform: translateX(3px); }
+
+/* NOTHING ARRIVES ON A REPAINT (v1.4.2). The CLI Hook Interface rebuilds its
+   whole panel when a change is STAGED — no request, no navigation, the same
+   cards with one value different — and the entrance animations above replayed
+   every time, on a 30ms stagger. With the network tab empty it read exactly
+   like the page reloading, on every keystroke.
+
+   `hk-quiet` is added by `hkPaint` from the SECOND paint onward and by the part
+   editor before every rebuild. It removes the ENTRANCES only: the transitions
+   further up are about the pointer rather than about arriving, so hover, the
+   drop marker and the staged edge are untouched. It must load after the rules
+   it switches off, which is why it is here and not in the panel's own file. */
+.hk-quiet > *,
+.hk-quiet .hk-chip,
+.hk-quiet .hk-chip-new,
+.hk-quiet .hk-pick-row {
+  animation: none;
+}
+
 /* ---------------------------------------------------------- REDUCED MOTION */
 /* Non-negotiable: every animation and transition above is off. */
 
@@ -55,6 +110,12 @@
      nudges are removed outright rather than sped up. */
   .nav a:hover, .btn:active:not(:disabled), .action:hover,
   .todo:hover, .stat-link:hover, button.step:hover { transform: none !important; }
+  /* The board's own nudges, removed rather than shortened — a chip that lifts
+     under the pointer is an affordance, and a fast lift is still a lift. The
+     border and box-shadow changes stay: THEY are what says where a drop lands,
+     and a drop marker carried by motion alone would not exist here at all. */
+  .hk-chip:hover:not(.hk-chip-dragging), .hk-add:hover:not(:disabled),
+  button.hk-pick-row:hover { transform: none !important; }
   /* The vault pulse is one of two INFINITE animations on the page. Capping it to
      a single 1ms run would still leave a dash frozen mid-edge, so it is removed
      outright and the edge reads as a plain line. */

package/bin/webui/css/06-responsive.css

@@ -124,12 +124,14 @@
      way. The PREVIEW never collapses: it is a monospaced grid and squeezing it
      would misreport the width the user is deciding. It scrolls instead. */
   .hk-degrade-row,
+  .hk-compare-row,
   .hk-field,
   .hk-check {
     grid-template-columns: 1fr;
     gap: 4px;
   }
-  .hk-degrade-label {
+  .hk-degrade-label,
+  .hk-compare-label {
     text-align: left;
   }
   .hk-gallery {
@@ -138,6 +140,20 @@
   .hk-prow-id {
     min-width: 0;
   }
+  /* v1.4.1 — the editor's two-column field (a name plus the sentence that
+     explains it, then the control) stacks; and DRAG IS OFF below this width. A
+     40-pixel drop gap on a phone is not a target, so the three buttons on every
+     chip are the path — which is why they are buttons on the chip and not a
+     menu behind one. */
+  .hk-chip {
+    max-width: none;
+    flex-basis: 100%;
+    cursor: default;
+  }
+  .hk-grip { display: none; }
+  .hk-add { flex-basis: 100%; }
+  .hk-picker, .hk-editor { min-width: 0; }
+  .hk-theme { flex-basis: 100%; max-width: none; }
   /* The caution KEEPS its two columns. The mark and the sentence belong to each
      other, and stacking them puts a lone ✕ on a line of its own above the text
      it is about. The mark column narrows instead. */