@promptctl/cc-candybar 1.9.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/cc-candybar",
-  "version": "1.9.0",
+  "version": "1.10.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,10 +91,10 @@
     "mobx": "^6.15.0"
   },
   "optionalDependencies": {
-    "@promptctl/cc-candybar-darwin-arm64": "1.9.0",
-    "@promptctl/cc-candybar-darwin-x64": "1.9.0",
-    "@promptctl/cc-candybar-linux-x64": "1.9.0",
-    "@promptctl/cc-candybar-linux-arm64": "1.9.0"
+    "@promptctl/cc-candybar-darwin-arm64": "1.10.0",
+    "@promptctl/cc-candybar-darwin-x64": "1.10.0",
+    "@promptctl/cc-candybar-linux-x64": "1.10.0",
+    "@promptctl/cc-candybar-linux-arm64": "1.10.0"
   },
   "pnpm": {
     "supportedArchitectures": {

package/schema/cc-candybar.schema.json

@@ -35,6 +35,11 @@
         },
         "autoWrap": {
           "type": "boolean"
+        },
+        "padding": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 16
         }
       },
       "additionalProperties": false

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

@@ -52,11 +52,11 @@ import type { DslConfig } from "./dsl-types.js";
 // full absolute path. Same logic handles equal home & current_dir → just "~".
 const DIR_REL = 'trimPrefix "/" (trimPrefix .project_dir .current_dir)';
 const DIR_TEMPLATE =
-  ' {{ if and (ne .home "") (or (eq .home .current_dir) (hasPrefix (printf "%s/" .home) .current_dir)) }}~{{ trimPrefix .home .current_dir }}' +
+  '{{ if and (ne .home "") (or (eq .home .current_dir) (hasPrefix (printf "%s/" .home) .current_dir)) }}~{{ trimPrefix .home .current_dir }}' +
   "{{ else }}" +
   '{{ if or (eq .project_dir .current_dir) (hasPrefix (printf "%s/" .project_dir) .current_dir) }}' +
   `{{ ternary (${DIR_REL}) (basename .project_dir) (ne (${DIR_REL}) "") }}` +
-  "{{ else }}{{ .current_dir }}{{ end }}{{ end }} ";
+  "{{ else }}{{ .current_dir }}{{ end }}{{ end }}";
 
 // Git working-tree counts — leading-space-then-trim idiom: each present count
 // contributes " +N", trim drops the leading space, survivors single-spaced.
@@ -74,7 +74,7 @@ const GIT_STATUS =
   '{{ if eq .git.status "dirty" }}●{{ else }}✓{{ end }}{{ end }}';
 
 const GIT_TEMPLATE =
-  ' {{ if ne .git.repoName "" }}{{ .git.repoName }} {{ end }}⎇ {{ .git.branch }}' +
+  '{{ if ne .git.repoName "" }}{{ .git.repoName }} {{ end }}⎇ {{ .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 }}" +
@@ -83,8 +83,7 @@ const GIT_TEMPLATE =
   "{{ if .git.upstream }} →{{ .git.upstream }}{{ end }}" +
   "{{ if gt .git.stash 0 }} ⧇ {{ .git.stash }}{{ end }}" +
   " " +
-  GIT_STATUS +
-  " ";
+  GIT_STATUS;
 
 // [LAW:dataflow-not-control-flow] block and weekly share the same threshold
 // cascade (≥warningThreshold → error, ≥50 → warning, else panel) on a numeric
