@promptctl/cc-candybar 1.29.0 → 1.30.0

package/src/daemon/cache/render.ts

@@ -25,7 +25,10 @@ import {
 } from "../verbs/config-validators.js";
 import { loadOverrides } from "../config-overrides-store.js";
 import { configOverridesPath } from "../paths.js";
-import { sanitizePersistedPresetOverride } from "../../config/presets.js";
+import {
+  applyPresetRootOpsOverrides,
+  sanitizePersistedPresetOverride,
+} from "../../config/presets.js";
 import { VariableStore } from "../../var-system/store.js";
 import { SourceRegistry } from "../../var-system/sources.js";
 import type { GitDataProvider } from "./git.js";
@@ -324,8 +327,20 @@ export class RenderCache {
       withGlobalsOverrides,
       overrides.segmentPalette,
     );
-    const config = validateConfig(
+    // [LAW:one-source-of-truth] brandon-layout-edit-2gc.1's replay step —
+    // the SAME "patch an already-merged config" cascade as the segment-
+    // palette overlay above, one field over (a preset's `root` instead of a
+    // segment's `palette`). Runs last so validateConfig's cross-ref walk
+    // proves the OPS-PATCHED tree, not the pre-edit one — a structural edit
+    // that referenced a segment removed by a later config change is caught
+    // exactly like a hand-authored preset root naming the same segment would
+    // be.
+    const withPresetRootOps = applyPresetRootOpsOverrides(
       withOverrides,
+      overrides.presetRootOps,
+    );
+    const config = validateConfig(
+      withPresetRootOps,
       resolvedPath ?? "<default>",
       source,
     );

package/src/daemon/config-overrides-store.ts

@@ -100,7 +100,17 @@ export function coercePersistValue(
       `coercePersistValue: "${key}" is not a valid persist target`,
     );
   }
