@promptctl/cc-candybar 1.30.0 → 1.31.0

package/package.json

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

package/schema/cc-candybar.schema.json

@@ -1399,6 +1399,30 @@
               "reset"
             ],
             "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "undo": {
+                "const": true
+              }
+            },
+            "required": [
+              "undo"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "redo": {
+                "const": true
+              }
+            },
+            "required": [
+              "redo"
+            ],
+            "additionalProperties": false
           }
         ]
       }

package/src/click/wire.ts

@@ -77,6 +77,15 @@ export const VERB_RESET_CONFIG = "reset-config";
 // 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:one-source-of-truth] brandon-layout-edit-2gc.2's global history step
+// over the config-overrides layer — the fine-grained sibling of
+// VERB_RESET_CONFIG's coarse "clear one key". Args: `[sessionId]` — there is
+// no key: the history is ONE stack over every persist/reset write ever made
+// to the overrides file (config-overrides-store.ts), not a per-key log. An
+// empty stack is a loud BAD_REQUEST surfaced through click.error like any
+// other verb failure, never a silent no-op.
+export const VERB_UNDO = "undo";
+export const VERB_REDO = "redo";
 
 // [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

@@ -43,7 +43,24 @@ export type { OptionDomain } from "./option-domain.js";
 // overrides layer (never the hand-authored config file). `reset` clears one
 // persisted override — the gated undo `persist` needs, since a machine-owned
 // write with no way back would be a one-way ratchet.
-export const ACTION_KEYS = ["set", "persist", "copy", "open", "reset"] as const;
+//
+// [LAW:one-source-of-truth] `undo`/`redo` (brandon-layout-edit-2gc.2) are
+// `reset`'s FINE-GRAINED siblings: `reset` clears one named key outright
+// (the coarse "forget this override" case); `undo`/`redo` step ONE GLOBAL
+// history of every `persist`/`reset` write ever made to the overrides layer
+// — every key, not just structural layout edits — back and forth. Neither
+// carries a key: the history is a single stack over the whole overrides
+// file (config-overrides-store.ts owns it), so the action is a bare marker,
+// like `int: true` is for a set-int cursor.
+export const ACTION_KEYS = [
+  "set",
+  "persist",
+  "copy",
+  "open",
+  "reset",
+  "undo",
+  "redo",
+] as const;
 export type ActionKey = (typeof ACTION_KEYS)[number];
 
 // [LAW:types-are-the-program] An ActionDecl is the click effect a named action
@@ -75,6 +92,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
+//   undo                — step the config-overrides layer's GLOBAL history one
+//                         entry back (any persist/reset write, not just a
+//                         layout op) -> no gate, no key: there is nothing a
+//                         template could smuggle, since the value restored is
+//                         whatever the daemon's own history recorded, never
+//                         wire input
+//   redo                — the inverse of undo: re-apply the most recently
+//                         undone entry -> no gate, no key
 //   removeSegment       — (persist only) remove the named segment from the
 //                         preset-root the `persist` key addresses
 //                         (`presets.<name>.rootOps`) -> allow-list {one op
@@ -133,7 +158,9 @@ export type ActionDecl =
     }
   | { readonly copy: string }
   | { readonly open: string }
-  | { readonly reset: string };
+  | { readonly reset: string }
+  | { readonly undo: true }
+  | { readonly redo: true };
 
 // [LAW:dataflow-not-control-flow] Does this action write a SessionState key? A
 // `set` action composes a set-state click URL whose first segment is session.id;
@@ -155,3 +182,14 @@ export function actionBindsPersist(a: ActionDecl): boolean {
 export function actionBindsReset(a: ActionDecl): boolean {
   return "reset" in a;
 }
+
+// [LAW:dataflow-not-control-flow] Does this action step the config-overrides
+// history? `undo`/`redo` carry session.id on the wire too — same reason as
+// `reset`: an empty stack is a loud, session-scoped click.error, not a
+// silent no-op (the ticket's own done-gate).
+export function actionBindsUndo(a: ActionDecl): boolean {
+  return "undo" in a;
+}
+export function actionBindsRedo(a: ActionDecl): boolean {
+  return "redo" in a;
+}

package/src/config/loader/actions.ts

@@ -145,6 +145,8 @@ const ACTION_ARMS: Record<ActionKey, ArmParse<ActionDecl>> = {
   copy: templateArm("copy"),
   open: templateArm("open"),
   reset: resetArm,
+  undo: markerArm("undo"),
+  redo: markerArm("redo"),
 };
 
 // [LAW:one-source-of-truth] A copy/open action emits the closed single-key
@@ -170,6 +172,8 @@ function actionDeclJson(): JsonNode {
       templateArmJson("copy"),
       templateArmJson("open"),
       templateArmJson("reset"),
+      markerArmJson("undo"),
+      markerArmJson("redo"),
     ],
   };
 }
