@promptctl/cc-candybar 1.8.4 → 1.10.0

package/package.json

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

@@ -32,6 +32,14 @@
             "capsule",
             "plain"
           ]
+        },
+        "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

@@ -189,6 +189,21 @@ export interface Globals {
   // so a style click reshapes the bar live and a config can set the default
   // shape without an edit-per-session.
   readonly style?: StripStyle;
+
+  // The legacy display.autoWrap knob: whether FlexStrip soft-wraps a root
+  // row that exceeds the usable width. Default true (current behavior);
+  // false renders each row as one unbounded line, overflow off-screen.
+  // [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

@@ -6,7 +6,9 @@
 import { type Globals } from "../dsl-types.js";
 import { STRIP_STYLES } from "../../themes/policy.js";
 import {
+  optionalBooleanSpec,
   optionalEnumSpec,
+  optionalIntSpec,
   optionalStringSpec,
   paletteSpec,
   record,
@@ -29,6 +31,12 @@ const GLOBALS_SCHEMA: RecordSchema<Globals> = {
     // shapes the joiner can render), unlike the open-ended palette NAME — so it
     // 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,7 +46,9 @@ import {
 } from "../themes/index.js";
 import {
   renderStripCells,
+  DEFAULT_PADDING,
   DEFAULT_TERMINAL_WIDTH,
+  DEFAULT_WRAP,
   type BuildLineOptions,
 } from "../render/strip.js";
 import { applyClaudeCodeReserve } from "../utils/terminal-width.js";
@@ -767,6 +769,17 @@ async function handleRequest(req: Request): Promise<HandledRequest> {
           sessionState.get(req.hookData.session_id, "style"),
           entry.state.config.globals.style,
         );
+        // [config-only] globals.autoWrap has no SessionState half (no click
+        // verb) — the config global over the base floor is the whole
+        // 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
@@ -1057,6 +1070,8 @@ const verbCtx = { sessionState, dlog };
 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/daemon/verbs/state-validators.ts

@@ -81,10 +81,10 @@ export type DerivedValidatorSpec =
     };
 
 // [LAW:one-source-of-truth] listResolvablePaletteNames is THE set whose
-// members resolve to a concrete Palette. The broader listAvailableThemes
-// includes the "custom" sentinel (read inline colors) which is not a
-// renderable theme name; accepting "custom" here would persist an
-// unrenderable value into SessionState and break the next render.
+// members resolve to a concrete Palette. It deliberately excludes the "custom"
+// sentinel (which needs inline colors and is not a renderable theme name):
+// accepting "custom" here would persist an unrenderable value into SessionState
+// and break the next render.
 //
 // [LAW:single-enforcer] Each validator's accepted-set is one constant
 // lookup structure — a Set for O(1) `has` (matching the BOOLEAN_*

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 } 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;
@@ -110,6 +114,10 @@ try {
         width: applyClaudeCodeReserve(
           process.stdout.columns ?? DEFAULT_TERMINAL_WIDTH,
         ),
+        // 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

@@ -32,14 +32,39 @@ export type { StripStyle };
 // applyClaudeCodeReserve from src/utils/terminal-width).
 export const DEFAULT_TERMINAL_WIDTH = 120;
 
+// [LAW:one-source-of-truth] The one statement of the globals.autoWrap
+// default (on — current behavior). Every resolver of the config global
+// (`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;
   separator?: string;
-  // [LAW:types-are-the-program] Every render carries a width. Finite values
-  // wrap via FlexStrip; Number.POSITIVE_INFINITY renders one unbounded line.
-  // Required (not optional) so callers cannot silently drop the wire's value.
+  // [LAW:types-are-the-program] Every render carries a width. Required (not
+  // optional) so callers cannot silently drop the wire's value.
+  // [LAW:one-source-of-truth] Width is a FACT (usable cells) feeding two
+  // consumers — FlexStrip's wrap limit AND the picker's pagination
+  // (`term.cols`). It stays finite even when wrapping is off; `wrap` below is
+  // the separate POLICY of whether rows may soft-break at that width.
   width: number;
+  // [LAW:types-are-the-program] Required for the same reason as width: the
+  // wrap decision (globals.autoWrap, default on) must reach every render
+  // 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 {
@@ -90,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);
 }
 
 /**
@@ -106,12 +131,13 @@ function toCell(seg: RenderedSegmentLike): RichText {
  * string. Every render path (DSL RichText[] via the template-engine
  * pipeline, buildLineStrip's input-shape adapter, debug per-segment
  * serialization) flows through here. The wrap dispatch lives here too:
- * finite width → FlexStrip (rich-js owns the wrap algebra); infinite
- * width → Strip.
+ * wrap enabled at a finite width → FlexStrip (rich-js owns the wrap
+ * algebra); otherwise → Strip, one unbounded line.
  *
- * [LAW:dataflow-not-control-flow] The dispatch is on the value, not on a
- * flag. There is no `wrap: boolean` knob; presence of a finite width IS
- * the decision.
+ * [LAW:dataflow-not-control-flow] The dispatch is on values, not on caller
+ * branches: `wrap` (the globals.autoWrap policy) gates whether the finite
+ * width acts as a break limit. An infinite width has nothing to break at,
+ * so it renders unbounded regardless of `wrap`.
  */
 export function renderStripCells(
   cells: readonly RichText[],
@@ -119,7 +145,7 @@ export function renderStripCells(
 ): string {
   if (cells.length === 0) return "";
   const joiner = pickJoiner(options.style, options.separator);
-  if (Number.isFinite(options.width)) {
+  if (options.wrap && Number.isFinite(options.width)) {
     const flex = new FlexStrip([...cells], { joiner });
     const out = renderToString(flex, {
       width: options.width,
@@ -142,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,
+  );
 }