@promptctl/cc-candybar 1.26.0 → 1.27.0

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

@@ -26,7 +26,7 @@
 // loader's own synthesis pass (see the bottom of this file) — a `DslConfig`,
 // the same effective shape every user config resolves to.
 
-import type { DslConfig, SegmentDecl } from "./dsl-types.js";
+import type { DslConfig, LayoutNode, SegmentDecl } from "./dsl-types.js";
 import { parseDslConfig } from "./dsl-loader.js";
 import { mergeWithDefault } from "./loader/merge.js";
 
@@ -74,30 +74,111 @@ const DIR_TEMPLATE =
   "{{ end }}{{ end }}" +
   "{{ abbreviatePath $dir }}";
 
-// Git working-tree counts — leading-space-then-trim idiom: each present count
-// contributes " +N", trim drops the leading space, survivors single-spaced.
+// Git-fact → semantic palette color, ONE table both the `git` and
+// `gitaculous` segment templates below read from. [LAW:one-source-of-truth]
+// brandon-segments-3eo.1 (the recoloring itself) typed this choice
+// independently into each template's literal string and the two drifted —
+// gitaculous colored branch `accent` where git used `primary`, and left
+// stash uncolored where git used `accent` — caught by live testing
+// (brandon-segments-3eo.1.1). A shared table makes "what color is this
+// fact" a value read twice, not a decision re-typed twice.
+const GIT_COLOR = {
+  branch: "primary",
+  staged: "success",
+  unstaged: "warning",
+  untracked: "accent",
+  conflicts: "error",
+  ahead: "success",
+  behind: "warning",
+  stash: "accent",
+} as const;
+
+// Paint one git fact in its semantic color. The table above holds palette
+// *variable names* (data), and this is the one place a name becomes a template
+// call, so the fact→color decision and its spelling stay separate concerns.
+// [LAW:one-source-of-truth]
+//
+// Note the shape: `fg (color "…")`, which is also what a composed color looks
+// like — `fg (darken (color "…") 1)`. A template that wants to adjust one of
+// these later wraps the color expression instead of rewriting the call.
+const paint = (fact: keyof typeof GIT_COLOR, content: string): string =>
+  `{{ fg (color "${GIT_COLOR[fact]}") ${content} }}`;
+
+// How far the two git segments' *structural* text — labels, punctuation,
+// brackets, the sha, the upstream name, the elapsed-time annotation — sits
+// toward their own background, as a percentage. It is applied as the segments'
+// `fg:`, so structural text is simply what a token renders as when the
+// template does NOT paint it; only the operative facts (branch, counts,
+// status) name a color. [LAW:dataflow-not-control-flow] — the quiet case is
+// the default that always applies, not a wrapper each token opts into. That
+// inversion is why these templates carry no de-emphasis markup at all.
+//
+// The blend target is the segment's OWN background (`bgOf`), not the theme's
+// `background`. The git segments render on `surface-active`, so a palette
+// `foreground-muted` — which blends toward `background` — would be muted
+// toward a color that is not behind them, and would read either too loud or
+// too faint depending on how far the surface sits from the base.
+//
+// The `readableOn` floor is what makes the result theme-independent, and it is
+// not decoration: the bare 60% blend measures 1.93–3.10 contrast across the
+// bundled themes (catppuccin-latte at 1.93 is genuinely hard to read), because
+// a fixed *percentage* of a distance is not a fixed amount of legibility when
+// themes disagree about how far apart their own foreground and surface sit.
+// Flooring at WCAG's 3:1 large-text threshold lands every theme at 3.00–3.10
+// against full-strength foregrounds of 5.8–10.9 — as quiet as each theme can
+// afford, and never quieter. Verified across the bundled themes in
+// test/default-dsl-config.test.ts rather than eyeballed on one.
+// [LAW:verifiable-goals]
+const GIT_QUIET_PCT = 60;
+const GIT_QUIET_MIN_CONTRAST = 3;
+const GIT_QUIET_FG =
+  `{{ readableOn (mix (color "foreground") (bgOf) ${GIT_QUIET_PCT}) (bgOf) ` +
+  `${GIT_QUIET_MIN_CONTRAST} }}`;
+
+// Git working-tree counts — each present count renders in its own semantic
+// palette color (GIT_COLOR above) so a dirty tree reads at a glance,
+// p10k/gitaculous-prompt style, instead of one uniform segment fg. `$first`
+// tracks whether a separator space is still owed before the next present
+// count.
+// [LAW:dataflow-not-control-flow]: one variable carries the "have we emitted
+// yet" state rather than four copies of positional space logic. `$first` is
+// declared inside the outer `{{ if or ... }}` gate (unlike DIR_TEMPLATE's
+// `$dir`, declared at the template's top level) and reassigned via `=` in
+// nested `{{ if }}` blocks below — Go template variable scoping walks up to
+// the declaring frame on `=` regardless of nesting depth, so this still
+// works, just at one more scope level than DIR_TEMPLATE's `$dir`. Verified
+// by test/default-dsl-config.test.ts's "worktree counts render
+// single-space-separated" test, not merely asserted here.
 const GIT_WORKTREE =
   "{{ if or (gt .git.staged 0) (gt .git.unstaged 0) (gt .git.untracked 0) (gt .git.conflicts 0) }}" +