-  if (target.scope === "segment-palette") return raw;
+  // [LAW:one-type-per-behavior] Both non-globals scopes are always a NAME/
+  // TOKEN string — segment-palette's value is a palette name, preset-root-ops'
+  // is one op token appended by the daemon's apply-layout-op verb handler
+  // (never a bare `persist` write — see verbs/index.ts). Neither has a
+  // GLOBALS_FIELD_KIND row because neither is a Globals field.
+  if (
+    target.scope === "segment-palette" ||
+    target.scope === "preset-root-ops"
+  ) {
+    return raw;
+  }
   const kind = GLOBALS_FIELD_KIND[target.field];
   if (kind === "string") return raw;
   if (kind === "number") {
@@ -136,9 +146,7 @@ function isValidOverrides(
     const target = parsePersistTarget(key);
     if (target === null) return false;
     const kind =
-      target.scope === "segment-palette"
-        ? "string"
-        : GLOBALS_FIELD_KIND[target.field];
+      target.scope === "globals" ? GLOBALS_FIELD_KIND[target.field] : "string";
     if (kind === "number" && typeof v !== "number") return false;
     if (kind === "boolean" && typeof v !== "boolean") return false;
     if (kind === "string" && typeof v !== "string") return false;
@@ -237,6 +245,46 @@ function projectSegmentPaletteOverrides(
   return out;
 }
 
+// [LAW:one-source-of-truth] The preset-root-ops-scoped VIEW of the SAME raw
+// dict — preset name -> the accumulated op-token LIST (brandon-layout-edit-
+// 2gc.1's structural-edit log; see src/config/layout-ops.ts). This is a
+// SHAPE check only (well-formed JSON array of strings) — decoding each
+// token into a typed LayoutOp, and applying the ops to a tree, is presets.ts's
+// job, not this storage-layer module's [LAW:decomposition]. A stored value
+// that isn't a JSON array of strings drops for THAT preset only (a warn log,
+// never a crash of the whole overrides file) — the identical "the world
+// moved on since this was written" recovery projectSegmentPaletteOverrides
+// already gets, one level narrower.
+function projectPresetRootOpsOverrides(
+  raw: Readonly<Record<string, string | number | boolean>>,
+  logger: DaemonLogger,
+): Readonly<Record<string, readonly string[]>> {
+  const out: Record<string, readonly string[]> = Object.create(null) as Record<
+    string,
+    readonly string[]
+  >;
+  for (const [key, value] of Object.entries(raw)) {
+    const target = parsePersistTarget(key);
+    if (target?.scope !== "preset-root-ops" || typeof value !== "string") {
+      continue;
+    }
+    try {
+      const parsed: unknown = JSON.parse(value);
+      if (Array.isArray(parsed) && parsed.every((t) => typeof t === "string")) {
+        out[target.preset] = parsed;
+        continue;
+      }
+    } catch {
+      // fall through to the warn below
+    }
+    logger(
+      "warn",
+      `config-overrides: "${key}" is not a valid op-token list, dropping`,
+    );
+  }
+  return out;
+}
+
 export function loadConfigOverrides(
   filePath: string,
   logger: DaemonLogger = quietLogger,
@@ -251,14 +299,15 @@ export function loadSegmentPaletteOverrides(
   return projectSegmentPaletteOverrides(loadRawOverrides(filePath, logger));
 }
 
-// [LAW:carrying-cost] RenderCache wants BOTH views on every reload
-// (buildState merges globals overrides, then overlays segment-palette
-// overrides) — calling loadConfigOverrides + loadSegmentPaletteOverrides
-// back to back would read, parse, and shape-validate the same tiny file
-// twice per reload for no reason. One read, two projections.
+// [LAW:carrying-cost] RenderCache wants ALL THREE views on every reload
+// (buildState merges globals overrides, overlays segment-palette overrides,
+// then replays preset-root-ops overrides) — calling the scoped loaders back
+// to back would read, parse, and shape-validate the same tiny file three
+// times per reload for no reason. One read, three projections.
 export interface Overrides {
   readonly globals: Partial<Globals>;
   readonly segmentPalette: Readonly<Record<string, string>>;
+  readonly presetRootOps: Readonly<Record<string, readonly string[]>>;
 }
 
 export function loadOverrides(
@@ -269,6 +318,7 @@ export function loadOverrides(
   return {
     globals: projectGlobalsOverrides(raw),
     segmentPalette: projectSegmentPaletteOverrides(raw),
+    presetRootOps: projectPresetRootOpsOverrides(raw, logger),
   };
 }
 

package/src/daemon/verbs/config-validators.ts

@@ -17,6 +17,7 @@ import {
 } from "../../config/option-domain";
 import type { DslConfig } from "../../config/dsl-types";
 import { isGlobalsField } from "../config-overrides-store";
+import { encodeLayoutOp } from "../../config/layout-ops";
 import {
   clampSeed,
   createValidatorRegistry,
@@ -73,6 +74,43 @@ function actionKeySpecs(
   if ("cycle" in a) {
     return [{ key: a.persist, spec: { kind: "allow-list", allowed: a.cycle } }];
   }
+  // [LAW:single-enforcer] brandon-layout-edit-2gc.1's structural-edit arms:
+  // the op is fully literal at config-author time (removeSegment's target,
+  // insertSegment's segment/anchor/relation), so — exactly like a literal
+  // `to` — there is exactly ONE legal value this declared action can ever
+  // request: its own encoded op token. Multiple layout actions targeting the
+  // same "presets.<name>.rootOps" key each contribute one allow-list member,
+  // unioned by mergeContributions below, same as multiple `to` actions on
+  // one key already do.
+  if ("removeSegment" in a) {
+    return [
+      {
+        key: a.persist,
+        spec: {
+          kind: "allow-list",
+          allowed: [encodeLayoutOp({ op: "remove", target: a.removeSegment })],
+        },
+      },
+    ];
+  }
+  if ("insertSegment" in a) {
+    return [
+      {
+        key: a.persist,
+        spec: {
+          kind: "allow-list",
+          allowed: [
+            encodeLayoutOp({
+              op: "insert",
+              segment: a.insertSegment,
+              anchor: a.anchor,
+              relation: a.relation,
+            }),
+          ],
+        },
+      },
+    ];
+  }
   return [
     {
       key: a.persist,

package/src/daemon/verbs/index.ts

@@ -36,12 +36,15 @@ import {
   coercePersistValue,
   isGlobalsField,
   loadConfigOverrides,
+  loadOverrides,
   writeConfigOverride,
 } from "../config-overrides-store";
 import { configOverridesPath } from "../paths";
+import { parsePersistTarget } from "../../config/loader/persist-target";
 import {
   decodeSegments,
   parseEffects,
+  VERB_APPLY_LAYOUT_OP,
   VERB_COPY,
   VERB_DISPATCH,
   VERB_OPEN_VSCODE,
@@ -444,6 +447,48 @@ const resetConfig: VerbHandler = (value, ctx) => {
   ctx.dlog("info", `reset-config: ${key} (session=${sid})`);
 };
 
+// [LAW:one-source-of-truth] brandon-layout-edit-2gc.1's structural-edit
+// write: a THIRD config-overrides write shape beside setConfig's overwrite
+// and stepConfig's numeric read-modify-write — read the current op-token
+// list at `key`, append the validated op, write the whole list back. Gated
+// by the SAME allow-list machinery setConfig uses (validateConfigWrite,
+// derived from a config's declared removeSegment/insertSegment actions) —
+// an op token no action declares is a loud BAD_REQUEST, never silently
+// appended. `key` must resolve to the preset-root-ops scope specifically
+// (never a globals/segment-palette key smuggled in through this verb) —
+// checked here rather than trusted from the gate, since the gate only
+// proves the VALUE is allowed for that key, not that the key's SCOPE
+// matches this verb's read-modify-write shape.
+const applyLayoutOp: VerbHandler = (rawValue, ctx) => {
+  const [sessionId = "", key = "", opToken = ""] = decodeWire(() =>
+    decodeSegments(rawValue),
+  );
+  const sid = requireSessionId(sessionId);
+  if (!key) {
+    throw new BadVerbArgs(
+      `apply-layout-op: <key>/<op> is required (have: ${listConfigKeys().join(", ")})`,
+    );
+  }
+  const result = validateConfigWrite(key, opToken);
+  if (!result.ok) throw new BadVerbArgs(`apply-layout-op: ${result.reason}`);
+  const target = parsePersistTarget(key);
+  if (target === null || target.scope !== "preset-root-ops") {
+    throw new BadVerbArgs(
+      `apply-layout-op: "${key}" is not a "presets.<name>.rootOps" target`,
+    );
+  }
+  const existing =
+    loadOverrides(configOverridesPath(), ctx.dlog).presetRootOps[
+      target.preset
+    ] ?? [];
+  const next = JSON.stringify([...existing, result.value]);
+  writeConfigOverride(configOverridesPath(), key, next, ctx.dlog);
+  ctx.dlog(
+    "info",
+    `apply-layout-op: ${key} += ${result.value} (session=${sid})`,
+  );
+};
+
 // ─── Registry ───────────────────────────────────────────────────────────────
 
 // [LAW:one-source-of-truth] The LEAF verbs — every click effect that does real
@@ -505,6 +550,7 @@ const LEAF_VERBS = new Map<string, VerbHandler>([
   [VERB_SET_CONFIG, setConfig],
   [VERB_STEP_CONFIG, stepConfig],
   [VERB_RESET_CONFIG, resetConfig],
+  [VERB_APPLY_LAYOUT_OP, applyLayoutOp],
   [VERB_SHOW_CONFIG_ERROR, showConfigError],
   [VERB_SHOW_CONFIG_WARNING, showConfigWarning],
   [VERB_TOOLBAR_TOGGLE, toolbarToggle],
@@ -536,9 +582,9 @@ const dispatch: VerbHandler = (rawValue, ctx) => {
   let sessionId: string | null = null;
   for (const { verb, value } of parseEffects(rawValue)) {
     // Extract session ID from the first session-bearing effect for error display.
-    // set-state, step-state, set-config, step-config, reset-config, and
-    // toolbar-toggle all carry the session id as their first segment, so a
-    // failing step surfaces in the bar like any other.
+    // set-state, step-state, set-config, step-config, reset-config,
+    // apply-layout-op, and toolbar-toggle all carry the session id as their
+    // first segment, so a failing step surfaces in the bar like any other.
     if (
       !sessionId &&
       (verb === VERB_SET_STATE ||
@@ -546,6 +592,7 @@ const dispatch: VerbHandler = (rawValue, ctx) => {
         verb === VERB_SET_CONFIG ||
         verb === VERB_STEP_CONFIG ||
         verb === VERB_RESET_CONFIG ||
+        verb === VERB_APPLY_LAYOUT_OP ||
         verb === VERB_TOOLBAR_TOGGLE)
     ) {
       const parts = decodeSegments(value);

package/src/render/action.ts

@@ -27,9 +27,11 @@ import { toString as varToString } from "../var-system/types.js";
 import { buildScope } from "../template-engine/scope.js";
 import type { ActionDecl } from "../config/action.js";
 import { resolveOptionDomain } from "../config/option-domain.js";
+import { encodeLayoutOp, type LayoutOp } from "../config/layout-ops.js";
 import type { StripStyle } from "../themes/policy.js";
 import {
   effectsUrl,
+  VERB_APPLY_LAYOUT_OP,
   VERB_COPY,
   VERB_OPEN_VSCODE,
   VERB_RESET_CONFIG,
@@ -135,7 +137,12 @@ export type CompiledActionDecl =
   // one config-overrides key. Carries only the key — there is no value to
   // realize, so it shares copy/open's "no gate" shape at compile time (the
   // GATE is the key-membership check the reset-config verb handler applies).
-  | { readonly kind: "reset"; readonly key: string };
+  | { readonly kind: "reset"; readonly key: string }
+  // [LAW:one-source-of-truth] brandon-layout-edit-2gc.1's structural-edit
+  // arms. Fully literal at compile time (the op IS the declaration — no
+  // template-bound option, unlike persist-option), so `op` is precomputed
+  // here rather than reconstructed from raw fields at every realize() call.
+  | { readonly kind: "layout-op"; readonly key: string; readonly op: LayoutOp };
 
 export type CompiledActions = ReadonlyMap<string, CompiledActionDecl>;
 
@@ -294,6 +301,25 @@ function compileAction(
         members: action.cycle,
       };
     }
+    if ("removeSegment" in action) {
+      return {
+        kind: "layout-op",
+        key: action.persist,
+        op: { op: "remove", target: action.removeSegment },
+      };
+    }
+    if ("insertSegment" in action) {
+      return {
+        kind: "layout-op",
+        key: action.persist,
+        op: {
+          op: "insert",
+          segment: action.insertSegment,
+          anchor: action.anchor,
+          relation: action.relation,
+        },
+      };
+    }
     return {
       kind: "persist-bounded",
       key: action.persist,
@@ -522,6 +548,20 @@ function realize(
         effect: { verb: VERB_RESET_CONFIG, args: [sessionId, c.key] },
         active: false,
       };
+    // [LAW:one-source-of-truth] The op is fixed at compile time (see
+    // compileAction) — the click just delivers it. `apply-layout-op`'s
+    // handler does read-current-append-write (see verbs/index.ts), unlike
+    // persist-literal's plain overwrite, so it is its own verb rather than
+    // VERB_SET_CONFIG. Never "active": a structural edit is a one-shot
+    // trigger, not a current-selection toggle.
+    case "layout-op":
+      return {
+        effect: {
+          verb: VERB_APPLY_LAYOUT_OP,
+          args: [sessionId, c.key, encodeLayoutOp(c.op)],
+        },
+        active: false,
+      };
   }
 }