@@ -228,6 +232,47 @@ function resetArm(
   return key === null ? null : { reset: key };
 }
 
+// [LAW:one-type-per-behavior] `undo`/`redo` are copy/open/reset's shape one
+// step further reduced: a single required key whose only legal VALUE is the
+// literal `true` (mirrors intMarkerSpec — a marker, not data), because there
+// is no key to name: the history they step is one global stack over the
+// whole overrides layer, not a per-target write. `function`, not a const
+// arrow, so ACTION_ARMS above (built before this declaration in source
+// order) can reference it directly via hoisting.
+function markerArm(key: "undo" | "redo"): ArmParse<ActionDecl> {
+  return (ctx, path, raw) => {
+    for (const k of Object.keys(raw)) {
+      if (k !== key)
+        issue(
+          ctx,
+          `${path}.${k}`,
+          `Unknown key "${k}" on a ${key} action. Expected only: ${key}`,
+        );
+    }
+    if (raw[key] !== true) {
+      issue(
+        ctx,
+        `${path}.${key}`,
+        `${key} must be the literal true (it takes no key — it steps the ONE global history over the whole overrides layer), got ${describeValue(raw[key])}`,
+      );
+      return null;
+    }
+    return { [key]: true } as unknown as ActionDecl;
+  };
+}
+
+// [LAW:one-source-of-truth] Mirrors templateArmJson's shape one level
+// narrower: the value schema is `const: true`, not `type: string` — a
+// marker action carries no data, on the wire or in the schema.
+function markerArmJson(key: "undo" | "redo"): JsonNode {
+  return {
+    type: "object",
+    properties: { [key]: { const: true } },
+    required: [key],
+    additionalProperties: false,
+  };
+}
+
 // ─── The `set` value-source sub-union ────────────────────────────────────────
 
 // [LAW:single-enforcer] A set-state URL path segment must be a non-empty,

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

@@ -15,8 +15,10 @@ import {
 } from "../dsl-types.js";
 import {
   actionBindsPersist,
+  actionBindsRedo,
   actionBindsReset,
   actionBindsSet,
+  actionBindsUndo,
   type ActionDecl,
 } from "../action.js";
 import {
@@ -442,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/daemon/config-overrides-store.ts

@@ -322,43 +322,94 @@ export function loadOverrides(
   };
 }
 
-// [LAW:no-silent-failure] Atomic write shared by set/clear: read the current
-// overrides, apply one mutation, write-to-temp + rename. Owner-only mode,
-// matching every other daemon runtime file (session-state.json, pid, lease).
+// [LAW:no-silent-failure] The atomic write/rename dance, generalized over ANY
+// JSON-serializable value — both this module's flat overrides dict and its
+// history stack (below) go through this one primitive rather than each
+// re-implementing mkdir+tmp+chmod+rename. Owner-only mode, matching every
+// other daemon runtime file (session-state.json, pid, lease). `label` names
+// the failure in the log/thrown message (the caller's own vocabulary —
+// "config-overrides"/"config-overrides-history" — not derived from the path,
+// so the wording a test might match on stays stable across either file).
 // Unlike session-state.json's debounced best-effort flush (no synchronous