-  ' ({{ printf "%s%s%s%s"' +
-  ' (ternary (printf " +%v" .git.staged) "" (gt .git.staged 0))' +
-  ' (ternary (printf " ~%v" .git.unstaged) "" (gt .git.unstaged 0))' +
-  ' (ternary (printf " ?%v" .git.untracked) "" (gt .git.untracked 0))' +
-  ' (ternary (printf " !%v" .git.conflicts) "" (gt .git.conflicts 0)) | trim }}){{ end }}';
+  ` ({{ $first := true }}` +
+  `{{ if gt .git.staged 0 }}${paint("staged", '(printf "+%v" .git.staged)')}{{ $first = false }}{{ end }}` +
+  `{{ if gt .git.unstaged 0 }}{{ if not $first }} {{ end }}${paint("unstaged", '(printf "~%v" .git.unstaged)')}{{ $first = false }}{{ end }}` +
+  `{{ if gt .git.untracked 0 }}{{ if not $first }} {{ end }}${paint("untracked", '(printf "?%v" .git.untracked)')}{{ $first = false }}{{ end }}` +
+  `{{ if gt .git.conflicts 0 }}{{ if not $first }} {{ end }}${paint("conflicts", '(printf "!%v" .git.conflicts)')}{{ $first = false }}{{ end }}` +
+  "){{ end }}";
 
-// Status icon precedence: conflicts → ⚠, dirty → ●, else clean ✓.
+// Status icon precedence: conflicts → ⚠ (error), dirty → ● (warning), else
+// clean ✓ (success) — colored to match the state it reports.
 const GIT_STATUS =
-  '{{ if eq .git.status "conflicts" }}⚠{{ else }}' +
-  '{{ if eq .git.status "dirty" }}●{{ else }}✓{{ end }}{{ end }}';
+  '{{ if eq .git.status "conflicts" }}{{ fg (color "error") "⚠" }}{{ else }}' +
+  '{{ if eq .git.status "dirty" }}{{ fg (color "warning") "●" }}' +
+  '{{ else }}{{ fg (color "success") "✓" }}{{ end }}{{ end }}';
 
+// Every unpainted token here — the repo name, `⎇`, `♯`, the sha, the worktree
+// parentheses, `→`, the upstream name — renders in the segment's quiet `fg:`
+// (GIT_QUIET_FG). Only the operative facts name a color, so the template reads
+// as the line it draws rather than as de-emphasis markup wrapped around it.
 const GIT_TEMPLATE =
-  '{{ if ne .git.repoName "" }}{{ .git.repoName }} {{ end }}⎇ {{ .git.branch }}' +
+  '{{ if ne .git.repoName "" }}{{ .git.repoName }} {{ end }}' +
+  `⎇ ${paint("branch", ".git.branch")}` +
   "{{ if .git.sha }} ♯ {{ .git.sha }}{{ end }}" +
   "{{ if or (gt .git.ahead 0) (gt .git.behind 0) }}" +
