@promptctl/cc-candybar 1.29.0 → 1.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/cc-candybar",
-  "version": "1.29.0",
+  "version": "1.30.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,9 +91,9 @@
     "mobx": "^6.15.0"
   },
   "optionalDependencies": {
-    "@promptctl/cc-candybar-darwin-arm64": "1.29.0",
-    "@promptctl/cc-candybar-darwin-x64": "1.29.0",
-    "@promptctl/cc-candybar-linux-x64": "1.29.0",
-    "@promptctl/cc-candybar-linux-arm64": "1.29.0"
+    "@promptctl/cc-candybar-darwin-arm64": "1.30.0",
+    "@promptctl/cc-candybar-darwin-x64": "1.30.0",
+    "@promptctl/cc-candybar-linux-x64": "1.30.0",
+    "@promptctl/cc-candybar-linux-arm64": "1.30.0"
   }
 }

package/schema/cc-candybar.schema.json

@@ -1321,6 +1321,49 @@
             ],
             "additionalProperties": false
           },
+          {
+            "type": "object",
+            "properties": {
+              "persist": {
+                "type": "string"
+              },
+              "removeSegment": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "persist",
+              "removeSegment"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "persist": {
+                "type": "string"
+              },
+              "insertSegment": {
+                "type": "string"
+              },
+              "anchor": {
+                "type": "string"
+              },
+              "relation": {
+                "enum": [
+                  "before",
+                  "after"
+                ]
+              }
+            },
+            "required": [
+              "persist",
+              "insertSegment",
+              "anchor",
+              "relation"
+            ],
+            "additionalProperties": false
+          },
           {
             "type": "object",
             "properties": {

package/src/click/wire.ts

@@ -66,6 +66,17 @@ export const VERB_STEP_CONFIG = "step-config";
 // config-overrides key, restoring the user-file/bundled-default value on the
 // next reload. Args: `[sessionId, key]`.
 export const VERB_RESET_CONFIG = "reset-config";
+// [LAW:one-type-per-behavior] brandon-layout-edit-2gc.1's structural-edit
+// verb — a THIRD write semantic beside set-config's plain overwrite and
+// step-config's numeric read-modify-write: read the current op-token LIST at
+// `key` (a "presets.<name>.rootOps" config-overrides target), append the
+// validated `op` token, write the whole list back. Args: `[sessionId, key,
+// op]` — `op` is one opaque token from src/config/layout-ops.ts's codec, the
+// SAME shape a `persist … to` literal's value would be, gated the SAME way
+// (validateConfigWrite) — only the write's SHAPE (append vs. overwrite)
+// differs, which is exactly why this is its own verb rather than another
+// VERB_SET_CONFIG value.
+export const VERB_APPLY_LAYOUT_OP = "apply-layout-op";
 
 // [LAW:types-are-the-program] An effect to EMIT: a verb plus its raw (unencoded)
 // positional args. The wire owns all encoding — callers never percent-encode.

package/src/config/action.ts

@@ -75,6 +75,14 @@ export type ActionKey = (typeof ACTION_KEYS)[number];
 //                         -> allow-list {members}
 //   copy                — copy templated text to the clipboard -> no gate
 //   open                — open a templated target in the editor -> no gate
+//   removeSegment       — (persist only) remove the named segment from the
+//                         preset-root the `persist` key addresses
+//                         (`presets.<name>.rootOps`) -> allow-list {one op
+//                         token — see src/config/layout-ops.ts}
+//   insertSegment +
+//     anchor + relation  — (persist only) insert a named segment before/after
+//                         an existing one, same key shape -> allow-list {one
+//                         op token}
 //
 // [LAW:one-source-of-truth] `set` writes SessionState and `persist` writes
 // the config-overrides layer, so only those two derive a validator (through
@@ -87,6 +95,15 @@ export type ActionKey = (typeof ACTION_KEYS)[number];
 // arms verbatim (to/from/min-max-by/cycle) MINUS `int`: an unbounded page
 // cursor is a UI-only paging concept (a picker's own navigation state) with
 // no meaning as a persisted config default.
+//
+// [LAW:locality-or-seam] `removeSegment`/`insertSegment` are `persist`-ONLY
+// (brandon-layout-edit-2gc.1) — a structural edit is always a durable,
+// machine-owned write by design (the ticket's own instruction: reuse 71o's
+// writer, land in the SAME overrides layer), so there is no SessionState
+// twin. Every operation is fully literal at config-author time — the
+// segment names and relation are DATA the loader proves at load, not a
+// runtime picker — so each declared action has exactly one legal request,
+// gated the same one-member-allow-list way a literal `to` already is.
 export type ActionDecl =
   | { readonly set: string; readonly to: string }
   | { readonly set: string; readonly from: OptionDomain }
@@ -107,6 +124,13 @@ export type ActionDecl =
       readonly by: number;
     }
   | { readonly persist: string; readonly cycle: readonly string[] }
+  | { readonly persist: string; readonly removeSegment: string }
+  | {
+      readonly persist: string;
+      readonly insertSegment: string;
+      readonly anchor: string;
+      readonly relation: "before" | "after";
+    }
   | { readonly copy: string }
   | { readonly open: string }
   | { readonly reset: string };

package/src/config/layout-ops.ts

@@ -0,0 +1,156 @@
+// [LAW:one-type-per-behavior] The seam brandon-layout-edit-2gc.1 opens: a
+// bounded, statically-enumerable vocabulary for mutating a LayoutNode tree —
+// remove the segment named X, insert a named segment before/after an
+// existing one. No third LayoutNode kind, no free-form tree editing: a
+// segment's own NAME is the stable position (dsl-types.ts already makes it
+// one — SegmentNode.name is a ref into `segments`, unaffected by a sibling
+// being added or removed elsewhere in the tree), so there is no sibling-index
+// to invalidate when a prior op lands.
+//
+// [LAW:no-ambient-temporal-coupling] A position is never a fact frozen at
+// declaration or click time — `removeSegment`/`insertSegment` always walk
+// the CURRENT tree handed to them. The daemon (src/daemon/cache/render.ts)
+// replays the accumulated op log against the live merged config on every
+// reload, so a later, unrelated config edit is what the next replay sees,
+// never a stale snapshot.
+//
+// [LAW:no-silent-failure] exception: a target/anchor absent from the tree is
+// a documented NO-OP, not a thrown error — mirroring
+// src/config/loader/merge.ts's applySegmentPaletteOverrides, the identical
+// failure shape one layer up. A validated action can only ever name a
+// segment the config declares (loader/cross-ref.ts checks this at config
+// load), so a miss here only happens after a LATER edit (to the bundled
+// default, the user's config, or an earlier op in the same accumulated list)
+// removed the segment — there is nothing left to apply the op to, and
+// bricking the whole render over a stale op would be worse than dropping it.
+
+import type { LayoutNode, SegmentNode } from "./dsl-types.js";
+
+// [LAW:types-are-the-program] The two operations brandon-layout-edit-2gc.1
+// ships. Both address position by NAME, never by index. A future op (e.g.
+// "move") is a new arm here, not a new node kind or a new codec.
+export type LayoutOp =
+  | { readonly op: "remove"; readonly target: string }
+  | {
+      readonly op: "insert";
+      readonly segment: string;
+      readonly anchor: string;
+      readonly relation: "before" | "after";
+    };
+
+// [LAW:single-enforcer] THE codec for a LayoutOp crossing the click wire and
+// the config-overrides file as one opaque string. `:` is the delimiter
+// (loader/actions.ts's segmentNameSpec rejects `:` and `/` in every name an
+// op can carry, so decode is unambiguous — a plain split, no escaping).
+// Encode and decode live together so the format cannot drift between the
+// validator gate (config-validators.ts, which encodes the ONE token a
+// declared action allows), the render side (which emits that same token),
+// and the daemon (which decodes it back).
+export function encodeLayoutOp(op: LayoutOp): string {
+  return op.op === "remove"
+    ? `remove:${op.target}`
+    : `insert:${op.segment}:${op.anchor}:${op.relation}`;
+}
+
+// [LAW:parse-dont-validate] Returns the typed op, or null for anything that
+// doesn't decode — the boundary a caller stamps before trusting the shape.
+// Reached only from data this process did not itself just encode (a
+// hand-edited or previous-version config-overrides.json), never from a
+// value produced by encodeLayoutOp in the same click.
+export function decodeLayoutOp(token: string): LayoutOp | null {
+  const parts = token.split(":");
+  if (parts[0] === "remove" && parts.length === 2 && parts[1]) {
+    return { op: "remove", target: parts[1] };
+  }
+  if (
+    parts[0] === "insert" &&
+    parts.length === 4 &&
+    parts[1] &&
+    parts[2] &&
+    (parts[3] === "before" || parts[3] === "after")
+  ) {
+    return {
+      op: "insert",
+      segment: parts[1],
+      anchor: parts[2],
+      relation: parts[3],
+    };
+  }
+  return null;
+}
+
+// [LAW:dataflow-not-control-flow] Ops are DATA folded over the tree in
+// order — replaying zero ops is the identity fold, replaying N is the same
+// reduce for every N. No branch on "are there ops to apply."
+export function applyLayoutOps(
+  root: LayoutNode,
+  ops: readonly LayoutOp[],
+): LayoutNode {
+  return ops.reduce(applyOne, root);
+}
+
+function applyOne(root: LayoutNode, op: LayoutOp): LayoutNode {
+  return op.op === "remove"
+    ? removeSegment(root, op.target)
+    : insertSegment(root, op.segment, op.anchor, op.relation);
+}
+
+// [LAW:types-are-the-program] Total and non-throwing: every LayoutNode maps
+// to a LayoutNode, whether or not `target` is present. Acts on the FIRST
+// segment found named `target`, in walkNodes' canonical pre-order — a
+// deterministic, documented tie-break for the edge case of a duplicate name,
+// never an ambiguous or thrown outcome. `done` is a closure-local flag (fresh
+// per call, never shared across calls) that stops the search the instant a
+// match is spliced out, so an EARLIER sibling's match always wins over a
+// LATER one — exactly walkNodes' visit order, not merely "this container's
+// own children before its descendants" (a subtly different, wrong order a
+// single-pass children-array scan would produce). An absent target returns
+// the identical root reference.
+function removeSegment(root: LayoutNode, target: string): LayoutNode {
+  let done = false;
+  function walk(node: LayoutNode): LayoutNode {
+    if (done || node.kind === "segment") return node;
+    const children: LayoutNode[] = [];
+    for (const child of node.children) {
+      if (!done && child.kind === "segment" && child.name === target) {
+        done = true;
+        continue;
+      }
+      children.push(walk(child));
+    }
+    return { ...node, children };
+  }
+  const result = walk(root);
+  return done ? result : root;
+}
+
+// [LAW:types-are-the-program] Splices a new `{ kind: "segment", name:
+// segment }` node immediately before/after the FIRST node found named
+// `anchor`, in walkNodes' canonical pre-order (see removeSegment's `done`
+// note — the same closure-local stop-at-first-match shape). Total and
+// non-throwing: an absent anchor returns the identical root reference.
+function insertSegment(
+  root: LayoutNode,
+  segment: string,
+  anchor: string,
+  relation: "before" | "after",
+): LayoutNode {
+  let done = false;
+  function walk(node: LayoutNode): LayoutNode {
+    if (done || node.kind === "segment") return node;
+    const children: LayoutNode[] = [];
+    for (const child of node.children) {
+      if (!done && child.kind === "segment" && child.name === anchor) {
+        done = true;
+        const inserted: SegmentNode = { kind: "segment", name: segment };
+        if (relation === "before") children.push(inserted, child);
+        else children.push(child, inserted);
+        continue;
+      }
+      children.push(walk(child));
+    }
+    return { ...node, children };
+  }
+  const result = walk(root);
+  return done ? result : root;
+}

package/src/config/loader/actions.ts

@@ -324,6 +324,25 @@ const CYCLE_FIELDS_SET: FieldSpecMap<{ cycle: readonly string[] }> = {
 const CYCLE_FIELDS_PERSIST: FieldSpecMap<{ cycle: readonly string[] }> = {
   cycle: cycleSpec("persist"),
 };
+// [LAW:one-type-per-behavior] brandon-layout-edit-2gc.1's two structural-edit
+// arms — PERSIST-only (see action.ts's ActionDecl doc comment for why there
+// is no `set` twin). Each field reuses layoutNameSpec: a segment/anchor name
+// must be non-empty and free of both `/` (the click wire's own segment
+// delimiter) and `:` (layout-ops.ts's op-token delimiter) — the SAME
+// wire-safety diligence slashFreeString already applies to `to`/`cycle`
+// members, one forbidden character wider.
+const REMOVE_SEGMENT_FIELDS: FieldSpecMap<{ removeSegment: string }> = {
+  removeSegment: layoutNameSpec("removeSegment"),
+};
+const INSERT_SEGMENT_FIELDS: FieldSpecMap<{
+  insertSegment: string;
+  anchor: string;
+  relation: "before" | "after";
+}> = {
+  insertSegment: layoutNameSpec("insertSegment"),
+  anchor: layoutNameSpec("anchor"),
+  relation: relationSpec(),
+};
 
 // [LAW:types-are-the-program] A bounded step is fully described by an integer
 // domain (min < max) and a non-zero integer increment (`by`; negative for a
@@ -418,16 +437,49 @@ const SET_ARMS: readonly ValueSourceArm[] = [
 
 // [LAW:one-type-per-behavior] `persist` mirrors `set` minus the `int` arm — a
 // page cursor is a UI-only paging concept with no meaning as a persisted
-// config default (see action.ts's ActionDecl comment).
+// config default (see action.ts's ActionDecl comment). `removeSegment`/
+// `insertSegment` are ADDITIONAL persist-only arms with no `set` counterpart.
 const PERSIST_ARMS: readonly ValueSourceArm[] = [
   valueSourceArm("persist", TO_FIELDS_PERSIST),
   valueSourceArm("persist", FROM_FIELDS_PERSIST),
   valueSourceArm("persist", BOUNDED_FIELDS, minLessThanMax, byNonZero),
   valueSourceArm("persist", CYCLE_FIELDS_PERSIST),
+  valueSourceArm("persist", REMOVE_SEGMENT_FIELDS),
+  valueSourceArm("persist", INSERT_SEGMENT_FIELDS),
 ];
 
-const VALUE_SOURCE_MESSAGE = (discriminator: "set" | "persist") =>
-  `a ${discriminator} action declares exactly one value source: "to" (a literal value), "from" (an option domain — a registered domain name like "themes"/"styles"/"looks", or an inline array of literal values), "min"/"max"/"by" (a bounded step)${discriminator === "set" ? `, "int" (an unbounded integer cursor)` : ""}, or "cycle" (an enumerated domain stepped in order)`;
+// [LAW:one-source-of-truth] The clause list, not the joined string, is the
+// data that varies per discriminator — the "or" belongs on the LAST clause
+// only, and which clause is last differs between `set` (ends at cycle) and
+// `persist` (ends at insertSegment), so building a list and joining it is
+// what keeps that placement correct without a second copy of the sentence.
+function valueSourceClauses(discriminator: "set" | "persist"): string[] {
+  const clauses = [
+    `"to" (a literal value)`,
+    `"from" (an option domain — a registered domain name like "themes"/"styles"/"looks", or an inline array of literal values)`,
+    `"min"/"max"/"by" (a bounded step)`,
+  ];
+  if (discriminator === "set")
+    clauses.push(`"int" (an unbounded integer cursor)`);
+  clauses.push(`"cycle" (an enumerated domain stepped in order)`);
+  if (discriminator === "persist") {
+    clauses.push(
+      `"removeSegment" (remove a named segment from the layout)`,
+      `"insertSegment"/"anchor"/"relation" (insert a named segment before/after an existing one)`,
+    );
+  }
+  return clauses;
+}
+
+function VALUE_SOURCE_MESSAGE(discriminator: "set" | "persist"): string {
+  const clauses = valueSourceClauses(discriminator);
+  const last = clauses[clauses.length - 1]!;
+  const list =
+    clauses.length === 1
+      ? last
+      : `${clauses.slice(0, -1).join(", ")}, or ${last}`;
+  return `a ${discriminator} action declares exactly one value source: ${list}`;
+}
 
 // [LAW:dataflow-not-control-flow] The set/persist sub-union eliminator:
 // validate the shared discriminator key, count which value sources are
@@ -681,6 +733,61 @@ function intMarkerSpec(): FieldSpec<true> {
   };
 }
 
+// [LAW:one-source-of-truth] A layout op's segment-name field (removeSegment /
+// insertSegment / anchor) is non-empty and free of BOTH wire-structural
+// characters: `/` (the click wire's own multi-arg segment delimiter, the
+// same restriction slashFreeString already enforces for `to`/`cycle`) and
+// `:` (layout-ops.ts's op-token delimiter — a name containing it would make
+// encodeLayoutOp's output ambiguous to decode). One spec, three callsites,
+// so the two-character restriction can't drift between them.
+function layoutNameSpec(field: string): FieldSpec<string> {
+  return {
+    required: true,
+    json: { type: "string" },
+    parse: (ctx, path, f, raw) => {
+      const v = requireString(ctx, path, raw, f);
+      if (v === null) return undefined;
+      const at = `${path}.${f}`;
+      if (v === "") {
+        issue(ctx, at, `${field} must be non-empty (a segment name)`);
+        return undefined;
+      }
+      if (v.includes("/") || v.includes(":")) {
+        issue(
+          ctx,
+          at,
+          `${field} "${v}" contains "/" or ":" — segment names in a layout op must be free of both (the click wire's own delimiter and layout-ops.ts's op-token delimiter)`,
+        );
+        return undefined;
+      }
+      return v;
+    },
+  };
+}
+
+// [LAW:types-are-the-program] `relation` is a closed two-value enum, not a
+// free string — a typo (`"befor"`) is a load error, never a click-time
+// surprise. Mirrors intMarkerSpec's "one legal literal" shape, widened to
+// two.
+function relationSpec(): FieldSpec<"before" | "after"> {
+  return {
+    required: true,
+    json: { enum: ["before", "after"] },
+    parse: (ctx, path, field, raw) => {
+      const v = raw[field];
+      if (v !== "before" && v !== "after") {
+        issue(
+          ctx,
+          `${path}.${field}`,
+          `relation must be "before" or "after", got ${describeValue(v)}`,
+        );
+        return undefined;
+      }
+      return v;
+    },
+  };
+}
+
 // [LAW:types-are-the-program] A required integer field — the field key (min / max
 // / by) comes from the map, the message names it. A non-integer or absent value
 // reports and fails the arm.

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

@@ -17,6 +17,7 @@ import {
   actionBindsPersist,
   actionBindsReset,
   actionBindsSet,
+  type ActionDecl,
 } from "../action.js";
 import {
   knownOptionDomainNames,
@@ -24,6 +25,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 +118,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 +359,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;

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 };
+}