@promptctl/cc-candybar 1.39.0 → 1.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/cc-candybar",
-  "version": "1.39.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.39.0",
-    "@promptctl/cc-candybar-darwin-x64": "1.39.0",
-    "@promptctl/cc-candybar-linux-x64": "1.39.0",
-    "@promptctl/cc-candybar-linux-arm64": "1.39.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

@@ -1475,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/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/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

package/src/config/loader/merge.ts

@@ -53,6 +53,12 @@ export function mergeWithDefault(
     // (incl. the "default" empty-fragment floor effectivePresetName collapses
     // to) survives every merge by construction, exactly as looks' "none" does.
     presets: { ...dflt.presets, ...(raw.presets ?? {}) },
+    // [LAW:one-source-of-truth] editGlobals merges FIELD by field — the
+    // `globals` cascade above, not the by-name cascades around it, because it
+    // IS a globals fragment: a user retuning edit mode's separator says nothing
+    // about its `style`, exactly as a user setting `globals.padding` says
+    // nothing about `globals.charset`.
+    editGlobals: { ...dflt.editGlobals, ...(raw.editGlobals ?? {}) },
     // [LAW:one-source-of-truth] helpers merge by name, same cascade — a user
     // overrides one formatter helper by re-declaring its name; the rest inherit
     // from the bundled default.

package/src/config/presets.ts

@@ -15,7 +15,7 @@
 // place it is written down:
 //
 //   bundled default  <  user config file  <  persisted overrides
-//                    <  ACTIVE PRESET  <  session pick
+//                    <  ACTIVE PRESET  <  session pick  <  EDIT MODE
 //
 // The preset's position is forced by its lifetime, not chosen. Everything to
 // its left is resolved once per RenderCache entry (an entry serves many
@@ -26,6 +26,18 @@
 // "compact" arrangement must actually change padding, even for a user who once
 // persisted a padding they liked) while a session's own click still wins over
 // the preset (a click is later still).
+//
+// The same rule places the last rung (candybar-settings-ui-aok.5): edit mode's
+// `editGlobals` fragment is decided later than ANY session pick — a user picks
+// a style, and only afterwards enters edit mode — so it is the new rightmost
+// layer, and a session pick of "capsule" cannot survive into a mode whose whole
+// job is to stop segments reading as one continuous strip. It differs from
+// every rung to its left in LIFETIME rather than in kind: nothing writes it to
+// SessionState or the overrides layer, so leaving edit mode restores the
+// previous look with no save/restore path — the session's own pick was never
+// overwritten, only out-ranked [LAW:dataflow-not-control-flow]. The rung itself
+// is the `staged` parameter of effectiveGlobal (themes/policy.ts); this comment
+// is the ONE place the order is written down.
 
 // [LAW:one-way-deps] Type-only, so nothing is emitted and option-domain.ts (a
 // leaf that deliberately never imports dsl-types.ts) can import PRESET_NAMES
@@ -87,7 +99,14 @@ export function effectivePresetName(
   globalsPreset: string | undefined,
   declaredPresets: Readonly<Record<string, PresetDecl>>,
 ): string {
+  // [LAW:types-are-the-program] No staged rung, and the absence is enforced
+  // rather than assumed: every globals fragment that could stage one — a
+  // preset's own `globals`, edit mode's `editGlobals` — has `preset` swapped for
+  // a rejection in its schema (loader/globals.ts), so "a fragment selected a
+  // preset" is unrepresentable and there is nothing here to resolve against.
+  // Which preset is active keeps exactly one authority.
   return effectiveMemberName(
+    undefined,
     sessionPreset,
     globalsPreset,
     PRESET_FLOOR,

package/src/daemon/render-payload.ts

@@ -20,7 +20,20 @@ import path from "node:path";
 import os from "node:os";
 import type { ClaudeHookData } from "../utils/claude.js";
 import type { ClientHints } from "./protocol.js";
-import type { DslConfig, VariableDecl } from "../config/dsl-types.js";
+import type { DslConfig, Globals, VariableDecl } from "../config/dsl-types.js";
+import { effectivePresetName, presetGlobals } from "../config/presets.js";
+import { EDIT_MODE_KEY, EDIT_MODE_OPEN } from "../config/loader/edit-mode.js";
+import {
+  DEFAULT_CHARSET,
+  DEFAULT_COLOR_COMPATIBILITY,
+} from "../render/strip.js";
+import {
+  effectiveAutoWrap,
+  effectiveLookName,
+  effectivePadding,
+  effectiveStripStyle,
+  effectiveThemeName,
+} from "../themes/policy.js";
 import { walkNodes } from "../config/dsl-types.js";
 import { extractTemplateRefs } from "../config/dsl-loader.js";
 import type { GitInfo, GitInfoOptions } from "../segments/git.js";
@@ -75,12 +88,96 @@ export interface EffectiveGlobals {
   // own comment.
   readonly presetCustomized: boolean;
   readonly style: StripStyle;
+  // [LAW:one-source-of-truth] The cell separator `plain` renders between
+  // segments (globals.default_separator). `string | undefined`, not a resolved
+  // string, precisely because its floor is NOT ours: PlainJoiner owns " | " and
+  // pickJoiner already reads undefined as "use the class default", so naming a
+  // floor here would be a second copy of a constant that lives in rich-js.
+  // Like charset it has no SessionState half — the config global (as staged by
+  // whatever fragment is on top) is its whole resolution.
+  readonly separator: string | undefined;
   readonly charset: Charset;
   readonly colorCompatibility: ColorCompatibility;
   readonly autoWrap: boolean;
   readonly padding: number;
 }
 
+// [LAW:one-source-of-truth] THE resolution — one function, so the precedence
+// chain has one implementation rather than one per caller. It previously stood
+// as two structurally identical struct literals (the daemon's, in server.ts,
+// and `cc-candybar check`'s), which is two clocks: the check command's job is
+// to render what the daemon would render, and a rung added to one copy is a
+// rung silently missing from the other. The callers differ only in WHERE a
+// session value comes from and whether an overrides log exists to be customized
+// by, so both arrive as parameters and nothing else forks
+// [LAW:dataflow-not-control-flow].
+//
+// `sessionPick` is the reader for one SessionState key. `check` passes a
+// function returning null for every key — a fresh session that has never
+// clicked — rather than a null store, so "no session" travels as a VALUE
+// through the same chain a real session travels [LAW:no-mode-explosion].
+export function resolveEffectiveGlobals(
+  config: DslConfig,
+  sessionPick: (key: string) => string | null,
+  presetCustomized: (preset: string) => boolean,
+): EffectiveGlobals {
+  // The preset resolves FIRST: every field below reads globals, and which
+  // globals is exactly what the preset decides.
+  const preset = effectivePresetName(
+    sessionPick("preset"),
+    config.globals.preset,
+    config.presets,
+  );
+  const globals = presetGlobals(config, preset);
+  // [LAW:dataflow-not-control-flow] The staged fragment is a VALUE, and "edit
+  // mode is off" is the EMPTY value — the identity fragment, exactly as
+  // PRESET_FLOOR's is. Every field below is resolved by the same expression
+  // whether or not edit mode is on; only the contents of `staged` differ. This
+  // is the whole of "no render-walk branch on edit mode": there is no branch
+  // here either, so there is none to leak downstream.
+  const staged: Partial<Globals> =
+    sessionPick(EDIT_MODE_KEY) === EDIT_MODE_OPEN ? config.editGlobals : {};
+  return {
+    preset,
+    presetCustomized: presetCustomized(preset),
+    theme: effectiveThemeName(
+      staged.palette,
+      sessionPick("theme"),
+      globals.palette,
+    ),
+    look: effectiveLookName(
+      staged.look,
+      sessionPick("look"),
+      globals.look,
+      config.looks,
+    ),
+    style: effectiveStripStyle(
+      staged.style,
+      sessionPick("style"),
+      globals.style,
+    ),
+    // [LAW:one-source-of-truth] The fields with no SessionState half resolve as
+    // `staged ?? config ?? floor` — the same chain minus the rung they do not
+    // have, spelled with the same `??` rather than a second mechanism.
+    separator: staged.default_separator ?? globals.default_separator,
+    autoWrap: effectiveAutoWrap(
+      staged.autoWrap,
+      sessionPick("autoWrap"),
+      globals.autoWrap,
+    ),
+    padding: effectivePadding(
+      staged.padding,
+      sessionPick("padding"),
+      globals.padding,
+    ),
+    charset: staged.charset ?? globals.charset ?? DEFAULT_CHARSET,
+    colorCompatibility:
+      staged.colorCompatibility ??
+      globals.colorCompatibility ??
+      DEFAULT_COLOR_COMPATIBILITY,
+  };
+}
+
 // ─── Augmented payload shape ─────────────────────────────────────────────────
 
 // [LAW:types-are-the-program] The RenderPayload extends ClaudeHookData with