-  " {{ if gt .git.ahead 0 }}↑{{ .git.ahead }}{{ end }}" +
-  "{{ if gt .git.behind 0 }}↓{{ .git.behind }}{{ end }}{{ end }}" +
+  ` {{ if gt .git.ahead 0 }}${paint("ahead", '(printf "↑%v" .git.ahead)')}{{ end }}` +
+  `{{ if gt .git.behind 0 }}${paint("behind", '(printf "↓%v" .git.behind)')}{{ end }}{{ end }}` +
   GIT_WORKTREE +
   "{{ if .git.upstream }} →{{ .git.upstream }}{{ end }}" +
-  "{{ if gt .git.stash 0 }} ⧇ {{ .git.stash }}{{ end }}" +
+  `{{ if gt .git.stash 0 }} ${paint("stash", '(printf "⧇ %v" .git.stash)')}{{ end }}` +
   " " +
   GIT_STATUS;
 
@@ -146,6 +227,51 @@ function etaHeatFg(etaRef: string, warnRef: string): string {
   );
 }
 
+// ─── The settings drawer (candybar-config-engine-71o.4) ──────────────────────
+
+// [LAW:one-source-of-truth] exception: `kind: "group"` is authoring-grammar
+// sugar the loader lowers at parse time (src/config/loader/layout.ts) —
+// deliberately NOT a member of the canonical LayoutNode union DslConfig.root
+// requires (arranging + gating are behaviors `container` already has; "group"
+// is only a spelling), so a plain `satisfies DslConfig` cannot type-check it
+// inline below. Hand-lowering it here instead (writing the toggle segment +
+// gated body container by hand, under the reserved `groups.` namespace) is
+// NOT an option: reservedNamespaceCollisions rejects any USER-authored
+// variables/actions/segments name starting with `groups.` before synthesis
+// ever runs, so a hand-authored `groups.settings` segment would be rejected
+// as squatting the very namespace it's trying to populate — the sugar node is
+// the only legal way to populate it. This literal is unconditionally
+// round-tripped through the real parseDslConfig pipeline below (see the
+// module-load parse near the bottom of this file) exactly like a user's
+// hand-authored JSON5, so a malformed group is still caught loudly at import
+// 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.
+const settingsDrawer = {
+  kind: "group",
+  name: "settings",
+  label: "⚙ settings",
+  direction: "horizontal",
+  children: [
+    "themeControl",
+    "lookControl",
+    "styleControl",
+    "charsetControl",
+    "colorCompatControl",
+    "wrapToggleControl",
+    "paddingControl",
+    "directoryPaletteControl",
+  ],
+} as unknown as LayoutNode;
+
 // ─── The default config ──────────────────────────────────────────────────────
 
 // [LAW:one-source-of-truth] The AUTHORED literal, pre-synthesis. Production
@@ -229,6 +355,50 @@ export const RAW_DEFAULT_DSL_CONFIG = {
       path: "look.effective",
       default: "",
     },
+    // [LAW:one-type-per-behavior] The effective PRESET name, theme/look's twin
+    // one level up — effectivePresetName(sessionState.preset, globals.preset,
+    // presets), the SAME name that selected the layout this render walked and
+    // the globals it rendered with. A preset-picker trigger reads
+    // `{{ .preset.effective }}` for its label, so the label and the arrangement
+    // trace to one resolution.
+    "preset.effective": {
+      kind: "input",
+      path: "preset.effective",
+      default: "",
+    },
+    // [LAW:one-type-per-behavior] style/charset/colorCompatibility/autoWrap/
+    // padding are theme/look's twins over the remaining persistable globals
+    // (candybar-config-engine-71o.3) — the SAME values BuildLineOptions
+    // renders with, each read back through this projection so a `persist`
+    // action over the field shows a "current selection" highlight and a
+    // trigger label can display the active value without restating it.
+    "style.effective": {
+      kind: "input",
+      path: "style.effective",
+      default: "",
+    },
+    "charset.effective": {
+      kind: "input",
+      path: "charset.effective",
+      default: "",
+    },
+    "colorCompatibility.effective": {
+      kind: "input",
+      path: "colorCompatibility.effective",
+      default: "",
+    },
+    "autoWrap.effective": {
+      kind: "input",
+      path: "autoWrap.effective",
+      type: "boolean",
+      default: true,
+    },
+    "padding.effective": {
+      kind: "input",
+      path: "padding.effective",
+      type: "number",
+      default: 1,
+    },
 
     // [LAW:one-source-of-truth] The usable terminal width for THIS render —
     // the exact post-reserve cell count FlexStrip wraps to. renderDsl injects
