@promptctl/cc-candybar 1.29.0 → 1.31.0

package/src/config/loader/cross-ref.ts

@@ -15,8 +15,11 @@ import {
 } from "../dsl-types.js";
 import {
   actionBindsPersist,
+  actionBindsRedo,
   actionBindsReset,
   actionBindsSet,
+  actionBindsUndo,
+  type ActionDecl,
 } from "../action.js";
 import {
   knownOptionDomainNames,
@@ -24,6 +27,7 @@ import {
 } from "../option-domain.js";
 import { listGlobalsFieldNames } from "./globals.js";
 import { parsePersistTarget } from "./persist-target.js";
+import { presetNames } from "../presets.js";
 import { findKeyLine } from "./diagnostics.js";
 import { isPlainObject, type ValidateCtx } from "./validate-core.js";
 import {
@@ -116,11 +120,23 @@ export function validateCrossReferences(
     if (target === null) {
       ctx.issues.push({
         path: `actions.${name}.${discriminator}`,
-        message: `actions.${name}: "${key}" is not a config globals field (have: ${listGlobalsFieldNames().join(", ")}) or a "segments.<name>.palette" target`,
+        message: `actions.${name}: "${key}" is not a config globals field (have: ${listGlobalsFieldNames().join(", ")}), a "segments.<name>.palette" target, or a "presets.<name>.rootOps" target`,
         line: findKeyLine(ctx.source, ["actions", name, discriminator]),
       });
       continue;
     }
+    if (target.scope === "preset-root-ops") {
+      checkPresetRootOpsTarget(
+        ctx,
+        cfg,
+        name,
+        discriminator,
+        key,
+        target.preset,
+        a,
+      );
+      continue;
+    }
     if (target.scope !== "segment-palette") continue;
     if (!Object.prototype.hasOwnProperty.call(cfg.segments, target.segment)) {
       ctx.issues.push({
@@ -345,6 +361,76 @@ export function validateCrossReferences(
   }
 }
 
+// [LAW:no-silent-failure] brandon-layout-edit-2gc.1's structural-edit target
+// check, one arm of the persist/reset key cross-ref above. Three things must
+// hold at load time, same spirit as the segment-palette check just above it:
+// the preset name must be real (mirrors globals.preset's check earlier in
+// this function), the arm pairing must make sense for this scope (only
+// removeSegment/insertSegment address a tree — a `to`/`from`/cycle/bounded
+// literal has no meaning as "the current op log"), and every segment name
+// the op names must be declared.
+function checkPresetRootOpsTarget(
+  ctx: ValidateCtx,
+  cfg: DslConfig,
+  name: string,
+  discriminator: "persist" | "reset",
+  key: string,
+  presetName: string,
+  a: ActionDecl,
+): void {
+  const at = `actions.${name}.${discriminator}`;
+  const line = findKeyLine(ctx.source, ["actions", name, discriminator]);
+  if (!presetNames(cfg.presets).includes(presetName)) {
+    ctx.issues.push({
+      path: at,
+      message: `actions.${name}: "${key}" names preset "${presetName}" which is not declared (have: ${presetNames(cfg.presets).join(", ")})`,
+      line,
+    });
+    return;
+  }
+  // [LAW:one-source-of-truth] `reset` has no value-source arm to check — its
+  // shape is a bare `{ reset: key }` — so the arm-pairing/segment checks
+  // below are `persist`-only, exactly as the "reset" action's clean-slate
+  // undo is meant to be: it clears the whole op log regardless of what wrote
+  // it.
+  if (discriminator === "reset") return;
+  const hasRemove = "removeSegment" in a;
+  const hasInsert = "insertSegment" in a;
+  if (!hasRemove && !hasInsert) {
+    ctx.issues.push({
+      path: at,
+      message: `actions.${name}: "${key}" is a "presets.<name>.rootOps" target and can only be paired with "removeSegment" or "insertSegment" (not "to"/"from"/"cycle"/bounded — those have no meaning as a tree op)`,
+      line,
+    });
+    return;
+  }
+  const missing = (segName: string): boolean =>
+    !Object.prototype.hasOwnProperty.call(cfg.segments, segName);
+  if (hasRemove && "removeSegment" in a && missing(a.removeSegment)) {
+    ctx.issues.push({
+      path: at,
+      message: `actions.${name}: removeSegment "${a.removeSegment}" is not a declared segment (have: ${Object.keys(cfg.segments).join(", ")})`,
+      line,
+    });
+  }
+  if (hasInsert && "insertSegment" in a) {
+    if (missing(a.insertSegment)) {
+      ctx.issues.push({
+        path: at,
+        message: `actions.${name}: insertSegment "${a.insertSegment}" is not a declared segment (have: ${Object.keys(cfg.segments).join(", ")})`,
+        line,
+      });
+    }
+    if (missing(a.anchor)) {
+      ctx.issues.push({
+        path: at,
+        message: `actions.${name}: anchor "${a.anchor}" is not a declared segment (have: ${Object.keys(cfg.segments).join(", ")})`,
+        line,
+      });
+    }
+  }
+}
+
 function hasStateKind(cfg: DslConfig): boolean {
   for (const v of Object.values(cfg.variables)) {
     if (v.kind === "state") return true;
@@ -358,15 +444,22 @@ function hasStateKind(cfg: DslConfig): boolean {
   return false;
 }
 
-// [LAW:dataflow-not-control-flow] A config emits a set-state, set-config, OR
-// reset-config click — and so needs session.id — when any declared action is
-// a `set` (literal/option/bounded/cycle), a `persist` (its config-overrides
-// twin), or a `reset` (persist's gated undo) — all three carry session.id on
-// the wire for click-error surfacing. copy/open actions write nothing, so
-// they embed no session.id.
+// [LAW:dataflow-not-control-flow] A config emits a set-state, set-config,
+// reset-config, undo, OR redo click — and so needs session.id — when any
+// declared action is a `set` (literal/option/bounded/cycle), a `persist`
+// (its config-overrides twin), a `reset` (persist's gated undo), or an
+// `undo`/`redo` (the overrides layer's global history step) — all five
+// carry session.id on the wire for click-error surfacing (an empty history
+// stack is a loud, session-scoped miss, not a silent no-op). copy/open
+// actions write nothing, so they embed no session.id.
 function hasActionSetAction(cfg: DslConfig): boolean {
   return Object.values(cfg.actions).some(
-    (a) => actionBindsSet(a) || actionBindsPersist(a) || actionBindsReset(a),
+    (a) =>
+      actionBindsSet(a) ||
+      actionBindsPersist(a) ||
+      actionBindsReset(a) ||
+      actionBindsUndo(a) ||
+      actionBindsRedo(a),
   );
 }
 

package/src/config/loader/persist-target.ts

@@ -16,17 +16,33 @@ import { isGlobalsField } from "./globals.js";
 
 export type PersistTarget =
   | { readonly scope: "globals"; readonly field: keyof Globals }
-  | { readonly scope: "segment-palette"; readonly segment: string };
+  | { readonly scope: "segment-palette"; readonly segment: string }
+  // [LAW:one-source-of-truth] brandon-layout-edit-2gc.1's structural-edit
+  // target — the accumulated op LOG for one preset's root (see
+  // src/config/layout-ops.ts), never the tree itself: a scalar-shaped value
+  // (a JSON-encoded string[] of op tokens) so it rides the SAME flat-dict
+  // overrides file with no shape change to that store's core writer.
+  | { readonly scope: "preset-root-ops"; readonly preset: string };
 
 // [LAW:locality-or-seam] `segments.<name>.palette` reuses the SAME dotted
 // namespacing SegmentDecl.vars already uses for segment-local variables
 // (`<segment>.<var>`, declared in src/dsl/render.ts) — one idiom for "a name
 // scoped under a segment", not a bespoke second syntax invented for persist
-// targets alone.
+// targets alone. `presets.<name>.rootOps` mirrors it one level up (a name
+// scoped under a preset) — deliberately spelled `rootOps`, not `root`, so it
+// never reads as the same string as presetRoot()'s load-time diagnostic path
+// `presets.<name>.root` (src/config/presets.ts), a different namespace this
+// key must never be confused with.
 const SEGMENT_PALETTE_KEY = /^segments\.([^.]+)\.palette$/;
+const PRESET_ROOT_OPS_KEY = /^presets\.([^.]+)\.rootOps$/;
 
 export function parsePersistTarget(key: string): PersistTarget | null {
   if (isGlobalsField(key)) return { scope: "globals", field: key };
-  const match = SEGMENT_PALETTE_KEY.exec(key);
-  return match ? { scope: "segment-palette", segment: match[1]! } : null;
+  const segmentMatch = SEGMENT_PALETTE_KEY.exec(key);
+  if (segmentMatch)
+    return { scope: "segment-palette", segment: segmentMatch[1]! };
+  const presetMatch = PRESET_ROOT_OPS_KEY.exec(key);
+  return presetMatch
+    ? { scope: "preset-root-ops", preset: presetMatch[1]! }
+    : null;
 }

package/src/config/presets.ts

@@ -37,6 +37,7 @@ import type {
   PresetDecl,
 } from "./dsl-types.js";
 import { effectiveMemberName } from "../themes/policy.js";
+import { applyLayoutOps, decodeLayoutOp } from "./layout-ops.js";
 
 // [LAW:one-source-of-truth] The floor preset's name, spelled once. `looks` has
 // `"none"` (the identity adaptation); presets have `"default"` (the identity
@@ -186,3 +187,44 @@ export function sanitizePersistedPresetOverride(
   delete rest.preset;
   return rest;
 }
+
+// [LAW:one-source-of-truth] brandon-layout-edit-2gc.1's replay step — the
+// SAME "patch an already-merged config" shape applySegmentPaletteOverrides
+// (src/config/loader/merge.ts) uses one field over, run at the SAME point in
+// RenderCache.buildState (after the globals/segment-palette overrides, before
+// validateConfig): for every preset with an accumulated op log, resolve its
+// CURRENT root the normal way (presetRoot — bundled/user root, or the
+// preset's own declared fragment) and replay the ops on top, writing the
+// result back as that preset's `root`. Every later reader (presetRoot,
+// registerDslConfig's per-preset compile, validateConfig's cross-ref walk)
+// sees the patched tree as if it had been authored that way — no second
+// resolution path [LAW:locality-or-seam].
+//
+// [LAW:no-silent-failure] exception: an op whose target/anchor names a
+// segment absent from the CURRENT tree is a no-op (layout-ops.ts's own
+// documented policy) — a validated action can only ever name a segment the
+// config declares at the time it was clicked, so a miss here only happens
+// after a LATER edit (a config change, or an earlier op in the same list)
+// already removed it. A malformed individual token (decodeLayoutOp -> null;
+// can only arise from hand-edited or previous-version state, never from this
+// process's own encodeLayoutOp) is filtered the same way, never applied.
+export function applyPresetRootOpsOverrides(
+  config: DslConfig,
+  presetRootOps: Readonly<Record<string, readonly string[]>>,
+): DslConfig {
+  const entries = Object.entries(presetRootOps).filter(
+    ([, tokens]) => tokens.length > 0,
+  );
+  if (entries.length === 0) return config;
+  const presets: Record<string, PresetDecl> = { ...config.presets };
+  for (const [name, tokens] of entries) {
+    const ops = tokens.map(decodeLayoutOp).filter((op) => op !== null);
+    if (ops.length === 0) continue;
+    const { node } = presetRoot(config, name);
+    presets[name] = {
+      ...presetByName(config.presets, name),
+      root: applyLayoutOps(node, ops),
+    };
+  }
+  return { ...config, presets };
+}

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,
     );