@promptctl/cc-candybar 1.28.0 → 1.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/cc-candybar",
-  "version": "1.28.0",
+  "version": "1.30.0",
   "description": "Statusline renderer for Claude Code — a JSON5-configurable DSL with daemon-cached data sources, byte-clean palette-aware composition, and OSC8 click verbs.",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -91,9 +91,9 @@
     "mobx": "^6.15.0"
   },
   "optionalDependencies": {
-    "@promptctl/cc-candybar-darwin-arm64": "1.28.0",
-    "@promptctl/cc-candybar-darwin-x64": "1.28.0",
-    "@promptctl/cc-candybar-linux-x64": "1.28.0",
-    "@promptctl/cc-candybar-linux-arm64": "1.28.0"
+    "@promptctl/cc-candybar-darwin-arm64": "1.30.0",
+    "@promptctl/cc-candybar-darwin-x64": "1.30.0",
+    "@promptctl/cc-candybar-linux-x64": "1.30.0",
+    "@promptctl/cc-candybar-linux-arm64": "1.30.0"
   }
 }

package/schema/cc-candybar.schema.json

@@ -1321,6 +1321,49 @@
             ],
             "additionalProperties": false
           },
+          {
+            "type": "object",
+            "properties": {
+              "persist": {
+                "type": "string"
+              },
+              "removeSegment": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "persist",
+              "removeSegment"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "persist": {
+                "type": "string"
+              },
+              "insertSegment": {
+                "type": "string"
+              },
+              "anchor": {
+                "type": "string"
+              },
+              "relation": {
+                "enum": [
+                  "before",
+                  "after"
+                ]
+              }
+            },
+            "required": [
+              "persist",
+              "insertSegment",
+              "anchor",
+              "relation"
+            ],
+            "additionalProperties": false
+          },
           {
             "type": "object",
             "properties": {

package/src/click/wire.ts

@@ -66,6 +66,17 @@ export const VERB_STEP_CONFIG = "step-config";
 // config-overrides key, restoring the user-file/bundled-default value on the
 // next reload. Args: `[sessionId, key]`.
 export const VERB_RESET_CONFIG = "reset-config";
+// [LAW:one-type-per-behavior] brandon-layout-edit-2gc.1's structural-edit
+// verb — a THIRD write semantic beside set-config's plain overwrite and
+// step-config's numeric read-modify-write: read the current op-token LIST at
+// `key` (a "presets.<name>.rootOps" config-overrides target), append the
+// validated `op` token, write the whole list back. Args: `[sessionId, key,
+// op]` — `op` is one opaque token from src/config/layout-ops.ts's codec, the
+// SAME shape a `persist … to` literal's value would be, gated the SAME way
+// (validateConfigWrite) — only the write's SHAPE (append vs. overwrite)
+// differs, which is exactly why this is its own verb rather than another
+// VERB_SET_CONFIG value.
+export const VERB_APPLY_LAYOUT_OP = "apply-layout-op";
 
 // [LAW:types-are-the-program] An effect to EMIT: a verb plus its raw (unencoded)
 // positional args. The wire owns all encoding — callers never percent-encode.

package/src/config/action.ts

@@ -75,6 +75,14 @@ export type ActionKey = (typeof ACTION_KEYS)[number];
 //                         -> allow-list {members}
 //   copy                — copy templated text to the clipboard -> no gate
 //   open                — open a templated target in the editor -> no gate
+//   removeSegment       — (persist only) remove the named segment from the
+//                         preset-root the `persist` key addresses
+//                         (`presets.<name>.rootOps`) -> allow-list {one op
+//                         token — see src/config/layout-ops.ts}
+//   insertSegment +
+//     anchor + relation  — (persist only) insert a named segment before/after
+//                         an existing one, same key shape -> allow-list {one
+//                         op token}
 //
 // [LAW:one-source-of-truth] `set` writes SessionState and `persist` writes
 // the config-overrides layer, so only those two derive a validator (through
@@ -87,6 +95,15 @@ export type ActionKey = (typeof ACTION_KEYS)[number];
 // arms verbatim (to/from/min-max-by/cycle) MINUS `int`: an unbounded page
 // cursor is a UI-only paging concept (a picker's own navigation state) with
 // no meaning as a persisted config default.
+//
+// [LAW:locality-or-seam] `removeSegment`/`insertSegment` are `persist`-ONLY
+// (brandon-layout-edit-2gc.1) — a structural edit is always a durable,
+// machine-owned write by design (the ticket's own instruction: reuse 71o's
+// writer, land in the SAME overrides layer), so there is no SessionState
+// twin. Every operation is fully literal at config-author time — the
+// segment names and relation are DATA the loader proves at load, not a
+// runtime picker — so each declared action has exactly one legal request,
+// gated the same one-member-allow-list way a literal `to` already is.
 export type ActionDecl =
   | { readonly set: string; readonly to: string }
   | { readonly set: string; readonly from: OptionDomain }
@@ -107,6 +124,13 @@ export type ActionDecl =
       readonly by: number;
     }
   | { readonly persist: string; readonly cycle: readonly string[] }
+  | { readonly persist: string; readonly removeSegment: string }
+  | {
+      readonly persist: string;
+      readonly insertSegment: string;
+      readonly anchor: string;
+      readonly relation: "before" | "after";
+    }
   | { readonly copy: string }
   | { readonly open: string }
   | { readonly reset: string };

package/src/config/default-dsl-config.ts

@@ -247,14 +247,25 @@ function etaHeatFg(etaRef: string, warnRef: string): string {
 // time — the type safety net just moves from tsc to that parse, never lost.
 //
 // One collapsed-by-default drawer holding every bar-mutable display default:
-// theme/style/look (session `set` for a per-conversation preview, PLUS a
-// persist-forever twin — candybar-config-engine-71o.5 — for pinning the
-// choice as everyone's default), the four .3 globals steppers (persist-only,
-// no SessionState half at all), and one .6 segment-scoped persist control
-// (directoryPaletteControl, persist-only like the four steppers — a
-// per-segment palette pin, not a whole-bar default). Placed as a sibling in
-// row 1's horizontal container, toggled from beside the quick-action tray —
-// see `root` below.
+// theme/style/look/preset (session `set` for a per-conversation preview, PLUS
+// a persist-forever twin — candybar-config-engine-71o.5, brandon-presets-0yk.3
+// — for pinning the choice as everyone's default), the four .3 globals
+// steppers (persist-only, no SessionState half at all), and one .6
+// segment-scoped persist control (directoryPaletteControl, persist-only like
+// the four steppers — a per-segment palette pin, not a whole-bar default).
+// Placed as a sibling in row 1's horizontal container, toggled from beside the
+// quick-action tray — see `root` below.
+//
+// [LAW:one-source-of-truth] exception: this `kind: "group"` sugar node may
+// appear EXACTLY ONCE in the whole config — group names are a synthesis-wide
+// namespace (synthesizeGroupDecls collects every group across every preset's
+// root too), so a second `settingsDrawer` reference embedded in a preset's
+// own root would be a SECOND declaration of "settings" and collide with
+// itself, not a reuse of the first. It stays only in the default `root`
+// below; the library presets under `presets:` reach back to it — and to the
+// rest of the settingsDrawer's controls — by switching to the "default"
+// preset via the standalone `presetControl` segment they carry instead (see
+// each preset's own comment), never by re-embedding the group.
 const settingsDrawer = {
   kind: "group",
   name: "settings",
@@ -263,6 +274,7 @@ const settingsDrawer = {
   children: [
     "themeControl",
     "lookControl",
+    "presetControl",
     "styleControl",
     "charsetControl",
     "colorCompatControl",
@@ -1099,6 +1111,25 @@ export const RAW_DEFAULT_DSL_CONFIG = {
       bg: "surface",
       fg: "foreground",
     },
+    // Preset control — the whole-arrangement switcher (brandon-presets-0yk.3),
+    // the exact twin of themeControl/lookControl one level up: `.preset.
+    // effective` is the daemon-resolved name (effectivePresetName) that chose
+    // BOTH the compiled root this render walked and the globals it rendered
+    // with, so the label can never name an arrangement the bar is not in.
+    // closeOnPick on both menus, like lookControl: a preset swap is a
+    // decisive whole-bar change tried one at a time, not a stackable tweak.
+    // Lives inside settingsDrawer (never inside a preset's own staged root —
+    // see settingsDrawer's comment), so every bundled preset — including the
+    // narrow `compact` one — keeps the one control that switches back.
+    presetControl: {
+      template:
+        "▦ {{ .preset.effective }} " +
+        '{{ menu "applyPreset" (dict "key" "pickers" "closeOnPick" true) }} ' +
+        '📌{{ menu "applyPresetForever" (dict "key" "pickersForever" "closeOnPick" true) }} ' +
+        '{{ action "resetPreset" "↺" }}',
+      bg: "surface",
+      fg: "foreground",
+    },
     // ── The four .3 globals steppers, folded into the settingsDrawer group
     // (candybar-config-engine-71o.4) alongside theme/style/look above. Each
     // pairs a `persist` control with a `↺` reset (docs' persist/reset
@@ -1263,23 +1294,33 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     // block's names — the same derivation test/dsl-looks.test.ts exercises.
     applyTheme: { set: "theme", from: "themes" },
     applyLook: { set: "look", from: "looks" },
+    // [LAW:one-type-per-behavior] The preset picker's session-preview
+    // behavior (brandon-presets-0yk.3), the exact twin of applyLook one level
+    // up: "preset" has no baseline SessionState entry, so this derives a
+    // fresh allow-list validator ranging the merged `presets` block's names
+    // (the floor included — presetNames always seeds it) via the same
+    // `from`-sourced derivation every picker above uses.
+    applyPreset: { set: "preset", from: "presets" },
 
     // [LAW:one-source-of-truth] The persist-forever twins of applyTheme/
-    // applyStyle/applyLook above (candybar-config-engine-71o.5) — same
-    // domain sources (`from`), same picker mechanism, but the target is the
-    // Globals field the config DEFAULT reads (`palette`/`style`/`look`,
-    // isGlobalsField-checked at load), not the SessionState key the session
-    // preview writes. Precedence is unchanged: a session's own `set` pick
-    // (applyTheme/applyStyle/applyLook) still wins over a persisted default
-    // for that session — effectiveThemeName/effectiveStripStyle/
-    // effectiveLookName all read SessionState before globals. Paired with a
-    // `reset` each, per the docs' persist/reset convention.
+    // applyStyle/applyLook/applyPreset above (candybar-config-engine-71o.5,
+    // brandon-presets-0yk.3) — same domain sources (`from`), same picker
+    // mechanism, but the target is the Globals field the config DEFAULT
+    // reads (`palette`/`style`/`look`/`preset`, isGlobalsField-checked at
+    // load), not the SessionState key the session preview writes.
+    // Precedence is unchanged: a session's own `set` pick still wins over a
+    // persisted default for that session — effectiveThemeName/
+    // effectiveStripStyle/effectiveLookName/effectivePresetName all read
+    // SessionState before globals. Paired with a `reset` each, per the docs'
+    // persist/reset convention.
     applyThemeForever: { persist: "palette", from: "themes" },
     resetTheme: { reset: "palette" },
     applyStyleForever: { persist: "style", from: "styles" },
     resetStyle: { reset: "style" },
     applyLookForever: { persist: "look", from: "looks" },
     resetLook: { reset: "look" },
+    applyPresetForever: { persist: "preset", from: "presets" },
+    resetPreset: { reset: "preset" },
 
     // [LAW:locality-or-seam] The settings-drawer steppers' behaviors
     // (candybar-config-engine-71o.4), decoupled by NAME from
@@ -1380,21 +1421,117 @@ export const RAW_DEFAULT_DSL_CONFIG = {
   // Named config FRAGMENTS — each an alternative `root` + display `globals`,
   // i.e. a whole arrangement of the bar rather than one knob. A preset is to
   // configuration what a look is to a theme, and rides the identical seam:
-  // selected per session via the `preset` SessionState key (an action
-  // `{ set: "preset", from: "presets" }` + a `{{ menu }}`), resolved as session
-  // pick over globals.preset over this floor.
+  // selected per session via the `preset` SessionState key (the applyPreset
+  // action, `{ set: "preset", from: "presets" }`, and the presetControl
+  // segment's `{{ menu }}` above), resolved as session pick over
+  // globals.preset over this floor.
   // [LAW:one-source-of-truth] Merges by name (user wins per name), so this
-  // stdlib — currently just the floor — is present in every merged config by
-  // construction, exactly as looks' "none" is.
+  // stdlib is present in every merged config by construction, exactly as
+  // looks' "none"/"vivid"/"muted"/… is — a user redefining "compact" or
+  // "verbose" wins per name; the floor cannot be shadowed by anything but an
+  // empty fragment, because that IS what it already is.
+  //
+  // [LAW:carrying-cost] Each library preset stages only real deltas from the
+  // bundled default's own root (declared above) — no preset here restates a
+  // segment's template, bg, or fg, only which of the ALREADY-declared
+  // segments appear and in what arrangement, per the field cap
+  // (brandon-presets-0yk.1's premise note): a bundled preset can only STAGE
+  // segments DEFAULT_DSL_CONFIG.segments already declares, never introduce
+  // one.
+  //
+  // [LAW:verifiable-goals] Every entry here is asserted error-cell-free at
+  // 80/120/200 columns against a RICH payload in
+  // test/default-dsl-config.test.ts (the same checkPayload fixture check.ts
+  // uses) — curated by actually rendering each arrangement, not by reading
+  // the segment names off the page.
   presets: {
     // [LAW:dataflow-not-control-flow] "default" is just the identity fragment
     // — the resolution floor as a value, not a special case. An empty fragment
     // declares no `root` and no `globals`, so it stages the config's own, which
-    // is precisely what "no preset chosen" means. A usable preset LIBRARY on
-    // top of this floor is brandon-presets-0yk.3; the floor itself belongs here
-    // because effectivePresetName's collapse target must exist in every merged
-    // config, the same load-bearing reason "none" ships beside the real looks.
+    // is precisely what "no preset chosen" means. This is the bundled default's
+    // OWN two-row (identity / status) arrangement declared as `root` above —
+    // it needs no entry of its own here beyond the floor, because staging it
+    // AS a named fragment would be a byte-for-byte copy of `root` that could
+    // silently drift from it the moment either changed.
     default: {},
+
+    // Single-row arrangement for narrow terminals and split panes — the
+    // situation where a user most wants a different arrangement and least
+    // wants to hand-write one. Keeps only the three facts a split pane most
+    // needs at a glance (where am I / what's the git state / how much context
+    // is left), the quiet one-line `git` segment rather than the multi-fact
+    // `gitaculous`, and `padding: 0` to buy back the chrome a narrow column
+    // can't spare.
+    //
+    // [LAW:no-silent-failure] Carries the standalone `presetControl` segment
+    // (NOT the full settingsDrawer group — see that constant's own comment on
+    // why a group can't be re-embedded) so a session that switches TO compact
+    // is never stranded: one click back to "default" restores the drawer and
+    // everything else compact traded away for width.
+    compact: {
+      root: {
+        kind: "container",
+        direction: "horizontal",
+        children: [
+          { kind: "segment", name: "directory" },
+          { kind: "segment", name: "git" },
+          { kind: "segment", name: "context" },
+          { kind: "segment", name: "presetControl" },
+        ],
+      },
+      globals: { padding: 0 },
+    },
+
+    // Verbose arrangement surfacing every segment that is declared but NOT in
+    // the default root (gitPr, burnrate, speed, tokenSparkline — see each
+    // segment's own "declared-but-opt-in" comment above) alongside the
+    // default's own two rows, for a user who wants the full usage-monitor
+    // picture rather than the quiet default. A third row carries the two
+    // per-turn throughput segments, which read "—" between turns
+    // ([LAW:no-silent-failure] on speed/tokenSparkline) rather than an empty
+    // or stale row. Carries the standalone `presetControl` in place of the
+    // full settingsDrawer group, exactly like `compact` and for the same
+    // reason (that constant's comment) — switching back to "default" reaches
+    // the drawer and every other bar-mutable default from there.
+    verbose: {
+      root: {
+        kind: "container",
+        direction: "vertical",
+        children: [
+          {
+            kind: "container",
+            direction: "horizontal",
+            children: [
+              { kind: "segment", name: "directory" },
+              { kind: "segment", name: "gitaculous" },
+              { kind: "segment", name: "gitPr" },
+              { kind: "segment", name: "toolbar" },
+              { kind: "segment", name: "presetControl" },
+            ],
+          },
+          {
+            kind: "container",
+            direction: "horizontal",
+            children: [
+              { kind: "segment", name: "model" },
+              { kind: "segment", name: "context" },
+              { kind: "segment", name: "cacheTimer" },
+              { kind: "segment", name: "block" },
+              { kind: "segment", name: "weekly" },
+              { kind: "segment", name: "burnrate" },
+            ],
+          },
+          {
+            kind: "container",
+            direction: "horizontal",
+            children: [
+              { kind: "segment", name: "speed" },
+              { kind: "segment", name: "tokenSparkline" },
+            ],
+          },
+        ],
+      },
+    },
   },
 
   // [LAW:single-enforcer] / [LAW:one-source-of-truth] Display-formatting policy

package/src/config/layout-ops.ts

@@ -0,0 +1,156 @@
+// [LAW:one-type-per-behavior] The seam brandon-layout-edit-2gc.1 opens: a
+// bounded, statically-enumerable vocabulary for mutating a LayoutNode tree —
+// remove the segment named X, insert a named segment before/after an
+// existing one. No third LayoutNode kind, no free-form tree editing: a
+// segment's own NAME is the stable position (dsl-types.ts already makes it
+// one — SegmentNode.name is a ref into `segments`, unaffected by a sibling
+// being added or removed elsewhere in the tree), so there is no sibling-index
+// to invalidate when a prior op lands.
+//
+// [LAW:no-ambient-temporal-coupling] A position is never a fact frozen at
+// declaration or click time — `removeSegment`/`insertSegment` always walk
+// the CURRENT tree handed to them. The daemon (src/daemon/cache/render.ts)
+// replays the accumulated op log against the live merged config on every
+// reload, so a later, unrelated config edit is what the next replay sees,
+// never a stale snapshot.
+//
+// [LAW:no-silent-failure] exception: a target/anchor absent from the tree is
+// a documented NO-OP, not a thrown error — mirroring
+// src/config/loader/merge.ts's applySegmentPaletteOverrides, the identical
+// failure shape one layer up. A validated action can only ever name a
+// segment the config declares (loader/cross-ref.ts checks this at config
+// load), so a miss here only happens after a LATER edit (to the bundled
+// default, the user's config, or an earlier op in the same accumulated list)
+// removed the segment — there is nothing left to apply the op to, and
+// bricking the whole render over a stale op would be worse than dropping it.
+
+import type { LayoutNode, SegmentNode } from "./dsl-types.js";
+
+// [LAW:types-are-the-program] The two operations brandon-layout-edit-2gc.1
+// ships. Both address position by NAME, never by index. A future op (e.g.
+// "move") is a new arm here, not a new node kind or a new codec.
+export type LayoutOp =
+  | { readonly op: "remove"; readonly target: string }
+  | {
+      readonly op: "insert";
+      readonly segment: string;
+      readonly anchor: string;
+      readonly relation: "before" | "after";
+    };
+
+// [LAW:single-enforcer] THE codec for a LayoutOp crossing the click wire and
+// the config-overrides file as one opaque string. `:` is the delimiter
+// (loader/actions.ts's segmentNameSpec rejects `:` and `/` in every name an
+// op can carry, so decode is unambiguous — a plain split, no escaping).
+// Encode and decode live together so the format cannot drift between the
+// validator gate (config-validators.ts, which encodes the ONE token a
+// declared action allows), the render side (which emits that same token),
+// and the daemon (which decodes it back).
+export function encodeLayoutOp(op: LayoutOp): string {
+  return op.op === "remove"
+    ? `remove:${op.target}`
+    : `insert:${op.segment}:${op.anchor}:${op.relation}`;
+}
+
+// [LAW:parse-dont-validate] Returns the typed op, or null for anything that
+// doesn't decode — the boundary a caller stamps before trusting the shape.
+// Reached only from data this process did not itself just encode (a
+// hand-edited or previous-version config-overrides.json), never from a
+// value produced by encodeLayoutOp in the same click.
+export function decodeLayoutOp(token: string): LayoutOp | null {
+  const parts = token.split(":");
+  if (parts[0] === "remove" && parts.length === 2 && parts[1]) {
+    return { op: "remove", target: parts[1] };
+  }
+  if (
+    parts[0] === "insert" &&
+    parts.length === 4 &&
+    parts[1] &&
+    parts[2] &&
+    (parts[3] === "before" || parts[3] === "after")
+  ) {
+    return {
+      op: "insert",
+      segment: parts[1],
+      anchor: parts[2],
+      relation: parts[3],
+    };
+  }
+  return null;
+}
+
+// [LAW:dataflow-not-control-flow] Ops are DATA folded over the tree in
+// order — replaying zero ops is the identity fold, replaying N is the same
+// reduce for every N. No branch on "are there ops to apply."
+export function applyLayoutOps(
+  root: LayoutNode,
+  ops: readonly LayoutOp[],
+): LayoutNode {
+  return ops.reduce(applyOne, root);
+}
+
+function applyOne(root: LayoutNode, op: LayoutOp): LayoutNode {
+  return op.op === "remove"
+    ? removeSegment(root, op.target)
+    : insertSegment(root, op.segment, op.anchor, op.relation);
+}
+
+// [LAW:types-are-the-program] Total and non-throwing: every LayoutNode maps
+// to a LayoutNode, whether or not `target` is present. Acts on the FIRST
+// segment found named `target`, in walkNodes' canonical pre-order — a
+// deterministic, documented tie-break for the edge case of a duplicate name,
+// never an ambiguous or thrown outcome. `done` is a closure-local flag (fresh
+// per call, never shared across calls) that stops the search the instant a
+// match is spliced out, so an EARLIER sibling's match always wins over a
+// LATER one — exactly walkNodes' visit order, not merely "this container's
+// own children before its descendants" (a subtly different, wrong order a
+// single-pass children-array scan would produce). An absent target returns
+// the identical root reference.
+function removeSegment(root: LayoutNode, target: string): LayoutNode {
+  let done = false;
+  function walk(node: LayoutNode): LayoutNode {
+    if (done || node.kind === "segment") return node;
+    const children: LayoutNode[] = [];
+    for (const child of node.children) {
+      if (!done && child.kind === "segment" && child.name === target) {
+        done = true;
+        continue;
+      }
+      children.push(walk(child));
+    }
+    return { ...node, children };
+  }
+  const result = walk(root);
+  return done ? result : root;
+}
+
+// [LAW:types-are-the-program] Splices a new `{ kind: "segment", name:
+// segment }` node immediately before/after the FIRST node found named
+// `anchor`, in walkNodes' canonical pre-order (see removeSegment's `done`
+// note — the same closure-local stop-at-first-match shape). Total and
+// non-throwing: an absent anchor returns the identical root reference.
+function insertSegment(
+  root: LayoutNode,
+  segment: string,
+  anchor: string,
+  relation: "before" | "after",
+): LayoutNode {
+  let done = false;
+  function walk(node: LayoutNode): LayoutNode {
+    if (done || node.kind === "segment") return node;
+    const children: LayoutNode[] = [];
+    for (const child of node.children) {
+      if (!done && child.kind === "segment" && child.name === anchor) {
+        done = true;
+        const inserted: SegmentNode = { kind: "segment", name: segment };
+        if (relation === "before") children.push(inserted, child);
+        else children.push(child, inserted);
+        continue;
+      }
+      children.push(walk(child));
+    }
+    return { ...node, children };
+  }
+  const result = walk(root);
+  return done ? result : root;
+}