@promptctl/cc-candybar 1.18.0 → 1.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/cc-candybar",
-  "version": "1.18.0",
+  "version": "1.19.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",
@@ -27,7 +27,7 @@
     "preloadtest": "pnpm build",
     "loadtest": "node --import tsx scripts/daemon-load-harness.ts",
     "preloadtest:gate": "pnpm build",
-    "loadtest:gate": "node --import tsx scripts/daemon-load-harness.ts --sessions 25 --interval 300 --duration 20 --churn --transcript-lines 5000",
+    "loadtest:gate": "node --import tsx scripts/daemon-load-harness.ts --sessions 25 --interval 300 --duration 20 --churn --git-churn --transcript-lines 5000",
     "check:protocol": "node scripts/check-protocol.mjs",
     "gen:schema": "tsx scripts/gen-schema.ts",
     "check:schema": "tsx scripts/check-schema.ts",
@@ -89,16 +89,16 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@promptctl/go-template-js": "^0.6.0",
+    "@promptctl/go-template-js": "^0.7.0",
     "@promptctl/rich-js": "^0.6.0",
     "json5": "^2.2.3",
     "mobx": "^6.15.0"
   },
   "optionalDependencies": {
-    "@promptctl/cc-candybar-darwin-arm64": "1.18.0",
-    "@promptctl/cc-candybar-darwin-x64": "1.18.0",
-    "@promptctl/cc-candybar-linux-x64": "1.18.0",
-    "@promptctl/cc-candybar-linux-arm64": "1.18.0"
+    "@promptctl/cc-candybar-darwin-arm64": "1.19.0",
+    "@promptctl/cc-candybar-darwin-x64": "1.19.0",
+    "@promptctl/cc-candybar-linux-x64": "1.19.0",
+    "@promptctl/cc-candybar-linux-arm64": "1.19.0"
   },
   "pnpm": {
     "supportedArchitectures": {

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

@@ -528,12 +528,9 @@ export const DEFAULT_DSL_CONFIG = {
     // and the render's read are one value. Empty default ⇒ the daemon's
     // "powerline" floor is in effect and styleControl shows "(default)".
     activeStyle: { kind: "state", key: "style", default: "" },
-    // The style picker's page index. Open/closed is the synthesized menus.* key
-    // the styleControl's {{ menu }} owns — NOT this var, which is purely the page
-    // the picker paginates by (default page 0; the disclosure resets it to 0 on
-    // every toggle, so a reopened menu never lands on a stale page). The stylePage
-    // action below declares the int gate this var reads back.
-    stylePage: { kind: "state", key: "style-page", default: "0" },
+    // No page-cursor var: the styleControl {{ menu }} synthesizes its own page
+    // cursor (state var + int action, named by menuPageKey) under the reserved
+    // menus.* namespace, alongside its open-state.
   },
 
   // ─── Segments ──────────────────────────────────────────────────────────────
@@ -794,15 +791,16 @@ export const DEFAULT_DSL_CONFIG = {
     // onto the line below this row when open. [LAW:one-type-per-behavior] "a menu
     // that opens and closes" is one behavior the substrate already expresses — no
     // bespoke open-action + page-cursor-as-open-state + when-gated reveal row.
-    // paged omitted ⇒ false ⇒ one full-width page (the 3 powerline shapes are a
-    // small domain; FlexStrip soft-wraps if needed). closeOnPick omitted ⇒ false
-    // ⇒ stay-open, so shapes can be tried in a row; the ▾ collapses.
+    // The apply name is the whole declaration: the page cursor (state var + int
+    // gate) is synthesized from the menu's identity, and the defaults are the
+    // canonical path — paged (the 3 powerline shapes fit one page, so no arrows
+    // render) and stay-open, so shapes can be tried in a row; ▾/✕ collapse.
     // [LAW:dataflow-not-control-flow] No display state from the provider — the
     // label is the one "style" value the click writes and the render reads.
     styleControl: {
       template:
         "✦ {{ if .activeStyle }}{{ .activeStyle }}{{ else }}(default){{ end }} " +
-        '{{ menu "applyStyle" "stylePage" }}',
+        '{{ menu "applyStyle" }}',
       bg: "surface",
       fg: "foreground",
     },
@@ -876,18 +874,17 @@ export const DEFAULT_DSL_CONFIG = {
     openProject: { open: "{{ .project_dir }}" },
     openTranscript: { open: "{{ .transcript_path }}" },
 
-    // [LAW:locality-or-seam] The style menu's behaviors, decoupled by NAME from the
-    // styleControl {{ menu }} above. The disclosure's open-state toggle + its
-    // backing state var are SYNTHESIZED by the menu pass (under the reserved
-    // menus.* namespace) — no hand-authored open/close action. These two are the
-    // picker body's effects, both gated by derivation (deriveActionValidators):
-    // applyStyle writes the chosen shape, gated to the STRIP_STYLES allow-list
-    // because its value source is `from: "styles"`; stylePage is the page cursor's
-    // unbounded int gate (←/→ navigation + the disclosure's page-0 reset). The
+    // [LAW:locality-or-seam] The style menu's behavior, decoupled by NAME from the
+    // styleControl {{ menu }} above. The disclosure's open-state toggle, its
+    // backing state var, AND the picker body's page cursor (state var + int
+    // action) are all SYNTHESIZED by the menu pass (under the reserved menus.*
+    // namespace) — no hand-authored open/close or page plumbing. This one action
+    // is the picker body's apply effect, gated by derivation
+    // (deriveActionValidators): it writes the chosen shape, gated to the
+    // STRIP_STYLES allow-list because its value source is `from: "styles"`. The
     // rendered click and the wire gate share that one source — a template cannot
     // smuggle an un-gated style write.
     applyStyle: { set: "style", from: "styles" },
-    stylePage: { set: "style-page", int: true },
   },
 
   // [LAW:single-enforcer] / [LAW:one-source-of-truth] Display-formatting policy

package/src/config/disclosure.ts

@@ -0,0 +1,55 @@
+// [LAW:one-source-of-truth] THE disclosure primitive: the one toggle machinery
+// that both group sugar (`kind: "group"`, src/config/loader/layout.ts) and the
+// `{{ menu }}` helper (src/config/loader/menu-synth.ts + src/render/menu.ts) are
+// built on. A disclosure is a binary toggle over a SessionState key: the key
+// holds either the CLOSED sentinel or a single MEMBER name; a `cycle` action
+// flips between the two; a ▸/▾ glyph shows which state it is in; sibling
+// disclosures sharing one key become mutually exclusive (an accordion) because
+// one key holds one open member. Group and menu differ ONLY in their BODY (group
+// reveals an arbitrary layout container gated by a `when`; menu drops a picker
+// grid below the row) and in where the trigger lives (group synthesizes a toggle
+// segment; the menu helper IS the trigger). The toggle itself — sentinel, glyphs,
+// the `state` var, the `cycle` action — is single-sourced HERE so the two
+// body-kinds cannot drift [LAW:one-type-per-behavior][LAW:decomposition].
+//
+// [LAW:one-way-deps] This module is intentionally PURE — it imports only decl
+// TYPES (erased at build) and holds no loader (`ValidateCtx`, diagnostics) nor
+// render (rich-js) dependency, so both the loader synthesis passes and the render
+// helper can share it without dragging one layer into the other. The loader-side
+// reserved-namespace collision check — the other half of the shared machinery,
+// which needs the validation context — lives in
+// `src/config/loader/reserved-namespace.ts`.
+
+import type { ActionDecl } from "./action.js";
+import type { VariableDecl } from "./dsl-types.js";
+
+// The "nothing open" sentinel a disclosure's key starts from and returns to on
+// close. A disclosure's MEMBER (a group name / a menu apply-action name) may
+// never equal this — an equal member would make the cycle `[closed, "closed"]`
+// (two identical members, never openable), which both synthesis passes reject.
+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 ▾.
+export const DISCLOSURE_GLYPH_CLOSED = "▸";
+export const DISCLOSURE_GLYPH_OPEN = "▾";
+
+// [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
+// `open: true`). One shape, so a group var and a menu var declared on one key
+// cannot disagree on kind or key.
+export function disclosureStateVar(key: string, def: string): VariableDecl {
+  return { kind: "state", key, default: def };
+}
+
+// [LAW:single-enforcer] THE toggle action a disclosure realizes: a binary `cycle`
+// between the CLOSED sentinel and the member (ordered closed-first, so an unset or
+// sibling-held key counts as the first member — the toggle renders ▸ and a click
+// writes the member, opening it and auto-closing any accordion sibling). The
+// derived click gate (`deriveActionValidators`) reads this like every other
+// `set`, so a disclosure toggle needs no parallel verb [LAW:single-enforcer].
+export function disclosureCycleAction(key: string, member: string): ActionDecl {
+  return { set: key, cycle: [DISCLOSURE_CLOSED, member] };
+}

package/src/config/loader/layout.ts

@@ -30,7 +30,15 @@ import {
   type VariableDecl,
 } from "../dsl-types.js";
 import type { ActionDecl } from "../action.js";
+import {
+  DISCLOSURE_CLOSED,
+  DISCLOSURE_GLYPH_CLOSED,
+  DISCLOSURE_GLYPH_OPEN,
+  disclosureCycleAction,
+  disclosureStateVar,
+} from "../disclosure.js";
 import { findKeyLine } from "./diagnostics.js";
+import { reservedNamespaceCollisions } from "./reserved-namespace.js";
 import {
   describeType,
   describeValue,
@@ -385,9 +393,11 @@ export const validateRoot = (
 // prefix is rejected so synthesis can never silently collide.
 export const GROUP_NS = "groups.";
 
-// The "no group open" sentinel a group's cycle starts from. Group names are
-// forbidden from equaling it, so a cycle's two members are always distinct.
-const GROUP_CLOSED = "closed";
+// [LAW:one-source-of-truth] The closed sentinel and ▸/▾ glyphs are the shared
+// disclosure primitive (src/config/disclosure.ts) — a group is one of its two
+// body-kinds, so it reuses DISCLOSURE_CLOSED / DISCLOSURE_GLYPH_* rather than
+// keeping a second copy that could drift from the menu's. Group names are
+// forbidden from equaling the sentinel, so a cycle's two members are distinct.
 
 // [LAW:types-are-the-program] A group name must be template-addressable — it is
 // spliced into the synthesized `when` predicate and toggle template as
@@ -396,9 +406,6 @@ const GROUP_CLOSED = "closed";
 // dots, so a name needs no escaping anywhere it is spliced.
 const GROUP_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
-const GROUP_GLYPH_CLOSED = "▸";
-const GROUP_GLYPH_OPEN = "▾";
-
 function groupNameSpec(): FieldSpec<string> {
   return {
     required: true,
@@ -408,11 +415,11 @@ function groupNameSpec(): FieldSpec<string> {
       if (
         typeof v !== "string" ||
         !GROUP_NAME_RE.test(v) ||
-        v === GROUP_CLOSED
+        v === DISCLOSURE_CLOSED
       ) {
         ctx.issues.push({
           path: `${path}.${field}`,
-          message: `a group "name" must be an identifier (letters, digits, _; not starting with a digit) and not the reserved "${GROUP_CLOSED}", got ${describeValue(v)}`,
+          message: `a group "name" must be an identifier (letters, digits, _; not starting with a digit) and not the reserved "${DISCLOSURE_CLOSED}", got ${describeValue(v)}`,
           line: findKeyLine(ctx.source, ["root"]),
         });
         return undefined;
@@ -571,17 +578,10 @@ export function synthesizeGroupDecls(
   const groups = ctx.groups;
   if (groups.length === 0) return;
 
-  for (const section of ["variables", "actions", "segments"] as const) {
-    for (const name of Object.keys(out[section] ?? {})) {
-      if (name.startsWith(GROUP_NS)) {
-        groupIssue(
-          ctx,
-          `${section}.${name}`,
-          `"${name}" is in the reserved "${GROUP_NS}" namespace (synthesized by group nodes) — rename it`,
-        );
-      }
-    }
-  }
+  // [LAW:single-enforcer] The disclosure primitive's shared reserved-namespace
+  // enforcer (mirroring {{ menu }}'s `menus.`) — a user name under `groups.`
+  // would silently shadow a synthesized artifact.
+  reservedNamespaceCollisions(ctx, out, GROUP_NS, "group nodes");
 
   const seen = new Set<string>();
   for (const g of groups) {
@@ -617,10 +617,10 @@ export function synthesizeGroupDecls(
   const defaultByKey = new Map<string, string>();
   for (const g of groups) {
     const key = groupStateKey(g);
-    if (!defaultByKey.has(key)) defaultByKey.set(key, GROUP_CLOSED);
+    if (!defaultByKey.has(key)) defaultByKey.set(key, DISCLOSURE_CLOSED);
     if (g.open === true) {
       const prior = defaultByKey.get(key)!;
-      if (prior !== GROUP_CLOSED) {
+      if (prior !== DISCLOSURE_CLOSED) {
         groupIssue(
           ctx,
           g.path,
@@ -645,22 +645,20 @@ export function synthesizeGroupDecls(
       (other) => other !== g && g.path.startsWith(other.path + "."),
     ).length;
     const indent = "  ".repeat(depth);
-    variables[name] = {
-      kind: "state",
-      key,
-      default: defaultByKey.get(key)!,
-    };
-    // Members are ordered default-state-first ("closed" first): an unset or
-    // sibling-held key counts as the first member, so the toggle renders ▸ and
-    // clicks to its own name — expand, auto-closing the sibling on a shared key.
-    actions[name] = { set: key, cycle: [GROUP_CLOSED, g.name] };
+    // [LAW:one-source-of-truth] The shared disclosure toggle: one state var + one
+    // binary cycle action, both from the primitive. Members are ordered default-
+    // state-first (closed first): an unset or sibling-held key counts as the first
+    // member, so the toggle renders ▸ and clicks to its own name — expand, auto-
+    // closing the sibling on a shared key.
+    variables[name] = disclosureStateVar(key, defaultByKey.get(key)!);
+    actions[name] = disclosureCycleAction(key, g.name);
     // [LAW:representation] The disclosure glyph trails the label it gates, so an
     // arrow reads as belonging to the text on its LEFT — adjacent toggles
     // ("details ▸" "links ▸") stay unambiguous even when abutted. `indent` is a
     // structural left-margin (nesting depth) and stays leading; the glyph is a
     // trailing affordance on the label, never a prefix.
     segments[name] = {
-      template: `{{ action "${name}" "${indent}${label} ${GROUP_GLYPH_CLOSED}" "${indent}${label} ${GROUP_GLYPH_OPEN}" }}`,
+      template: `{{ action "${name}" "${indent}${label} ${DISCLOSURE_GLYPH_CLOSED}" "${indent}${label} ${DISCLOSURE_GLYPH_OPEN}" }}`,
       ...(g.bg !== undefined && { bg: g.bg }),
       ...(g.fg !== undefined && { fg: g.fg }),
     };