@promptctl/cc-candybar 1.38.0 → 1.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/cc-candybar",
-  "version": "1.38.0",
+  "version": "1.40.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.38.0",
-    "@promptctl/cc-candybar-darwin-x64": "1.38.0",
-    "@promptctl/cc-candybar-linux-x64": "1.38.0",
-    "@promptctl/cc-candybar-linux-arm64": "1.38.0"
+    "@promptctl/cc-candybar-darwin-arm64": "1.40.0",
+    "@promptctl/cc-candybar-darwin-x64": "1.40.0",
+    "@promptctl/cc-candybar-linux-x64": "1.40.0",
+    "@promptctl/cc-candybar-linux-arm64": "1.40.0"
   }
 }

package/schema/cc-candybar.schema.json

@@ -1648,7 +1648,7 @@
               },
               "preset": {
                 "not": {},
-                "description": "not allowed inside a preset — a preset cannot select a preset"
+                "description": "not allowed here — a preset cannot select a preset"
               },
               "style": {
                 "enum": [
@@ -1686,6 +1686,66 @@
         "additionalProperties": false
       }
     },
+    "editGlobals": {
+      "type": "object",
+      "properties": {
+        "default_bg": {
+          "type": "string"
+        },
+        "default_fg": {
+          "type": "string"
+        },
+        "default_empty_value": {
+          "type": "string"
+        },
+        "default_separator": {
+          "type": "string"
+        },
+        "default_truncate_marker": {
+          "type": "string"
+        },
+        "palette": {
+          "type": "string"
+        },
+        "look": {
+          "type": "string"
+        },
+        "preset": {
+          "not": {},
+          "description": "not allowed here — the editGlobals fragment cannot select a preset"
+        },
+        "style": {
+          "enum": [
+            "powerline",
+            "capsule",
+            "plain"
+          ]
+        },
+        "autoWrap": {
+          "type": "boolean"
+        },
+        "padding": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 16
+        },
+        "charset": {
+          "enum": [
+            "unicode",
+            "ascii"
+          ]
+        },
+        "colorCompatibility": {
+          "enum": [
+            "truecolor",
+            "256",
+            "ansi",
+            "none"
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
     "helpers": {
       "type": "object",
       "additionalProperties": {

package/src/check.ts

@@ -31,21 +31,12 @@ import { SourceRegistry } from "./var-system/sources.js";
 import { SessionState } from "./daemon/session-state.js";
 import { registerDslConfig, renderDsl } from "./dsl/render.js";
 import { deriveActionValidators } from "./daemon/verbs/state-validators.js";
-import {
-  effectiveThemeName,
-  effectiveLookName,
-  lookKeyByName,
-  effectiveStripStyle,
-  effectiveAutoWrap,
-  effectivePadding,
-} from "./themes/policy.js";
+import { lookKeyByName } from "./themes/policy.js";
 import { paletteForThemeName } from "./themes/palette-resolvers.js";
-import { effectivePresetName, presetGlobals } from "./config/presets.js";
 import {
-  DEFAULT_CHARSET,
-  DEFAULT_COLOR_COMPATIBILITY,
-} from "./render/strip.js";
-import type { EffectiveGlobals } from "./daemon/render-payload.js";
+  resolveEffectiveGlobals,
+  type EffectiveGlobals,
+} from "./daemon/render-payload.js";
 
 // [LAW:no-ambient-temporal-coupling] A fixed width keeps the verdict a function
 // of the config alone, not of whichever terminal invoked the check. Templates
@@ -302,14 +293,13 @@ function loadRegisterRender(
     // globals feed every field below, the SAME order the daemon resolves in
     // (server.ts) — so `check` renders the arrangement a fresh session actually
     // opens in, not the config's un-presetted root.
-    const preset = effectivePresetName(
-      null,
-      config.globals.preset,
-      config.presets,
-    );
-    const globals = presetGlobals(config, preset);
-    const effective: EffectiveGlobals = {
-      preset,
+    const effective: EffectiveGlobals = resolveEffectiveGlobals(
+      config,
+      // A fresh session: no clicked theme/style/look, and edit mode off. The
+      // resolution is THE daemon's (resolveEffectiveGlobals), not a copy that
+      // agrees with it today — which is the whole reason check renders what the
+      // daemon would render rather than something adjacent.
+      () => null,
       // [LAW:no-silent-failure] `check` validates a config file in isolation
       // — it never reads the daemon-owned overrides file, so there is no
       // rootOps log to be customized BY. false is the honest value for THIS
@@ -317,16 +307,8 @@ function loadRegisterRender(
       // has never customized anything. A second render pass below also
       // exercises `true`, so a `.preset.customized`-gated segment still
       // gets checked — just not through this value.
-      presetCustomized: false,
-      theme: effectiveThemeName(null, globals.palette),
-      look: effectiveLookName(null, globals.look, config.looks),
-      style: effectiveStripStyle(null, globals.style),
-      autoWrap: effectiveAutoWrap(null, globals.autoWrap),
-      padding: effectivePadding(null, globals.padding),
-      charset: globals.charset ?? DEFAULT_CHARSET,
-      colorCompatibility:
-        globals.colorCompatibility ?? DEFAULT_COLOR_COMPATIBILITY,
-    };
+      () => false,
+    );
     // [LAW:no-silent-failure] A segment whose template THROWS while evaluating
     // (an `{{ action }}` display-arity mismatch, a MissingFieldError from a
     // partially-declared variable) renders as a visible ⚠ error cell — partial
@@ -352,6 +334,7 @@ function loadRegisterRender(
         paletteForThemeName(payloadEffective.theme),
         {
           style: payloadEffective.style,
+          separator: payloadEffective.separator,
           width: CHECK_WIDTH,
           colorCompatibility: payloadEffective.colorCompatibility,
           wrap: payloadEffective.autoWrap,

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

@@ -28,6 +28,14 @@
 
 import type { DslConfig, LayoutNode, SegmentDecl } from "./dsl-types.js";
 import { parseDslConfig } from "./dsl-loader.js";
+// [LAW:one-source-of-truth] The bundled drawer's menus author their own
+// disclosure glyphs now that `{{ menu }}` appends none. Interpolating the
+// shared constants keeps the stdlib bar reading like every other disclosure
+// without restating the vocabulary in three string literals.
+import {
+  DISCLOSURE_GLYPH_CLOSED,
+  DISCLOSURE_GLYPH_OPEN,
+} from "./disclosure.js";
 import { mergeWithDefault } from "./loader/merge.js";
 
 // ─── Shared template fragments ───────────────────────────────────────────────
@@ -1133,14 +1141,16 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     charsetControl: {
       template:
         "{{ .charset.effective }} " +
-        '{{ menu "applyCharsetForever" }} {{ action "resetCharset" "↺" }}',
+        `{{ menu "applyCharsetForever" "${DISCLOSURE_GLYPH_CLOSED}" "${DISCLOSURE_GLYPH_OPEN}" }} ` +
+        '{{ action "resetCharset" "↺" }}',
       bg: "surface",
       fg: "foreground",
     },
     colorCompatControl: {
       template:
         "{{ .colorCompatibility.effective }} " +
-        '{{ menu "applyColorCompatForever" }} {{ action "resetColorCompat" "↺" }}',
+        `{{ menu "applyColorCompatForever" "${DISCLOSURE_GLYPH_CLOSED}" "${DISCLOSURE_GLYPH_OPEN}" }} ` +
+        '{{ action "resetColorCompat" "↺" }}',
       bg: "surface",
       fg: "foreground",
     },
@@ -1168,7 +1178,7 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     directoryPaletteControl: {
       template:
         "🎨 directory " +
-        '{{ menu "applyDirectoryPaletteForever" }} ' +
+        `{{ menu "applyDirectoryPaletteForever" "${DISCLOSURE_GLYPH_CLOSED}" "${DISCLOSURE_GLYPH_OPEN}" }} ` +
         '{{ action "resetDirectoryPalette" "↺" }}',
       bg: "surface",
       fg: "foreground",
@@ -1465,6 +1475,24 @@ export const RAW_DEFAULT_DSL_CONFIG = {
     },
   },
 
+  // [LAW:one-source-of-truth] What edit mode LOOKS like, as config a user can
+  // retune — the whole point of candybar-settings-ui-aok.5, whose predecessor
+  // was renderer constants. Powerline chrome exists to make adjacent segments
+  // read as one continuous strip, which is precisely the wrong signal while a
+  // user is trying to see where one segment ends and the next begins; `plain`
+  // trades the caps for a visible separator between every cell.
+  //
+  // The separator is stated rather than left to PlainJoiner's own default: this
+  // fragment layers over the user's globals, so a config that set
+  // `default_separator` for its own powerline bar would otherwise carry that
+  // choice into edit mode, where the separator is the entire affordance. " | "
+  // (not "│") because it must survive `charset: "ascii"` — the fragment does
+  // not, and should not, know the terminal's glyph coverage.
+  editGlobals: {
+    style: "plain",
+    default_separator: " | ",
+  },
+
   // [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 }}`

package/src/config/disclosure.ts

@@ -32,9 +32,63 @@ export const DISCLOSURE_CLOSED = "closed";
 // [LAW:representation] The disclosure glyph vocabulary — one pair for the whole
 // bar so every disclosure reads the same (trailing the label/content it gates,
 // per pdu.8): collapsed ▸, expanded ▾.
+//
+// [LAW:one-source-of-truth] These are the AUTHORED default, never an emission.
+// Every disclosure splices them into the template it synthesizes — group sugar
+// (loader/layout.ts), the settings menu (settings-menu.ts), the bundled drawer
+// — and a hand-authored config writes whichever glyph it likes, because the
+// trigger's text is a display bound at the call site like any other. Until
+// candybar-settings-ui-aok.4 `{{ menu }}` was the exception, appending ▸/▾ from
+// its own runtime where no author could see or decline it, which is how edit
+// mode's `+` came to render `+▸`.
 export const DISCLOSURE_GLYPH_CLOSED = "▸";
 export const DISCLOSURE_GLYPH_OPEN = "▾";
 
+// [LAW:one-source-of-truth] The glyph that CLOSES an open disclosure. The
+// picker body's ✕ has always been this; it lives here now because a trigger can
+// wear it too — edit mode's `+` does, since a `+` whose only open-state cue was
+// the ▸ this change removed would otherwise be indistinguishable from its
+// siblings (three insertion points render byte-identically when one is open,
+// and their dropped bodies are identical too, so row 0 is the only place the
+// answer can live). Two affordances, one meaning, one glyph.
+export const DISCLOSURE_GLYPH_CLOSE = "✕";
+
+// [LAW:single-enforcer] THE display rule every multi-state trigger obeys: bind
+// one display per member, or ONE static display that shows in every state. It
+// lives here, beside the toggle machinery, because both disclosure kinds need
+// it at different times — the loader can count a call's arguments statically
+// and wants an ISSUE to report, the renderer holds the evaluated displays and
+// wants to THROW — and a rule spelled once in each place is a rule that drifts.
+// A `{{ menu }}` folds through it with two members (its `[closed, member]`
+// cycle) and a cycle `{{ action }}` with as many as it declares; nothing about
+// the rule is disclosure-specific beyond who calls it.
+export function cycleDisplayIssue(
+  subject: string,
+  count: number,
+  members: number,
+): string | undefined {
+  if (count === 0) return `${subject} needs a display (the clickable text)`;
+  if (count !== 1 && count !== members) {
+    return `${subject} cycles ${members} members; bind one display per member (${members}) or one static display, got ${count}`;
+  }
+  return undefined;
+}
+
+// [LAW:dataflow-not-control-flow] Which display shows is a pure function of
+// (bound displays, current member index): a single static display shows in
+// every state, per-member displays index by the state. Throws the one rule's
+// text rather than silently dropping or repeating an argument.
+export function pickCycleDisplay(
+  subject: string,
+  displays: readonly string[],
+  members: number,
+  index: number,
+): string {
+  const issue = cycleDisplayIssue(subject, displays.length, members);
+  if (issue !== undefined) throw new Error(issue);
+  return displays.length === 1 ? displays[0]! : displays[index]!;
+}
+
 // [LAW:single-enforcer] THE backing `state` variable a disclosure key implies:
 // it holds the open member's name and defaults to `def` (the CLOSED sentinel for
 // an independent disclosure, or an initially-open member for a group's

package/src/config/dsl-loader.ts

@@ -43,7 +43,7 @@ import {
   type ValidateCtx,
 } from "./loader/validate-core.js";
 import { mergeWithDefault } from "./loader/merge.js";
-import { validateGlobals } from "./loader/globals.js";
+import { validateEditGlobals, validateGlobals } from "./loader/globals.js";
 import { validateVariables } from "./loader/variables.js";
 import { validateSegments } from "./loader/segments.js";
 import { synthesizeGroupDecls, validateRoot } from "./loader/layout.js";
@@ -280,6 +280,12 @@ function validateTopLevel(
   // was staged from.
   if (raw.presets !== undefined)
     out.presets = validatePresets(ctx, raw.presets);
+  // [LAW:one-type-per-behavior] Edit mode's staged display globals — the same
+  // fragment shape a preset carries, one rung later in the precedence chain, so
+  // it runs through the same field table (validateEditGlobals) rather than a
+  // parallel schema listing which globals edit mode may set.
+  if (raw.editGlobals !== undefined)
+    out.editGlobals = validateEditGlobals(ctx, "editGlobals", raw.editGlobals);
   if (raw.helpers !== undefined)
     out.helpers = validateHelpers(ctx, raw.helpers);
   // [LAW:one-source-of-truth] Group sugar synthesis runs AFTER every section
@@ -328,5 +334,6 @@ const TOP_LEVEL_KEYS = new Set([
   "actions",
   "looks",
   "presets",
+  "editGlobals",
   "helpers",
 ]);

package/src/config/dsl-types.ts

@@ -172,6 +172,9 @@ export interface RawDslConfig {
   // arrangement selected per session, the exact twin of `looks` one level up
   // (a look adapts the THEME; a preset adapts the LAYOUT + display globals).
   readonly presets?: Readonly<Record<string, PresetDecl>>;
+  // The display globals edit mode stages while it is on — see DslConfig's own
+  // `editGlobals` for the shape, the merge, and where it sits in the chain.
+  readonly editGlobals?: Partial<Globals>;
   // Named theme-adaptation bundles ("looks"): each is a full ThemeKey (the
   // loader normalizes absent axes to identity at parse). Applied ON TOP of the
   // active theme at render — a transform composing with every theme, selected
@@ -216,6 +219,26 @@ export interface DslConfig {
   // `{ set: …, from: "presets" }` ranges these names; the derived click gate and
   // the rendered options read this one map.
   readonly presets: Readonly<Record<string, PresetDecl>>;
+  // [LAW:one-source-of-truth] The display globals edit mode stages while it is
+  // on — the `globals` half of the fragment whose `root` half edit chrome
+  // already stages (src/config/edit-chrome.ts). Merges FIELD BY FIELD with the
+  // bundled default's (like `globals` itself, not wholesale like `root`), so a
+  // user retuning the separator keeps the bundled `style: "plain"`.
+  //
+  // [LAW:types-are-the-program] `Partial<Globals>`, deliberately NOT
+  // `PresetDecl`: a preset is root + globals, and edit mode needs only the
+  // globals half. Taking the wider type to use half of it would make "an edit
+  // fragment that restages the layout" representable — a second authority over
+  // a tree edit-chrome already owns. The loader additionally rejects `preset`
+  // inside it, for the same reason a preset may not select a preset.
+  //
+  // Its rung in the precedence chain is the RIGHTMOST one (see
+  // src/config/presets.ts): it outranks even a session pick, because entering
+  // edit mode is decided later than picking a style. Nothing writes it back to
+  // SessionState or the overrides layer, which is why leaving edit mode
+  // restores the previous look with no save/restore path
+  // [LAW:dataflow-not-control-flow].
+  readonly editGlobals: Partial<Globals>;
   // [LAW:single-enforcer] The effective helper set: a name → template-body map
   // compiled to a defines-preamble at registerDslConfig. Empty when no config
   // declares helpers — an absent `helpers` key merges to `{}` (same cascade as

package/src/config/edit-chrome.ts

@@ -50,6 +50,7 @@ import {
 } from "./menu-keys.js";
 import {
   DISCLOSURE_CLOSED,
+  DISCLOSURE_GLYPH_CLOSE,
   disclosureCycleAction,
   disclosureStateVar,
 } from "./disclosure.js";
@@ -211,8 +212,21 @@ function insertChrome(
   artifacts.actions[identity] = disclosureCycleAction(stateKey, member);
   artifacts.actions[pageKey] = { set: pageKey, int: true };
 
+  // The `+` IS the trigger — no appended arrow (candybar-settings-ui-aok.4).
+  // Beside a `-` that means something else entirely, a ▸ read as part of the
+  // affordance rather than as a disclosure hint, so the trigger names the ACTION
+  // its click performs instead: `+` inserts here, `✕` closes what `+` opened —
+  // the same glyph, and the same effect, as the body's own close cell.
+  //
+  // [LAW:no-silent-failure] It is deliberately NOT one static display. A preset
+  // has N insertion points whose rendered rows are byte-identical, and their
+  // dropped bodies are identical too — so with no per-state display, an open `+`
+  // is indistinguishable from the two beside it and the bar silently stops
+  // answering "which one did I open". The tint that marks other open menus
+  // (node-registry's `drops.length > 0`) cannot answer it either: this segment
+  // declares no bg, so there is nothing to tint.
   artifacts.segments[chromeSegName] = {
-    template: `+{{ menu "${applyName}" }}`,
+    template: `{{ menu "${applyName}" "+" "${DISCLOSURE_GLYPH_CLOSE}" }}`,
     when: EDIT_MODE_GATE,
   };
   return { kind: "segment", name: chromeSegName };

package/src/config/loader/emit-schema.ts

@@ -12,7 +12,7 @@
 // cycles. Those stay SEMANTIC checks the loader carries — schema = shape, lint =
 // meaning, the same complementary boundary `config-schema.test.ts` pins.
 
-import { globalsJson } from "./globals.js";
+import { editGlobalsJson, globalsJson } from "./globals.js";
 import { variablesMapJson } from "./variables.js";
 import { segmentsJson } from "./segments.js";
 import { actionsJson } from "./actions.js";
@@ -50,6 +50,7 @@ export function emitConfigSchema(): JsonNode {
       actions: actionsJson(),
       looks: looksJson(),
       presets: presetsJson(),
+      editGlobals: editGlobalsJson(),
       helpers: { type: "object", additionalProperties: { type: "string" } },
     },
     definitions: {

package/src/config/loader/globals.ts

@@ -104,43 +104,63 @@ const GLOBALS_SCHEMA: RecordSchema<Globals> = {
   fields: GLOBALS_FIELDS,
 };
 
-// [LAW:one-source-of-truth] A preset's `globals` may not carry `preset`: which
-// preset is active has exactly one authority (session pick over globals.preset
-// over the floor), and a preset re-selecting a preset would be a second one —
-// a cyclic second one. Same species of bespoke, migration-pointing rejection as
+// [LAW:one-source-of-truth] A globals FRAGMENT — a delta layered over the
+// config's own globals at render time — may not carry `preset`: which preset is
+// active has exactly one authority (session pick over globals.preset over the
+// floor), and a fragment re-selecting a preset would be a second one. For a
+// preset's own fragment that second authority is also cyclic; for edit mode's
+// it would let a look-only fragment restage the whole layout, which edit chrome
+// already owns. Same species of bespoke, migration-pointing rejection as
 // colorCompatibility's "auto" above, and for the same reason: an author who
 // writes it deserves to be told WHY, not handed a bare unknown-key message.
-const nestedPresetSpec: FieldSpec<string> = {
-  required: false,
-  // Always-fail: JSON Schema's `not: {}` matches nothing, so an editor flags
-  // the key at the same moment the validator does.
-  json: {
-    not: {},
-    description:
-      "not allowed inside a preset — a preset cannot select a preset",
-  },
-  parse: (ctx, path, field, raw) => {
-    if (raw[field] !== undefined) {
-      ctx.issues.push({
-        path: `${path}.${field}`,
-        message:
-          `${path}.${field}: a preset cannot select a preset. Which preset is active is ` +
-          `resolved once, as session pick over globals.preset over "default"; a preset ` +
-          `naming another would be a second authority over that, and a cyclic one. ` +
-          `Set the default arrangement in the top-level globals.preset instead.`,
-        line: findKeyLine(ctx.source, [...path.split("."), field]),
-      });
-    }
-    return undefined;
-  },
-};
+//
+// [LAW:one-type-per-behavior] Both fragments reject the field identically and
+// differ only in the SUBJECT a diagnostic names, so this is one spec taking
+// that noun as data — never two specs that could drift in what they reject.
+function nestedPresetSpec(subject: string): FieldSpec<string> {
+  return {
+    required: false,
+    // Always-fail: JSON Schema's `not: {}` matches nothing, so an editor flags
+    // the key at the same moment the validator does.
+    json: {
+      not: {},
+      description: `not allowed here — ${subject} cannot select a preset`,
+    },
+    parse: (ctx, path, field, raw) => {
+      if (raw[field] !== undefined) {
+        ctx.issues.push({
+          path: `${path}.${field}`,
+          message:
+            `${path}.${field}: ${subject} cannot select a preset. Which preset is active is ` +
+            `resolved once, as session pick over globals.preset over "default"; a fragment ` +
+            `naming another would be a second authority over that. ` +
+            `Set the default arrangement in the top-level globals.preset instead.`,
+          line: findKeyLine(ctx.source, [...path.split("."), field]),
+        });
+      }
+      return undefined;
+    },
+  };
+}
 
-// [LAW:one-source-of-truth] The preset-scoped globals schema is the SAME field
-// table with exactly one field swapped for its rejection — not a hand-listed
-// subset that a future globals field could be forgotten from.
+// [LAW:one-source-of-truth] Each fragment-scoped globals schema is the SAME
+// field table with exactly one field swapped for its rejection — not a
+// hand-listed subset that a future globals field could be forgotten from.
 const PRESET_GLOBALS_SCHEMA: RecordSchema<Globals> = {
   noun: "preset globals key",
-  fields: { ...GLOBALS_FIELDS, preset: nestedPresetSpec },
+  fields: { ...GLOBALS_FIELDS, preset: nestedPresetSpec("a preset") },
+};
+
+// [LAW:one-type-per-behavior] Edit mode's staged globals are the same shape one
+// rung later in the precedence chain, so they reuse the same table rather than
+// declaring which fields edit mode "supports" — a field added to Globals is
+// edit-settable the same day, with no edit here.
+const EDIT_GLOBALS_SCHEMA: RecordSchema<Globals> = {
+  noun: "editGlobals key",
+  fields: {
+    ...GLOBALS_FIELDS,
+    preset: nestedPresetSpec("the editGlobals fragment"),
+  },
 };
 
 // An absent globals block is the empty default (no issue); a non-object is a
@@ -177,6 +197,20 @@ export function presetGlobalsJson(): JsonNode {
   return recordJson(PRESET_GLOBALS_SCHEMA);
 }
 
+// Edit mode's twin of the two above: same interpreter, same field table, the
+// schema whose `preset` rejection names the editGlobals fragment.
+export function validateEditGlobals(
+  ctx: ValidateCtx,
+  path: string,
+  raw: unknown,
+): Globals {
+  return record(ctx, EDIT_GLOBALS_SCHEMA, path, raw) ?? {};
+}
+
+export function editGlobalsJson(): JsonNode {
+  return recordJson(EDIT_GLOBALS_SCHEMA);
+}
+
 // [LAW:one-source-of-truth] THE membership check for "is this a real Globals
 // field" — derived from GLOBALS_SCHEMA.fields, the same declaration
 // validateGlobals/globalsJson interpret, so a `persist`/`reset` action's