@@ -509,6 +508,12 @@ export const DEFAULT_DSL_CONFIG = {
   // palette spec names resolved against the active theme. `when` predicates
   // hide a segment when its primary signal is absent (no git repo, no version
   // field, no env var, no tmux, no rate-limit window).
+  //
+  // [LAW:one-source-of-truth] Templates author CONTENT only — the intra-cell
+  // padding (the space each side of a cell) is render chrome synthesized
+  // structurally from the one resolved globals.padding (default 1), never
+  // authored here. A template with leading/trailing spaces would render them
+  // IN ADDITION to the structural padding.
   segments: {
     directory: {
       template: DIR_TEMPLATE,
@@ -516,25 +521,25 @@ export const DEFAULT_DSL_CONFIG = {
       fg: "foreground",
     },
     model: {
-      template: " ✱ {{ formatModelName .model.display_name }} ",
+      template: "✱ {{ formatModelName .model.display_name }}",
       bg: "panel",
       fg: "foreground",
       when: '{{ ne .model.display_name "" }}',
     },
     sessionId: {
-      template: " ⌗{{ trunc 8 .session.id }} ",
+      template: "⌗{{ trunc 8 .session.id }}",
       bg: "surface",
       fg: "foreground",
       when: '{{ ne .session.id "" }}',
     },
     version: {
-      template: " ◈ v{{ .version }} ",
+      template: "◈ v{{ .version }}",
       bg: "surface",
       fg: "foreground",
       when: '{{ ne .version "" }}',
     },
     tmux: {
-      template: ' tmux:{{ .tmux.session | default "none" }} ',
+      template: 'tmux:{{ .tmux.session | default "none" }}',
       bg: "surface-active",
       fg: "foreground",
       when: '{{ ne .tmux.session "" }}',
@@ -547,7 +552,7 @@ export const DEFAULT_DSL_CONFIG = {
     },
     gitaculous: {
       template:
-        " (git)" +
+        "(git)" +
         '{{ if ne .git.repoName "" }} {{ .git.repoName }}{{ end }}' +
         '{{ if ne .git.operation "" }} [{{ .git.operation }}]{{ end }}' +
         '{{ if ne .git.sha "" }} {{ .git.sha }}{{ end }}' +
@@ -564,8 +569,7 @@ export const DEFAULT_DSL_CONFIG = {
         '{{ if gt .git.behind 0 }}{{ red (printf "-%v" .git.behind) }}{{ end }}' +
         "{{ end }}]{{ end }}" +
         "{{ if gt .git.stash 0 }} ({{ .git.stash }} stashed){{ end }}" +
-        '{{ if gt .git.timeSinceCommit 0 }} ◷ {{ template "formatTimeSince" .git.timeSinceCommit }}{{ end }}' +
-        " ",
+        '{{ if gt .git.timeSinceCommit 0 }} ◷ {{ template "formatTimeSince" .git.timeSinceCommit }}{{ end }}',
       bg: "surface-active",
       fg: "foreground",
       when: '{{ ne .git.branch "" }}',
@@ -580,10 +584,12 @@ export const DEFAULT_DSL_CONFIG = {
     // renders a distinct ⚠ marker so an outage is not mistaken for "no PR";
     // no PR (both empty) leaves the `when` gate false and the segment absent.
     gitPr: {
+      // The pad spaces are structural chrome now, OUTSIDE the OSC-8 link
+      // region — the clickable area is the glyph text itself.
       template:
         '{{ if ne .git.prUrl "" }}' +
-        '{{ link .git.prUrl (printf " ⇆ #%v " .git.prNumber) }}' +
-        "{{ else }} ⚠ PR {{ end }}",
+        '{{ link .git.prUrl (printf "⇆ #%v" .git.prNumber) }}' +
+        "{{ else }}⚠ PR{{ end }}",
       bg: "surface-active",
       fg: "foreground",
       when: '{{ or (ne .git.prUrl "") (ne .git.prError "") }}',
@@ -596,28 +602,28 @@ export const DEFAULT_DSL_CONFIG = {
     // one OSC-8 clickable region whose URL the wire codec owns end-to-end.
     toolbar: {
       template:
-        ' {{ action "copySession" "⎘ id" }} {{ action "copyDir" "⎘ cwd" }}' +
-        ' {{ action "openProject" "↗ proj" }} {{ action "openTranscript" "↗ log" }} ',
+        '{{ action "copySession" "⎘ id" }} {{ action "copyDir" "⎘ cwd" }}' +
+        ' {{ action "openProject" "↗ proj" }} {{ action "openTranscript" "↗ log" }}',
       bg: "surface",
       fg: "foreground",
     },
     session: {
       template:
-        ' § {{ template "formatCost" .session.cost }} ({{ template "formatTokens" .session.tokens }}) ',
+        '§ {{ template "formatCost" .session.cost }} ({{ template "formatTokens" .session.tokens }})',
       bg: "surface",
       fg: "foreground",
     },
     today: {
       template:
-        ' ☉ {{ template "formatCost" .today.cost }} ({{ template "formatTokens" .today.tokens }})' +
-        '{{ template "budgetStatus" (dict "cost" .today.cost "budget" .today.budget.amount "warn" .today.budget.warningThreshold) }} ',
+        '☉ {{ template "formatCost" .today.cost }} ({{ template "formatTokens" .today.tokens }})' +
+        '{{ template "budgetStatus" (dict "cost" .today.cost "budget" .today.budget.amount "warn" .today.budget.warningThreshold) }}',
       bg: "surface",
       fg: "foreground",
     },
     block: {
       template:
-        " ◱ {{ round .block.nativeUtilization }}% " +
-        '({{ template "formatLongTimeRemaining" (minutesUntilReset .block.resetsAt) }}) ',
+        "◱ {{ round .block.nativeUtilization }}% " +
+        '({{ template "formatLongTimeRemaining" (minutesUntilReset .block.resetsAt) }})',
       bg: blockLikeBg(
         ".block.nativeUtilization",
         ".block.budget.warningThreshold",
@@ -628,8 +634,8 @@ export const DEFAULT_DSL_CONFIG = {
     },
     weekly: {
       template:
-        " ◑ {{ round .weekly.percentage }}% " +
-        '({{ template "formatLongTimeRemaining" (minutesUntilReset .weekly.resetsAt) }}) ',
+        "◑ {{ round .weekly.percentage }}% " +
+        '({{ template "formatLongTimeRemaining" (minutesUntilReset .weekly.resetsAt) }})',
       bg: blockLikeBg(".weekly.percentage", ".weekly.budget.warningThreshold"),
       fg: blockLikeFg(".weekly.percentage"),
       when: "{{ gt .weekly.resetsAt 0 }}",
@@ -641,9 +647,9 @@ export const DEFAULT_DSL_CONFIG = {
     // rate-limit window is active — the same signal block/weekly gate on.
     burnrate: {
       template:
-        ' ⚡ {{ template "formatRate" .burn.costPerHour }} · ' +
+        '⚡ {{ template "formatRate" .burn.costPerHour }} · ' +
         '{{ template "formatEta" .block.etaMinutes }} to 5h · ' +
-        '{{ template "formatEta" .weekly.etaMinutes }} to wk ',
+        '{{ template "formatEta" .weekly.etaMinutes }} to wk',
       bg: etaHeatBg(
         ".block.etaMinutes",
         ".burn.eta.warnMinutes",
@@ -662,9 +668,9 @@ export const DEFAULT_DSL_CONFIG = {
     // turn start, `total` is their sum.
     speed: {
       template:
-        ' ⇅ out {{ template "formatSpeed" .speed.output }} · ' +
+        '⇅ out {{ template "formatSpeed" .speed.output }} · ' +
         'in {{ template "formatSpeed" .speed.input }} · ' +
-        'tot {{ template "formatSpeed" .speed.total }} ',
+        'tot {{ template "formatSpeed" .speed.total }}',
       bg: "panel",
       fg: "foreground",
       when: "{{ gt .session.tokens 0 }}",
@@ -679,7 +685,7 @@ export const DEFAULT_DSL_CONFIG = {
     // two samples before its first bar). [LAW:effects-at-boundaries] — all the
     // history lives in the daemon ring, the template only draws.
     tokenSparkline: {
-      template: " ⚡ {{ sparkline .speed.history 24 }} ",
+      template: "⚡ {{ sparkline .speed.history 24 }}",
       bg: "panel",
       fg: "foreground",
       when: '{{ ne .speed.history "" }}',
@@ -693,8 +699,8 @@ export const DEFAULT_DSL_CONFIG = {
     // (warm = normal, ≤20m = warning, ≤8m/cold = error).
     cacheTimer: {
       template:
-        " ◴ {{ if le (minutesUntilReset .cache.expiresAt) 0 }}cold" +
-        "{{ else }}{{ minutesUntilReset .cache.expiresAt }}m{{ end }} ",
+        "◴ {{ if le (minutesUntilReset .cache.expiresAt) 0 }}cold" +
+        "{{ else }}{{ minutesUntilReset .cache.expiresAt }}m{{ end }}",
       bg: "surface",
       fg:
         "{{ if le (minutesUntilReset .cache.expiresAt) 8 }}error" +
@@ -704,7 +710,7 @@ export const DEFAULT_DSL_CONFIG = {
     },
     context: {
       template:
-        " ◔ {{ formatInteger .context.totalTokens }} ({{ .context.contextLeft }}%) ",
+        "◔ {{ formatInteger .context.totalTokens }} ({{ .context.contextLeft }}%)",
       bg:
         "{{ if le .context.contextLeft 20 }}error" +
         "{{ else }}{{ if le .context.contextLeft 40 }}warning" +
@@ -724,6 +730,12 @@ export const DEFAULT_DSL_CONFIG = {
       // level `when` survives as a weak any-present check so a payload
       // with zero metrics data renders no cell at all (an empty template
       // would otherwise produce a single-space bg-styled cell).
+      //
+      // [LAW:one-source-of-truth] exception: each arm's leading space is the
+      // SEPARATOR between present parts (only data can decide which part is
+      // first, so no static strip can remove just the first one), and the
+      // trailing space mirrors it for symmetry. At the default padding this
+      // cell therefore reads one space wider per side than its siblings.
       template:
         '{{ if .metrics.lastResponseTime }} Δ {{ template "formatResponseTime" .metrics.lastResponseTime }}{{ end }}' +
         '{{ if .metrics.responseTime }} ⧖ {{ template "formatResponseTime" .metrics.responseTime }}{{ end }}' +

package/src/config/dsl-types.ts

@@ -196,6 +196,14 @@ export interface Globals {
   // [config-only] Unlike palette/style there is no SessionState/click half —
   // the daemon resolves `globals.autoWrap ?? true` into renderOpts.wrap.
   readonly autoWrap?: boolean;
+
+  // The legacy display.padding knob: spaces synthesized INSIDE each segment
+  // cell per side (intra-cell, within the bg fill — not rich-js FlexStrip's
+  // inter-item gap). Default 1 (current behavior). Templates author content;
+  // this chrome is applied structurally at the cell-formation seam.
+  // [config-only] The daemon resolves `globals.padding ?? 1` into
+  // renderOpts.padding; no SessionState/click half.
+  readonly padding?: number;
 }
 
 // [LAW:one-type-per-behavior] One discriminated union covers every source

package/src/config/loader/globals.ts

@@ -8,6 +8,7 @@ import { STRIP_STYLES } from "../../themes/policy.js";
 import {
   optionalBooleanSpec,
   optionalEnumSpec,
+  optionalIntSpec,
   optionalStringSpec,
   paletteSpec,
   record,
@@ -31,6 +32,11 @@ const GLOBALS_SCHEMA: RecordSchema<Globals> = {
     // validates by membership and emits a JSON-Schema `enum`.
     style: optionalEnumSpec(STRIP_STYLES),
     autoWrap: optionalBooleanSpec(),
+    // Intra-cell spaces per side. Bounded above so a config value can never
+    // drive an unbounded `" ".repeat` allocation in the daemon
+    // [LAW:no-silent-failure] — an absurd value is a loud load error, not a
+    // silently-huge render.
+    padding: optionalIntSpec({ min: 0, max: 16 }),
   },
 };
 

package/src/config/loader/validate-core.ts

@@ -554,6 +554,34 @@ export function optionalBooleanSpec(): FieldSpec<boolean> {
   };
 }
 
+// [LAW:dataflow-not-control-flow] An optional bounded-integer field: the bounds
+// are DATA feeding both interpreters — `parse` checks them and interpolates them
+// into the one message, `json` emits them as minimum/maximum — so the validator
+// and the editor-facing schema cannot describe different ranges.
+export function optionalIntSpec(bounds: {
+  readonly min: number;
+  readonly max: number;
+}): FieldSpec<number> {
+  const { min, max } = bounds;
+  return {
+    required: false,
+    json: { type: "integer", minimum: min, maximum: max },
+    parse: (ctx, path, field, raw) => {
+      const v = raw[field];
+      if (v === undefined) return undefined;
+      if (typeof v !== "number" || !Number.isInteger(v) || v < min || v > max) {
+        ctx.issues.push({
+          path: `${path}.${field}`,
+          message: `${field} must be an integer between ${min} and ${max}, got ${describeValue(v)}`,
+          line: findKeyLine(ctx.source, [field]),
+        });
+        return undefined;
+      }
+      return v;
+    },
+  };
+}
+
 // [LAW:single-enforcer] The palette field defers to the one palette-name
 // authority; the field key is conventionally "palette", which validatePaletteName
 // reads directly.

package/src/daemon/server.ts

@@ -46,6 +46,7 @@ import {
 } from "../themes/index.js";
 import {
   renderStripCells,
+  DEFAULT_PADDING,
   DEFAULT_TERMINAL_WIDTH,
   DEFAULT_WRAP,
   type BuildLineOptions,
@@ -773,6 +774,12 @@ async function handleRequest(req: Request): Promise<HandledRequest> {
         // resolution. Width stays finite regardless: it also feeds the
         // picker's pagination (term.cols), which no-wrap must not break.
         renderOpts.wrap = entry.state.config.globals.autoWrap ?? DEFAULT_WRAP;
+        // [config-only] globals.padding, same shape as autoWrap: the config
+        // global over the base floor is the whole resolution — the ONE home
+        // of the value every cell builder (and the picker's pagination
+        // reserve) derives from. [LAW:one-source-of-truth]
+        renderOpts.padding =
+          entry.state.config.globals.padding ?? DEFAULT_PADDING;
         // [LAW:single-enforcer] renderDsl internally calls
         // `registry.applyInput(payload)` as its first step (see step 1 in
         // src/dsl/render.ts). The daemon must not pre-apply — doing so
@@ -1064,6 +1071,7 @@ const RENDER_OPTS_BASE = {
   style: "powerline" as const,
   colorCompatibility: "truecolor" as const,
   wrap: DEFAULT_WRAP,
+  padding: DEFAULT_PADDING,
 };
 const DEBUG_RENDER_OPTS: BuildLineOptions = {
   ...RENDER_OPTS_BASE,

package/src/demo/dsl.ts

@@ -31,7 +31,11 @@ import { SessionState } from "../daemon/session-state.js";
 import { listResolvablePaletteNames } from "../themes/policy.js";
 import { effectiveThemeName, resolverForThemeName } from "../themes/index.js";
 import { registerDslConfig, renderDsl } from "../dsl/render.js";
-import { DEFAULT_TERMINAL_WIDTH, DEFAULT_WRAP } from "../render/strip.js";
+import {
+  DEFAULT_PADDING,
+  DEFAULT_TERMINAL_WIDTH,
+  DEFAULT_WRAP,
+} from "../render/strip.js";
 import { applyClaudeCodeReserve } from "../utils/terminal-width.js";
 
 const FRAMES = 4;
@@ -113,6 +117,7 @@ try {
         // Same resolution the daemon applies: the config global over the
         // default-on floor.
         wrap: config.globals.autoWrap ?? DEFAULT_WRAP,
+        padding: config.globals.padding ?? DEFAULT_PADDING,
       },
     );
     process.stdout.write(`  ${line}\n`);

package/src/dsl/node-registry.ts

@@ -101,6 +101,10 @@ export interface NodeRenderCtx {
   readonly scope: object;
   readonly basePalette: PaletteResolver;
   readonly visible: boolean;
+  // [LAW:one-source-of-truth] The render-wide intra-cell padding (resolved
+  // globals.padding), threaded by the driver from BuildLineOptions into every
+  // segment's layout — one value per render, never re-defaulted per node.
+  readonly padding: number;
   // Advance the walk-owned hue cursor by one unit and return that unit's shift.
   nextHueShift(): number;
   readonly perSegmentSink?: Map<string, readonly RichText[]>;
@@ -279,6 +283,11 @@ const segmentType: NodeType<"segment"> = {
         justify: seg.justify ?? "left",
         truncate: seg.truncate ?? "right",
         baseStyle,
+        // [LAW:dataflow-not-control-flow] Padding is uniform across every line
+        // a segment contributes — inline rows AND dropped menu bands — one
+        // value, no per-line-kind branch. The picker reserves 2×padding at its
+        // pagination seam so a padded band still fits the width budget.
+        padding: ctx.padding,
       } as const;
 
       // [LAW:single-enforcer] Partition the segment's authored "\n" into visual

package/src/dsl/render.ts

@@ -29,7 +29,7 @@ import {
   type GitField,
 } from "../var-system/sources.js";
 import type { BuildLineOptions } from "../render/strip.js";
-import { renderStripCells } from "../render/strip.js";
+import { DEFAULT_PADDING, renderStripCells } from "../render/strip.js";
 import { resolverForThemeName } from "../themes/index.js";
 import { buildScope } from "../template-engine/scope.js";
 import {
@@ -286,6 +286,9 @@ export function registerDslConfig(
     // style each render; "powerline" is the registration-time default so a
     // compile-only path (no render) still has a valid value.
     stripStyle: "powerline",
+    // Same contract as stripStyle: renderDsl republishes the live resolved
+    // globals.padding each render; the constant is only the compile-only floor.
+    padding: DEFAULT_PADDING,
   };
   // [LAW:one-way-deps] Inject action + picker feature funcs as data — the engine
   // stays generic. The picker shares the ACTION runtime (it resolves its
@@ -537,6 +540,10 @@ export function renderDsl(
   // once per render here — the same one-owner, per-render-mutation idiom as the
   // menu placement cursor below. [LAW:no-ambient-temporal-coupling]
   compiled.menuRuntime.action.stripStyle = opts.style;
+  // [LAW:one-source-of-truth] Publish the render's intra-cell padding beside the
+  // style: the picker reserves 2×padding at its pagination seam, the same seam
+  // that reserves the joiner chrome — one resolved value, read where needed.
+  compiled.menuRuntime.action.padding = opts.padding;
 
   const scope = buildScope(store);
   // [LAW:one-source-of-truth] hueStep is a value in the store like every other
@@ -610,6 +617,7 @@ export function renderDsl(
       scope,
       basePalette,
       visible,
+      padding: opts.padding,
       nextHueShift,
       perSegmentSink,
       beginSegment,

package/src/render/action.ts

@@ -134,6 +134,12 @@ export interface ActionRuntime {
   // and synchronous, so the per-render write never leaks across renders.
   // [LAW:no-ambient-temporal-coupling]
   stripStyle: StripStyle;
+  // [LAW:locality-or-seam] The current render's intra-cell padding (resolved
+  // globals.padding), published per render by renderDsl exactly like
+  // stripStyle. The picker reserves 2×padding at its pagination seam — the
+  // segment layout pads every line it emits, so a page packed to the full
+  // budget would otherwise be pushed past the width by the pad spaces.
+  padding: number;
 }
 
 // ─── Compilation ───────────────────────────────────────────────────────────────

package/src/render/picker.ts

@@ -168,11 +168,15 @@ export function renderPicker(
   // pagination seam, rather than shrinking the shared term.cols every template
   // reads. stripChromeCols owns the per-style geometry; Infinity − chrome stays
   // Infinity, so wrap mode is unaffected.
+  // The pad spaces the segment layout synthesizes around the picker's line
+  // (2 × the render's intra-cell padding) consume the same width budget the
+  // joiner chrome does — reserve both here, at the pagination seam.
   const available = paged
     ? Math.max(
         1,
         toNumber(store.read(TERM_COLS_VAR)) -
-          stripChromeCols(runtime.stripStyle),
+          stripChromeCols(runtime.stripStyle) -
+          2 * runtime.padding,
       )
     : Infinity;
   const closeReserve = cellWidth(PICKER_CLOSE) + 1;

package/src/render/strip.ts

@@ -37,6 +37,12 @@ export const DEFAULT_TERMINAL_WIDTH = 120;
 // (`globals.autoWrap ?? DEFAULT_WRAP`) derives from this constant.
 export const DEFAULT_WRAP = true;
 
+// [LAW:one-source-of-truth] The one statement of the globals.padding
+// default (one space per side inside each segment cell — current behavior,
+// matching the legacy display.padding). Every resolver of the config global
+// (`globals.padding ?? DEFAULT_PADDING`) derives from this constant.
+export const DEFAULT_PADDING = 1;
+
 export interface BuildLineOptions {
   style: StripStyle;
   colorCompatibility: ColorSystemSpec;
@@ -53,6 +59,12 @@ export interface BuildLineOptions {
   // explicitly — encoding "no wrap" as width=Infinity would corrupt the
   // picker's pagination, which reads the same width value.
   wrap: boolean;
+  // [LAW:one-source-of-truth] Spaces inside each segment cell per side
+  // (globals.padding, default 1 — the legacy display.padding, intra-cell,
+  // not rich-js FlexStrip's inter-item gap). Required so every construction
+  // site states the resolved value; the cell builders derive from it and
+  // never re-default.
+  padding: number;
 }
 
 function pickJoiner(style: StripStyle, separator?: string): Joiner {
@@ -103,15 +115,15 @@ export function stripChromeCols(style: StripStyle): number {
   }
 }
 
-function toCell(seg: RenderedSegmentLike): RichText {
-  // Padding mirrors the legacy buildLineFromSegments: one space on each side
-  // of the segment text. The joiners sit between cells; padding sits inside.
-  const padded = ` ${seg.text} `;
+function toCell(seg: RenderedSegmentLike, padding: number): RichText {
+  // [LAW:one-source-of-truth] Intra-cell padding derives from the one resolved
+  // globals.padding value on BuildLineOptions — the joiners sit between cells;
+  // padding sits inside, inheriting the cell's wrapping style (bg fill).
   const style = new Style({
     bgcolor: seg.bgHex || undefined,
     color: seg.fgHex || undefined,
   });
-  return new RichText(padded, { style, end: "", noWrap: true });
+  return new RichText(seg.text, { style, end: "", noWrap: true }).pad(padding);
 }
 
 /**
@@ -156,5 +168,8 @@ export function buildLineStrip(
   segments: readonly RenderedSegmentLike[],
   options: BuildLineOptions,
 ): string {
-  return renderStripCells(segments.map(toCell), options);
+  return renderStripCells(
+    segments.map((seg) => toCell(seg, options.padding)),
+    options,
+  );
 }

package/src/template-engine/layout.ts

@@ -30,6 +30,15 @@ export interface SegmentLayoutOptions {
   justify: JustifyMode;
   /** Overflow strategy when content exceeds a fixed width. Ignored when "auto". */
   truncate: TruncateMode;
+  /**
+   * Spaces synthesized inside the collapsed cell on each side (the resolved
+   * globals.padding). [LAW:types-are-the-program] Required so every layout
+   * site states the value — the walk threads the one render-wide resolution;
+   * there is no per-site re-default. Applied BEFORE width sizing, so padding
+   * sits inside a fixed `width` (the legacy intra-cell semantics: the joiners
+   * sit between cells; padding sits inside the bg fill).
+   */
+  padding: number;
   /** Glyph inserted at the overflow cut point. Default "…". */
   truncateMarker?: string;
   /**
@@ -95,11 +104,23 @@ export function applySegmentLayout(
   cells: readonly RichText[],
   options: SegmentLayoutOptions,
 ): RichText[] {
-  const { width, justify, truncate, truncateMarker = "…", baseStyle } = options;
+  const {
+    width,
+    justify,
+    truncate,
+    truncateMarker = "…",
+    baseStyle,
+    padding,
+  } = options;
 
   if (cells.length === 0) return [];
 
-  const cell = collapseToCell(cells, baseStyle);
+  // [LAW:one-source-of-truth] The DSL path's ONE intra-cell padding
+  // application — the same rich-js pad primitive toCell (render/strip.ts)
+  // uses on the legacy shape, threading the same resolved globals.padding.
+  // pad() shifts spans, so OSC-8 link regions survive; the spaces inherit
+  // the cell's wrapping style, so the segment bg is continuous.
+  const cell = collapseToCell(cells, baseStyle).pad(padding);
   if (width === "auto") return [cell];
 
   if (cell.cellLength > width) {