-// caller waiting on it), a `persist` write is directly caused by a click that
-// expects a truthful ack — a swallowed failure here would let the verb
-// handler log "set-config: ..." as if it landed when nothing was written.
-// Logs at "error" for the daemon-log breadcrumb, then RETHROWS so the caller
-// (the click) fails loudly instead of claiming a success that didn't happen.
-function writeOverrides(
+// caller waiting on it), a `persist`/`undo`/`redo` write is directly caused
+// by a click that expects a truthful ack — a swallowed failure here would let
+// the verb handler log success for a write that didn't land. Logs at "error"
+// for the daemon-log breadcrumb, then RETHROWS so the caller (the click)
+// fails loudly instead of claiming a success that didn't happen.
+function writeJsonAtomic(
   filePath: string,
-  overrides: Readonly<Record<string, string | number | boolean>>,
+  label: string,
+  value: unknown,
   logger: DaemonLogger,
 ): void {
   try {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const tmp = `${filePath}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(overrides), { mode: 0o600 });
+    fs.writeFileSync(tmp, JSON.stringify(value), { mode: 0o600 });
     fs.chmodSync(tmp, 0o600);
     fs.renameSync(tmp, filePath);
   } catch (e) {
-    const message = `config-overrides write failed: ${(e as Error).message}`;
+    const message = `${label} write failed: ${(e as Error).message}`;
     logger("error", message);
     throw new Error(message);
   }
 }
 
+function writeOverrides(
+  filePath: string,
+  overrides: Readonly<Record<string, string | number | boolean>>,
+  logger: DaemonLogger,
+): void {
+  writeJsonAtomic(filePath, "config-overrides", overrides, logger);
+}
+
+// [LAW:one-source-of-truth] The one place a key's value in the flat dict
+// changes (set-or-delete) — writeConfigOverride/clearConfigOverride/
+// restoreConfigOverrideValue all fold through here, so "what was the value
+// BEFORE this write" (the fact history needs) is captured at the one site
+// that reads-then-writes it, never re-derived. `value: undefined` deletes;
+// any other value sets. Returns the previous value (or undefined if the key
+// was absent) — the caller decides whether that fact matters.
+function mutateOverride(
+  filePath: string,
+  key: string,
+  value: string | number | boolean | undefined,
+  logger: DaemonLogger,
+): string | number | boolean | undefined {
+  const overrides = loadRawOverrides(filePath, logger);
+  const prev = overrides[key];
+  if (value === undefined) {
+    if (!(key in overrides)) return prev;
+    const next = { ...overrides };
+    delete next[key];
+    writeOverrides(filePath, next, logger);
+  } else {
+    writeOverrides(filePath, { ...overrides, [key]: value }, logger);
+  }
+  return prev;
+}
+
+// [LAW:one-source-of-truth] `persist`'s write, TRACKED: mutate the key, then
+// record the transition on the SAME global history undo/redo step
+// (brandon-layout-edit-2gc.2). This is the ONE enforcement point — every
+// current and future caller of writeConfigOverride (setConfig, stepConfig,
+// apply-layout-op's append) gets history for free, with zero edits to those
+// verb handlers, because the recording lives here rather than at each call
+// site. [LAW:locality-or-seam]
 export function writeConfigOverride(
   filePath: string,
   key: string,
   value: string | number | boolean,
   logger: DaemonLogger = quietLogger,
 ): void {
-  const overrides = loadRawOverrides(filePath, logger);
-  writeOverrides(filePath, { ...overrides, [key]: value }, logger);
+  const prev = mutateOverride(filePath, key, value, logger);
+  pushHistoryEntry(filePath, { key, from: prev ?? null, to: value }, logger);
 }
 
+// [LAW:one-source-of-truth] `reset`'s write, TRACKED — mirrors
+// writeConfigOverride above. A clear that touches nothing (the key was
+// already absent) records no entry: nothing changed, so there is nothing to
+// undo back to.
 export function clearConfigOverride(
   filePath: string,
   key: string,
@@ -366,7 +417,247 @@ export function clearConfigOverride(
 ): void {
   const overrides = loadRawOverrides(filePath, logger);
   if (!(key in overrides)) return;
-  const next = { ...overrides };
-  delete next[key];
-  writeOverrides(filePath, next, logger);
+  const prev = mutateOverride(filePath, key, undefined, logger);
+  pushHistoryEntry(filePath, { key, from: prev ?? null, to: null }, logger);
+}
+
+// [LAW:one-source-of-truth] The UNTRACKED twin — restores a key to EXACTLY
+// `value` (or clears it, for `null`) without recording a new history entry.
+// The only legitimate callers are popPastEntry/popFutureEntry below: undo and
+// redo already know they're moving an entry between the past/future stacks,
+// so routing their own restoration back through the tracked writers would
+// record the undo/redo AS a new forward edit — burying the entry it just
+// popped and making the OTHER stack unreachable. This is a structurally
+// distinct function, not a boolean flag on the tracked ones
+// [LAW:no-mode-explosion] — its contract ("apply this exact value, no
+// bookkeeping") is different from theirs ("write this value, remember how to
+// undo it"), not a variant of the same one.
+function restoreConfigOverrideValue(
+  filePath: string,
+  key: string,
+  value: string | number | boolean | null,
+  logger: DaemonLogger,
+): void {
+  mutateOverride(filePath, key, value === null ? undefined : value, logger);
+}
+
+// ─── Undo/redo history (brandon-layout-edit-2gc.2) ────────────────────────
+
+// [LAW:types-are-the-program] ONE entry shape covers every scope the
+// overrides file holds — a globals field's snapshot overwrite (setConfig), a
+// segment-palette snapshot overwrite (same verb, different key shape), AND a
+// preset-root-ops APPEND (apply-layout-op's read-current-append-write) —
+// because at the STORAGE layer every one of those is indistinguishable from
+// "the value at `key` changed from `from` to `to`". apply-layout-op computes
+// its new array-of-tokens string by reading-then-appending one level up
+// (verbs/index.ts); by the time that string reaches writeConfigOverride, it
+// is just the next value at that key. Undo restoring `from` verbatim is
+// therefore ALSO the correct "pop the last op token" behavior for a rootOps
+// key, with no rootOps-specific code anywhere in this module — the ticket's
+// "one history over the overrides layer, not a layout-specific feature" falls
+// out of the shape, it isn't special-cased into it. `null` is the ABSENT
+// sentinel (a key with no prior/no resulting value): safe because no real
+// override value is ever `null` — see isValidOverrides's kind table.
+export interface HistoryEntry {
+  readonly key: string;
+  readonly from: string | number | boolean | null;
+  readonly to: string | number | boolean | null;
+}
+
+interface HistoryState {
+  readonly past: readonly HistoryEntry[];
+  readonly future: readonly HistoryEntry[];
+}
+
+const EMPTY_HISTORY: HistoryState = { past: [], future: [] };
+
+// [LAW:carrying-cost] Resolves the ticket's "depth of the ring" question:
+// bounded so a long-running daemon's history file cannot grow without limit,
+// generous enough that no realistic editing session bumps into it. Oldest
+// entries fall off first (capPush below) — a silent, documented trim, not a
+// failure.
+const MAX_HISTORY_DEPTH = 50;
+
+// [LAW:one-source-of-truth] Resolves the ticket's "where it lives relative to
+// the overrides file" question: a SIBLING file in the same directory, derived
+// as a pure function of the overrides path already passed in — no reach to
+// paths.ts/global state, so every existing call site (and every existing
+// test's XDG_STATE_HOME isolation, which already isolates configOverridesPath())
+// isolates this file too, with zero additional test-harness surface. Kept
+// SEPARATE from the overrides file itself (rather than nesting it inside a
+// wrapper shape) so the overrides file's own on-disk shape — asserted by
+// name in existing tests and callers — never changes
+// [LAW:locality-or-seam]: a change to history storage must not ripple into
+// every existing reader of the flat overrides dict.
+function historyPathFor(overridesFilePath: string): string {
+  return path.join(
+    path.dirname(overridesFilePath),
+    "config-overrides-history.json",
+  );
+}
+
+function isValidHistoryValue(
+  v: unknown,
+): v is string | number | boolean | null {
+  return (
+    v === null ||
+    typeof v === "string" ||
+    typeof v === "number" ||
+    typeof v === "boolean"
+  );
+}
+
+function isValidHistoryEntry(v: unknown): v is HistoryEntry {
+  if (v === null || typeof v !== "object") return false;
+  const obj = v as Record<string, unknown>;
+  return (
+    typeof obj.key === "string" &&
+    isValidHistoryValue(obj.from) &&
+    isValidHistoryValue(obj.to)
+  );
+}
+
+// [LAW:no-silent-failure] Missing/corrupt/wrong-shape file → the empty
+// history is the DEFINED recovery (mirrors isValidOverrides/loadRawOverrides'
+// identical "first-ever boot" treatment for the sibling file) — a single
+// malformed entry drops the WHOLE history, never a guess at which entries to
+// salvage.
+function isValidHistoryState(v: unknown): v is HistoryState {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+  const obj = v as Record<string, unknown>;
+  return (
+    Array.isArray(obj.past) &&
+    obj.past.every(isValidHistoryEntry) &&
+    Array.isArray(obj.future) &&
+    obj.future.every(isValidHistoryEntry)
+  );
+}
+
+function loadHistoryState(
+  overridesFilePath: string,
+  logger: DaemonLogger,
+): HistoryState {
+  const filePath = historyPathFor(overridesFilePath);
+  let raw: string;
+  try {
+    raw = fs.readFileSync(filePath, "utf8");
+  } catch (e) {
+    const code = (e as NodeJS.ErrnoException).code;
+    if (code !== "ENOENT") {
+      logger(
+        "warn",
+        `config-overrides-history read failed (${code}); starting empty`,
+      );
+    }
+    return EMPTY_HISTORY;
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (isValidHistoryState(parsed)) return parsed;
+    logger(
+      "warn",
+      `config-overrides-history load: unexpected shape, starting empty`,
+    );
+    return EMPTY_HISTORY;
+  } catch {
+    logger(
+      "warn",
+      `config-overrides-history load: corrupt JSON, starting empty`,
+    );
+    return EMPTY_HISTORY;
+  }
+}
+
+function writeHistoryState(
+  overridesFilePath: string,
+  state: HistoryState,
+  logger: DaemonLogger,
+): void {
+  writeJsonAtomic(
+    historyPathFor(overridesFilePath),
+    "config-overrides-history",
+    state,
+    logger,
+  );
+}
+
+// [LAW:no-mode-explosion] Bounded push, oldest-drops-first, shared by both
+// stacks (past grows on a fresh edit or a redo; future grows on an undo) —
+// one shape, not two near-duplicate arms.
+function capPush<T>(arr: readonly T[], entry: T, max: number): readonly T[] {
+  const next = [...arr, entry];
+  return next.length > max ? next.slice(next.length - max) : next;
+}
+
+// [LAW:one-source-of-truth] The ONLY caller is writeConfigOverride/
+// clearConfigOverride above — every tracked write lands here, so recording
+// cannot drift from mutation. A fresh edit TRUNCATES `future`: the classic
+// undo/redo branch — diverging from history by doing something NEW abandons
+// whatever was undone, rather than silently keeping it reachable from a
+// history state the new edit has already invalidated.
+function pushHistoryEntry(
+  overridesFilePath: string,
+  entry: HistoryEntry,
+  logger: DaemonLogger,
+): void {
+  const state = loadHistoryState(overridesFilePath, logger);
+  writeHistoryState(
+    overridesFilePath,
+    { past: capPush(state.past, entry, MAX_HISTORY_DEPTH), future: [] },
+    logger,
+  );
+}
+
+// [LAW:one-source-of-truth] The daemon-GLOBAL history is ONE stack, not
+// per-session: config-overrides.json already has exactly one writer (the
+// daemon) and no session-scoping (candybar-config-engine-71o's own binding
+// guardrail — a `persist` write is daemon-global by design), so undo/redo
+// stepping that SAME single-writer file inherits the same scope rather than
+// inventing a session axis the storage layer doesn't otherwise have. Two
+// sessions clicking undo do see each other's edits — a real, DELIBERATE
+// consequence of there being one bar default, not a bug: the alternative
+// (per-session history over daemon-global state) would let one session's
+// "undo" silently fail to undo what another session's click actually did.
+//
+// [LAW:no-silent-failure] Returns `null` at the bottom of the stack — the
+// verb handler (verbs/index.ts) turns that into a loud BadVerbArgs surfaced
+// through click.error, never a silent no-op.
+export function undoLastOverride(
+  overridesFilePath: string,
+  logger: DaemonLogger = quietLogger,
+): HistoryEntry | null {
+  const state = loadHistoryState(overridesFilePath, logger);
+  const entry = state.past[state.past.length - 1];
+  if (entry === undefined) return null;
+  restoreConfigOverrideValue(overridesFilePath, entry.key, entry.from, logger);
+  writeHistoryState(
+    overridesFilePath,
+    {
+      past: state.past.slice(0, -1),
+      future: capPush(state.future, entry, MAX_HISTORY_DEPTH),
+    },
+    logger,
+  );
+  return entry;
+}
+
+// [LAW:no-silent-failure] Redo's mirror of undo above — `null` at the top of
+// the stack, same loud surfacing contract.
+export function redoLastOverride(
+  overridesFilePath: string,
+  logger: DaemonLogger = quietLogger,
+): HistoryEntry | null {
+  const state = loadHistoryState(overridesFilePath, logger);
+  const entry = state.future[state.future.length - 1];
+  if (entry === undefined) return null;
+  restoreConfigOverrideValue(overridesFilePath, entry.key, entry.to, logger);
+  writeHistoryState(
+    overridesFilePath,
+    {
+      past: capPush(state.past, entry, MAX_HISTORY_DEPTH),
+      future: state.future.slice(0, -1),
+    },
+    logger,
+  );
+  return entry;
 }