@@ -281,6 +451,10 @@ export const RAW_DEFAULT_DSL_CONFIG = {
       path: "git.repoName",
       default: "",
     },
+    // The repo's browsable web page, transposed from its remote by the daemon.
+    // "" is the genuine "no remote a browser can open" (local-only repo, bare
+    // path remote) — the toolbar's link reads that value, not a flag.
+    "git.repoUrl": { kind: "input", path: "git.repoUrl", default: "" },
     "git.branch": { kind: "input", path: "git.branch", default: "" },
     "git.sha": { kind: "input", path: "git.sha", default: "" },
     "git.ahead": {
@@ -609,31 +783,59 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     git: {
       template: GIT_TEMPLATE,
       bg: "surface-active",
-      fg: "foreground",
+      // A computed `fg:` — the field is a template evaluating to a color
+      // reference, and `bgOf` is available here because a segment's background
+      // is resolved before its foreground. Structural text therefore sits a
+      // fixed distance from THIS segment's background whatever theme, look, or
+      // hue shift is in effect.
+      fg: GIT_QUIET_FG,
       when: '{{ ne .git.branch "" }}',
     },
     gitaculous: {
+      // Recolored from raw green/red (render-bugs-pdu.3's era) to semantic
+      // palette names (brandon-segments-3eo.1), then unified against `git`'s
+      // choice of color per fact via the shared GIT_COLOR table above
+      // (brandon-segments-3eo.1.1 — the two had drifted: branch, untracked,
+      // and stash each disagreed with `git`'s coloring of the same fact).
+      // staged/ahead share `success` (positive — ready to commit / unpushed
+      // additions), unstaged/behind share `warning` (needs attention),
+      // untracked/stash share `accent` (their own GIT_COLOR entries, kept
+      // visually distinct from unstaged by using a different glyph, not a
+      // different color, so "U" vs "?" reads apart at a glance), conflicts
+      // gets its own `error`, branch gets `primary`.
+      //
+      // Everything the template does NOT paint — the "(git)" label, repo name,
+      // the operation and upstream brackets, the sha, the elapsed-time
+      // annotation — renders in the segment's quiet `fg:` and recedes, so the
+      // eye lands on the operative colored facts first (brandon-segments-
+      // 3eo.1.1.1: live feedback that "most of it" read as one flat color when
+      // only two facts happened to be present). Note that this needs no markup
+      // in the template — including around `{{ template "formatTimeSince" }}`,
+      // which as a top-level Go-template action could never have been wrapped
+      // in a styling call at all. Making quiet the default rather than a
+      // wrapper is what put that token in reach.
       template:
         "(git)" +
         '{{ if ne .git.repoName "" }} {{ .git.repoName }}{{ end }}' +
         '{{ if ne .git.operation "" }} [{{ .git.operation }}]{{ end }}' +
         '{{ if ne .git.sha "" }} {{ .git.sha }}{{ end }}' +
         "{{ if or (gt .git.staged 0) (gt .git.unstaged 0) (gt .git.untracked 0) (gt .git.conflicts 0) }} " +
-        '{{ if gt .git.staged 0 }}{{ green "S" }}{{ end }}' +
-        '{{ if or (gt .git.unstaged 0) (gt .git.untracked 0) }}{{ red "U" }}{{ end }}' +
-        '{{ if gt .git.conflicts 0 }}{{ red (printf "!%v" .git.conflicts) }}{{ end }}' +
+        `{{ if gt .git.staged 0 }}${paint("staged", '"S"')}{{ end }}` +
+        `{{ if gt .git.unstaged 0 }}${paint("unstaged", '"U"')}{{ end }}` +
+        `{{ if gt .git.untracked 0 }}${paint("untracked", '"?"')}{{ end }}` +
+        `{{ if gt .git.conflicts 0 }}${paint("conflicts", '(printf "!%v" .git.conflicts)')}{{ end }}` +
         "{{ end }}" +
-        " ⎇ {{ .git.branch }}" +
+        ` ⎇ ${paint("branch", ".git.branch")}` +
         '{{ if ne .git.upstream "" }} [{{ .git.upstream }}' +
         "{{ if or (gt .git.ahead 0) (gt .git.behind 0) }} " +
-        '{{ if gt .git.ahead 0 }}{{ green (printf "+%v" .git.ahead) }}{{ end }}' +
+        `{{ if gt .git.ahead 0 }}${paint("ahead", '(printf "+%v" .git.ahead)')}{{ end }}` +
         "{{ if and (gt .git.ahead 0) (gt .git.behind 0) }}/{{ end }}" +
-        '{{ if gt .git.behind 0 }}{{ red (printf "-%v" .git.behind) }}{{ end }}' +
+        `{{ if gt .git.behind 0 }}${paint("behind", '(printf "-%v" .git.behind)')}{{ end }}` +
         "{{ end }}]{{ end }}" +
-        "{{ if gt .git.stash 0 }} ({{ .git.stash }} stashed){{ end }}" +
+        `{{ if gt .git.stash 0 }} ${paint("stash", '(printf "(%v stashed)" .git.stash)')}{{ end }}` +
         '{{ if gt .git.timeSinceCommit 0 }} ◷ {{ template "formatTimeSince" .git.timeSinceCommit }}{{ end }}',
       bg: "surface-active",
-      fg: "foreground",
+      fg: GIT_QUIET_FG,
       when: '{{ ne .git.branch "" }}',
     },
     // Git PR/MR — the branch's open pull/merge request as a clickable link.
@@ -657,18 +859,27 @@ export const RAW_DEFAULT_DSL_CONFIG = {
       when: '{{ or (ne .git.prUrl "") (ne .git.prError "") }}',
     },
     // Quick-action tray — the default bar's interactivity: copy the session id,
-    // open the project dir / transcript (this session's jsonl) in the editor.
+    // open the project dir / transcript (this session's jsonl) in the editor,
+    // and open the repo's web page in the browser.
     // (copyDir — copy the cwd — stays declared as an action below for users who
-    // want a fourth glyph; it is simply not in the default tray.)
+    // want a fifth glyph; it is simply not in the default tray.)
     // [LAW:locality-or-seam] The glyph is the REPRESENTATION; the named action
     // (below) is the BEHAVIOR; the action name is the seam between them. Re-glyph
     // without touching behavior; re-target without touching this template. Each
     // `{{ action … }}` emits one OSC-8 clickable region whose URL the wire codec
     // owns end-to-end.
+    //
+    // `↗ repo` is the one glyph here that is NOT an action: the daemon already
+    // resolved the remote to an https page, so `{{ link }}` hands that URL
+    // straight to the terminal/OS (same seam the gitPr segment uses) — routing a
+    // public web URL through a cc-candybar:// verb would buy nothing. It is
+    // gated on the VALUE (`ne … ""`), not on a flag: a local-only repo simply
+    // supplies no page and the glyph is absent. [LAW:dataflow-not-control-flow]
     toolbar: {
       template:
         '{{ action "copySession" "⎘ id" }}' +
-        ' {{ action "openProject" "↗ proj" }} {{ action "openTranscript" "↗ log" }}',
+        ' {{ action "openProject" "↗ proj" }} {{ action "openTranscript" "↗ log" }}' +
+        '{{ if ne .git.repoUrl "" }} {{ link .git.repoUrl "↗ repo" }}{{ end }}',
       bg: "surface",
       fg: "foreground",
     },
@@ -829,10 +1040,25 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     // render) and stay-open, so shapes can be tried in a row; ▾/✕ collapse.
     // [LAW:dataflow-not-control-flow] No display state from the provider — the
     // label is the one "style" value the click writes and the render reads.
+    // Lives inside the settingsDrawer group (candybar-config-engine-71o.4) — not
+    // on `root` directly — so it renders only while the drawer is open.
+    // The 📌 "make default" menu + ↺ reset, one per control below, is
+    // styleControl/themeControl/lookControl's PERSIST twin (candybar-config-
+    // engine-71o.5) — the exact pairing charsetControl/colorCompatControl/
+    // wrapToggleControl/paddingControl already use, since theme/style/look
+    // are the only three of the drawer's seven knobs with a session `set`
+    // half at all. Its own "pickersForever" accordion key keeps the
+    // persist tier visually distinct from the existing "pickers" try tier
+    // (opening a session preview and opening a "pin as default" picker are
+    // different intents; auto-closing one when the other opens would
+    // conflate them) without touching the already-shipped/tested "pickers"
+    // accordion's membership.
     styleControl: {
       template:
         "✦ {{ if .activeStyle }}{{ .activeStyle }}{{ else }}(default){{ end }} " +
-        '{{ menu "applyStyle" }}',
+        '{{ menu "applyStyle" }} ' +
+        '📌{{ menu "applyStyleForever" (dict "key" "pickersForever") }} ' +
+        '{{ action "resetStyle" "↺" }}',
       bg: "surface",
       fg: "foreground",
     },
@@ -845,11 +1071,16 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     // styleControl (no "effective style" input exists), no extra `state`
     // variable is needed here. Shares the "pickers" accordion key with
     // lookControl so opening one closes the other, the docs' canonical
-    // two-menu pairing.
+    // two-menu pairing. Moved inside the settingsDrawer group
+    // (candybar-config-engine-71o.4) alongside style/look/charset/
+    // colorCompatibility/autoWrap/padding — one collapsed home for every
+    // bar-mutable display default, instead of its own always-on row.
     themeControl: {
       template:
         "🎨 {{ .theme.effective }} " +
-        '{{ menu "applyTheme" (dict "key" "pickers") }}',
+        '{{ menu "applyTheme" (dict "key" "pickers") }} ' +
+        '📌{{ menu "applyThemeForever" (dict "key" "pickersForever") }} ' +
+        '{{ action "resetTheme" "↺" }}',
       bg: "surface",
       fg: "foreground",
     },
@@ -862,7 +1093,73 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     lookControl: {
       template:
         "◐ {{ .look.effective }} " +
-        '{{ menu "applyLook" (dict "key" "pickers" "closeOnPick" true) }}',
+        '{{ menu "applyLook" (dict "key" "pickers" "closeOnPick" true) }} ' +
+        '📌{{ menu "applyLookForever" (dict "key" "pickersForever" "closeOnPick" true) }} ' +
+        '{{ action "resetLook" "↺" }}',
+      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
+    // convention) — these four have no SessionState half at all, so persist
+    // is their only seam, unlike theme/style/look's session `set`. Labels
+    // read `.field.effective` (the daemon-resolved value BuildLineOptions
+    // actually rendered with), never a restated literal.
+    charsetControl: {
+      template:
+        "{{ .charset.effective }} " +
+        '{{ menu "applyCharsetForever" }} {{ action "resetCharset" "↺" }}',
+      bg: "surface",
+      fg: "foreground",
+    },
+    colorCompatControl: {
+      template:
+        "{{ .colorCompatibility.effective }} " +
+        '{{ menu "applyColorCompatForever" }} {{ action "resetColorCompat" "↺" }}',
+      bg: "surface",
+      fg: "foreground",
+    },
+    wrapToggleControl: {
+      template:
+        '{{ action "toggleWrapForever" "wrap: on" "wrap: off" }} ' +
+        '{{ action "resetAutoWrap" "↺" }}',
+      bg: "surface",
+      fg: "foreground",
+    },
+    paddingControl: {
+      template:
+        '{{ action "paddingDownForever" "◀" }} padding {{ .padding.effective }} ' +
+        '{{ action "paddingUpForever" "▶" }} {{ action "resetPadding" "↺" }}',
+      bg: "surface",
+      fg: "foreground",
+    },
+    // [LAW:verifiable-goals] candybar-config-engine-71o.6's own acceptance
+    // bar, mirrored from .3/.5: at least ONE segment-scoped field must be
+    // menu-able from the BUNDLED default with no hand-authored actions.
+    // `directory` is the demo target — always visible, palette-driven
+    // bg/fg, so an override is immediately legible. The persist/reset pair
+    // below targets `segments.directory.palette` (not a Globals field),
+    // proving the option-domain-as-data seam generalizes to segment-scoped
+    // keys with zero engine edits beyond opening the key namespace itself
+    // (loader/persist-target.ts) — the SAME `from: "themes"` domain
+    // applyThemeForever already uses.
+    // [LAW:one-source-of-truth] exception: unlike charsetControl/
+    // paddingControl's `.field.effective` label, there is no
+    // `segments.directory.palette.effective` payload projection — adding one
+    // would require threading the full DslConfig through
+    // buildRenderPayload's signature (today built from EffectiveGlobals
+    // alone), a change with no other motivation than this one label. The
+    // control still writes/persists/resets correctly without it: per
+    // render/action.ts's CONFIG_KEY_TO_EFFECTIVE_VAR, a persist key with no
+    // effective-var entry writes fine and only loses the picker's "current
+    // selection" highlight — a documented, already-accepted degrade path,
+    // not a bug.
+    directoryPaletteControl: {
+      template:
+        "🎨 directory " +
+        '{{ menu "applyDirectoryPaletteForever" }} ' +
+        '{{ action "resetDirectoryPalette" "↺" }}',
       bg: "surface",
       fg: "foreground",
     },
@@ -870,23 +1167,24 @@ export const RAW_DEFAULT_DSL_CONFIG = {
 
   // Default layout — the canonical LayoutNode tree (`satisfies DslConfig`
   // requires the lowered form here; the terse Option-A `{ h/v/seg }` grammar is
-  // the loader's authoring surface for user JSON, not this typed literal).
+  // the loader's authoring surface for user JSON, not this typed literal — the
+  // one exception being `settingsDrawer` above, whose `kind: "group"` sugar has
+  // no canonical-form equivalent it could be hand-lowered to; see its own
+  // comment).
   //
-  // Three rows stacked by the vertical container: an IDENTITY + ACTIONS row
-  // (where am I / what can I do here — the directory, the verbose `gitaculous`
-  // line (repo, sha, working-tree, upstream, stash, time-since-commit), then the
-  // quick-action tray: copy session id, open project / transcript in the editor)
-  // over a STATUS row (what's happening now — model, context-window fill,
-  // prompt-cache warmth, and the 5h / 7d rate-limit quotas) over an APPEARANCE
-  // row (theme + look pickers, brandon-theming-8uj.1 — the bundled default's
-  // only on-bar affordance to discover and use the theme/look feature without
-  // reading docs or hand-authoring a config). The tray sits on the identity
-  // row because its actions are workspace-scoped (this session, this
-  // project), not usage metrics; the pickers get their own row rather than
-  // crowding the identity row because a `{{ menu }}` drops its picker body
-  // onto the line immediately below its row, and that drop must not land on
-  // top of an unrelated row's content. Each row zips its segments through the
-  // powerline joiner; `\n` separates the rows.
+  // Two always-visible rows stacked by the vertical container: an IDENTITY +
+  // ACTIONS row (where am I / what can I do here — the directory, the verbose
+  // `gitaculous` line, the quick-action tray: copy session id, open project /
+  // transcript in the editor, and the settingsDrawer toggle) over a STATUS row
+  // (what's happening now — model, context-window fill, prompt-cache warmth,
+  // and the 5h / 7d rate-limit quotas). The settingsDrawer (candybar-config-
+  // engine-71o.4) sits on the identity row beside the tray — collapsed by
+  // default and visually silent (a single "⚙ settings ▸" cell) — and reveals a
+  // third row of every bar-mutable display default (theme, style, look,
+  // charset, colorCompatibility, autoWrap, padding) on the line immediately
+  // below row 1 when opened, exactly where a `{{ menu }}`'s own picker body
+  // would drop. Each row zips its segments through the powerline joiner; `\n`
+  // separates the rows.
   //
   // [LAW:dataflow-not-control-flow] Every status segment is when-gated on its
   // own signal (no repo → the identity row is just the directory + tray; no
@@ -906,6 +1204,7 @@ export const RAW_DEFAULT_DSL_CONFIG = {
           { kind: "segment", name: "directory" },
           { kind: "segment", name: "gitaculous" },
           { kind: "segment", name: "toolbar" },
+          settingsDrawer,
         ],
       },
       {
@@ -919,14 +1218,6 @@ export const RAW_DEFAULT_DSL_CONFIG = {
           { kind: "segment", name: "weekly" },
         ],
       },
-      {
-        kind: "container",
-        direction: "horizontal",
-        children: [
-          { kind: "segment", name: "themeControl" },
-          { kind: "segment", name: "lookControl" },
-        ],
-      },
     ],
   },
 
@@ -972,6 +1263,63 @@ 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-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.
+    applyThemeForever: { persist: "palette", from: "themes" },
+    resetTheme: { reset: "palette" },
+    applyStyleForever: { persist: "style", from: "styles" },
+    resetStyle: { reset: "style" },
+    applyLookForever: { persist: "look", from: "looks" },
+    resetLook: { reset: "look" },
+
+    // [LAW:locality-or-seam] The settings-drawer steppers' behaviors
+    // (candybar-config-engine-71o.4), decoupled by NAME from
+    // charsetControl/colorCompatControl/wrapToggleControl/paddingControl
+    // below. Unlike theme/style/look (a per-session experiment via `set`),
+    // these four have no SessionState half at all — .3's handoff established
+    // `persist` as their ONLY seam — so every one of these writes the
+    // config-file DEFAULT through the daemon-owned overrides layer (never the
+    // hand-authored file itself), gated by the SAME deriveActionValidators
+    // pass as a `set` (persist mirrors set's value-source shapes one for
+    // one). Each is paired with a `reset` so a drawer choice is always
+    // undoable from the bar, per the docs' persist/reset convention.
+    applyCharsetForever: { persist: "charset", from: "charsets" },
+    resetCharset: { reset: "charset" },
+    applyColorCompatForever: {
+      persist: "colorCompatibility",
+      from: "colorCompatibilities",
+    },
+    resetColorCompat: { reset: "colorCompatibility" },
+    toggleWrapForever: { persist: "autoWrap", cycle: ["true", "false"] },
+    resetAutoWrap: { reset: "autoWrap" },
+    paddingDownForever: { persist: "padding", min: 0, max: 16, by: -1 },
+    paddingUpForever: { persist: "padding", min: 0, max: 16, by: 1 },
+    resetPadding: { reset: "padding" },
+
+    // [LAW:locality-or-seam] The segment-palette control's behavior
+    // (candybar-config-engine-71o.6), decoupled by NAME from
+    // directoryPaletteControl below. The target key is `segments.directory.
+    // palette` — NOT a Globals field — so it rides the SAME generic
+    // `from`/`reset` machinery every other persist pair here uses, over a
+    // key namespace loader/persist-target.ts opened alongside the pre-
+    // existing Globals-field one. Like the four .3 steppers, this field has
+    // no SessionState half at all: a per-segment `palette:` is a static pin
+    // that ignores the session theme by design (src/dsl/render.ts), so
+    // `persist` is its only seam.
+    applyDirectoryPaletteForever: {
+      persist: "segments.directory.palette",
+      from: "themes",
+    },
+    resetDirectoryPalette: { reset: "segments.directory.palette" },
   },
 
   // ─── Looks ───────────────────────────────────────────────────────────────
@@ -1028,6 +1376,27 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     },
   },
 
+  // ─── Presets ─────────────────────────────────────────────────────────────
+  // 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.
+  // [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.
+  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.
+    default: {},
+  },
+
   // [LAW:single-enforcer] / [LAW:one-source-of-truth] Display-formatting policy
   // for the cost/token/budget family lives here as named template helpers, each
   // DEFINED ONCE and called from every segment via `{{ template "name" .arg }}`