pi-goal-list-loop-audit 0.24.9 → 0.25.1

package/README.md

@@ -200,7 +200,10 @@ No external watchdog plugin needed.
 /glla tokenlimit=0                   # explicitly no cap (the default)
 /glla wedgealert=30                  # hung-command alert minutes (default: 30, 0 = off)
 /glla autoresume=on                  # held goals/loops auto-resume in fresh sessions (unattended rigs)
-/glla auditcap=5                     # pause the goal after N consecutive auditor disapprovals (default 3, 0 = unlimited)
+/glla auditcap=5                     # pause the goal after N consecutive auditor disapprovals (default 5, 0 = unlimited)
+/glla aggressivemode=on               # keep-going defaults: autoResume, cap 10, stuck 10, wedge off, quota auto-retry, cap→TODOs
+/glla quotaretryminutes=60            # minutes before auto-retrying a quota-exhausted auditor
+/glla stuckmax=10                     # consecutive stuck interventions before a loop stops (default 5)
 /glla auditfeedbackchars=800         # cap the executor-visible auditor report (default 0 = full report)
 /glla autoaccept=on                  # drafts ACTIVATE without the Confirm dialog (unattended rigs)
 /glla project tokenlimit=500         # rare per-project override

package/extensions/goal-loop-auditor.ts

@@ -107,6 +107,11 @@ function buildGoalAuditorPrompt(goal: Goal, completionSummary: string | null | u
     "Use read/grep/find/ls/bash as needed to inspect real artifacts. Do not mutate files or run destructive commands.",
     "If the work is only an alpha scaffold, generated template, shallow draft, proxy milestone, or lacks the user-facing value requested, disapprove.",
     "If any explicit requirement is missing, weakly verified, contradicted, or not inspectable with the available evidence, disapprove.",
+    "Objective shift: if the executor's <completion_summary> explicitly states that the work has shifted to other items",
+    "(different from the original <goal> objective), and the shift is justified — e.g. the original objective was blocked,",
+    "the agent pivoted to higher-ROI items, and the new items are independently verified — accept the shift as evidence",
+    "of reasonable engineering judgment. Do NOT rigidly disapprove because the original objective is not literally shipped;",
+    "audit the shifted work on its merits and say so in the report.",
     "Return a concise audit report. The final line MUST be exactly one of:",
     "<approved/>",
     "<disapproved/>",

package/extensions/goal-loop-core.ts

@@ -9,6 +9,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { execSync } from "node:child_process";
 
 // =================================================================
 // Types
@@ -144,6 +145,10 @@ export interface Goal {
   stopReason?: string;
   pauseReason?: string;
   pauseSuggestedAction?: string;
+  /** v0.25.0 (contract item 22): auditor objections extracted as TODOs when
+   * aggressiveMode keeps the goal active past the disapproval cap. Rendered
+   * into every continuation prompt until the next audit clears them. */
+  pendingTasks?: string[];
   activePath?: string;
   archivedPath?: string;
   usage: {
@@ -761,3 +766,155 @@ export function missingGllaTools(activeNames: readonly string[]): readonly GllaT
   const active = new Set(activeNames);
   return GLLA_TOOL_NAMES.filter((n) => !active.has(n));
 }
+
+// -----------------------------------------------------------------
+// v0.25.0 — eager-continuation contract helpers
+// -----------------------------------------------------------------
+
+/** Base defaults (aggressiveMode OFF). auditCap base raised 3 → 5 in
+ * v0.25.0 (contract item 7 — the "fairly eager" baseline). */
+export const BASE_AUDIT_CAP = 5;
+export const BASE_STUCK_MAX_INTERVENTIONS = 5;
+/** aggressiveMode defaults (contract item 5). Explicit per-key settings
+ * always win over these — aggressiveMode flips DEFAULTS, not user choices. */
+export const AGGRESSIVE_AUDIT_CAP = 10;
+export const AGGRESSIVE_STUCK_MAX_INTERVENTIONS = 10;
+export const DEFAULT_QUOTA_RETRY_MINUTES = 60;
+
+export interface EffectiveAggressiveSettings {
+  auditCap: number;
+  stuckMaxInterventions: number;
+  /** 0 = wedge alerts off. */
+  wedgeAlertMinutes: number;
+  autoResume: boolean;
+  aggressiveMode: boolean;
+}
+
+/** Layered resolution: explicit per-key value > aggressiveMode default >
+ * base default (contract items 5+7). Pure so tests can assert the matrix
+ * without a settings file. */
+export function resolveEffectiveAggressiveSettings(s: {
+  aggressiveMode?: boolean;
+  auditCap?: number;
+  stuckMaxInterventions?: number;
+  wedgeAlertMinutes?: number;
+  autoResume?: boolean;
+}): EffectiveAggressiveSettings {
+  const aggressiveMode = s.aggressiveMode === true;
+  return {
+    aggressiveMode,
+    auditCap: s.auditCap ?? (aggressiveMode ? AGGRESSIVE_AUDIT_CAP : BASE_AUDIT_CAP),
+    stuckMaxInterventions:
+      s.stuckMaxInterventions ?? (aggressiveMode ? AGGRESSIVE_STUCK_MAX_INTERVENTIONS : BASE_STUCK_MAX_INTERVENTIONS),
+    wedgeAlertMinutes: s.wedgeAlertMinutes ?? (aggressiveMode ? 0 : 30),
+    autoResume: s.autoResume ?? aggressiveMode,
+  };
+}
+
+/** Extract up to `cap` actionable objection lines from an auditor report
+ * (contract item 22): numbered/bulleted lines, most recent last-report
+ * wins, longest tails trimmed. Pure — the audit-cap branch and its test
+ * share this. */
+export function extractPendingTasks(report: string, cap = 5): string[] {
+  const out: string[] = [];
+  for (const raw of report.split("\n")) {
+    const line = raw.trim();
+    const m = line.match(/^(?:[-*•]|\d+[.)])\s+(.{8,200})$/);
+    if (!m) continue;
+    const text = m[1]!.trim();
+    // Skip pure-evidence bullets ("file X exists", "tests pass") — we want
+    // OBJECTIONS: missing/failing/not-done language.
+    if (!/miss|fail|not |no |lack|absent|doesn|didn|won|can'?t|remain|todo|fix|requir|incomplete|unverified/i.test(text)) continue;
+    if (!out.includes(text)) out.push(text);
+    if (out.length >= cap) break;
+  }
+  return out;
+}
+
+/** Contract item 23: is the auditor's IMPOSSIBLE reason about the WHOLE
+ * goal or only part of it? Default "full" (safe — keeps the pause);
+ * partial only on explicit subset language. */
+export function classifyImpossibleReason(reason: string): "partial" | "full" {
+  if (/\b(partial|some items|subset|remaining items|narrow|only .{0,30}(item|part|section)|the rest|rest of)\b/i.test(reason)) {
+    return "partial";
+  }
+  return "full";
+}
+
+/** Contract items 25/28: does this objective read as a full-audit /
+ * survey pivot? */
+export function isFullAuditObjective(objective: string): boolean {
+  return /full audit|survey|find all|task ?list|enumerate|audit the (whole |entire )?project/i.test(objective);
+}
+
+// --- Auto-committer daemon sentinel (contract item 31) ---
+
+/** Sentinel the auto-committer (dracon-sync) filter checks: when present,
+ * the daemon must not rewrite/commit in this repo. The agent writes it
+ * after detecting filter-branch damage (see DETACHED COMMIT DETECTION in
+ * the continuation prompt). */
+export const PAUSE_AUTO_COMMIT_SENTINEL = ".pause-auto-commit";
+
+export function pauseAutoCommit(cwd: string, reason: string): string {
+  const dir = path.join(cwd, ".pi-glla");
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, PAUSE_AUTO_COMMIT_SENTINEL);
+  fs.writeFileSync(file, `pausedAt: ${nowIso()}\nreason: ${reason}\n`, "utf-8");
+  return file;
+}
+
+export function resumeAutoCommit(cwd: string): boolean {
+  const file = path.join(cwd, ".pi-glla", PAUSE_AUTO_COMMIT_SENTINEL);
+  try {
+    fs.unlinkSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isAutoCommitPaused(cwd: string): boolean {
+  try {
+    fs.accessSync(path.join(cwd, ".pi-glla", PAUSE_AUTO_COMMIT_SENTINEL));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// --- Heartbeat ship-suppression (contract item 27) ---
+
+/** Suppress the heartbeat when work shipped very recently — a session
+ * that just committed is transitioning, not stalled. Pure; the tick
+ * gathers the timestamps. */
+export function shouldSuppressHeartbeatForRecentShip(args: {
+  nowMs: number;
+  lastShippedAtMs: number | null;
+  windowMs?: number;
+}): boolean {
+  const windowMs = args.windowMs ?? 5 * 60_000;
+  if (args.lastShippedAtMs === null) return false;
+  return args.nowMs - args.lastShippedAtMs < windowMs;
+}
+
+/** Best-effort "when did work last ship" for a repo: newest of the HEAD
+ * commit time and the .pi-glla state file mtime. Null when unknown. */
+export function lastShippedAtMs(cwd: string): number | null {
+  let best: number | null = null;
+  try {
+    const out = execSync("git log -1 --format=%ct", { cwd, stdio: ["ignore", "pipe", "ignore"] })
+      .toString()
+      .trim();
+    const sec = Number(out);
+    if (Number.isFinite(sec) && sec > 0) best = sec * 1000;
+  } catch {
+    /* not a git repo or no commits */
+  }
+  try {
+    const mtime = fs.statSync(path.join(cwd, ".pi-glla", "active.jsonl")).mtimeMs;
+    if (best === null || mtime > best) best = mtime;
+  } catch {
+    /* no state file yet */
+  }
+  return best;
+}

package/extensions/goal-loop-forever.ts

@@ -75,6 +75,33 @@ export interface LoopState {
   consecutiveStuck?: number;
   /** v0.24.0: the last stuck reason (for the intervention directive + ledger). */
   lastStuckReason?: string;
+  /** v0.25.1: /loop start toolsamerepeat=N — legacy same-tool-same-result
+   * check window. 0 disables it (multi-signal detector only). */
+  toolSameRepeat?: number;
+  /** v0.25.1: per-iteration progress-signal accumulators for the
+   * multi-signal stuck gate. fileWrites bumps on write/edit tool results;
+   * iterationStartHead/At snapshot when the iteration BEGAN so the tick can
+   * count commits and spec_item_progress events produced during it. */
+  iterMetrics?: {
+    fileWrites: number;
+    iterationStartHead?: string;
+    iterationStartAt?: string;
+  };
+}
+
+/** v0.25.1: stop reason for /loop finish — a clean "completed" end,
+ * distinct from stuck/plateau/stopped-by-user. */
+export function loopFinishStopReason(reason?: string): string {
+  const r = (reason ?? "").trim();
+  return `completed: ${r || "finished by user"}`;
+}
+
+/** v0.25.1: tool names that count as file-write progress signals for the
+ * multi-signal stuck gate (item 3). */
+export const LOOP_WRITE_TOOLS = ["write", "edit", "multi_edit", "write_file"] as const;
+
+export function isLoopWriteTool(toolName: string): boolean {
+  return (LOOP_WRITE_TOOLS as readonly string[]).includes(toolName);
 }
 
 /** Scratch-branch name for branch=1 mode. Format pinned by tests. */
@@ -229,6 +256,7 @@ export function parseLoopStartArgs(raw: string): {
   force: boolean;
   timeLimitHours?: number;
   tokenBudget?: number;
+  toolSameRepeat?: number;
 } {
   // Key=value pairs first (measure= and direction= may hold quoted values),
   // the remaining text is the target.
@@ -294,6 +322,12 @@ export function parseLoopStartArgs(raw: string): {
     force: forceRaw === "1" || forceRaw === "true" || forceRaw === "yes",
     timeLimitHours: Number.isFinite(timeRaw) && timeRaw > 0 ? timeRaw : undefined,
     tokenBudget: Number.isFinite(tokensRaw) && tokensRaw > 0 ? tokensRaw : undefined,
+    toolSameRepeat: (() => {
+      const raw = (kv.get("toolsamerepeat") ?? "").trim();
+      if (!raw) return undefined;
+      const n = Number.parseInt(raw, 10);
+      return Number.isInteger(n) && n >= 0 ? n : undefined;
+    })(),
   };
 }
 

package/extensions/goal-loop-repetition.ts

@@ -142,6 +142,59 @@ export interface LoopStuckInput {
   recentToolResults: ToolResultPrint[];
   /** Consecutive iterations with zero tool calls, including this one. */
   toollessStreak: number;
+  /** v0.25.1 progress signals (multi-signal stuck model): file writes,
+   * git commits, and spec_item_progress events in the FINISHED iteration.
+   * Optional for backward compat — absent = 0. */
+  fileWriteCount?: number;
+  gitCommitCount?: number;
+  specItemProgressCount?: number;
+}
+
+/**
+ * v0.25.1: forward-transition marker — the agent explicitly declares it is
+ * moving on ("Next step (iter-222, implement branch)"). Conservative word
+ * list: if the agent isn't saying "moving on", it's probably spinning.
+ */
+export function forwardTransitionMarker(text: string): boolean {
+  if (
+    /\b(next|next step|next phantom|next iter|iter[ -]\d+|pivot|moving on|implement next|switch to|now (do|implement|fix|add)|then (do|implement|fix|add))\b/i.test(
+      text,
+    )
+  ) {
+    return true;
+  }
+  // Line-start "Next:" / "Next step" — the phrasing the wild-caught
+  // transcripts used.
+  return /^\s*next\s*(step)?\s*:/im.test(text);
+}
+
+/** A forward marker only counts PAIRED with a real write/commit in the
+ * same iteration — pure narration ("next: implement X" × N, shipping
+ * nothing) is the narrate-but-don't-ship loop and IS stuck. */
+export function forwardTransitionPaired(input: LoopStuckInput): boolean {
+  if (!forwardTransitionMarker(input.assistantText)) return false;
+  return (input.fileWriteCount ?? 0) > 0 || (input.gitCommitCount ?? 0) > 0;
+}
+
+/**
+ * v0.25.1 multi-signal stuck gate (progress-signals model): an iteration
+ * is stuck ONLY when every progress signal is zero — file writes, git
+ * commits, spec_item_progress events, and a PAIRED forward transition —
+ * AND the legacy single-signal detector also fires. Stable verification
+ * output from a loop that is still shipping is the GOAL state of a
+ * metricless loop, not the stuck state (the two wild-caught transcripts
+ * that motivated this rework both died in exactly that false positive).
+ *
+ * `toolSameRepeat` (the /loop start toolsamerepeat=N kwarg) forwards to
+ * the legacy check: 0 disables the same-tool-same-result branch entirely
+ * (new detector only), undefined = REPETITION.toolResultRepeat.
+ */
+export function isActuallyStuck(input: LoopStuckInput, toolSameRepeat?: number): string | undefined {
+  if ((input.fileWriteCount ?? 0) > 0) return undefined;
+  if ((input.gitCommitCount ?? 0) > 0) return undefined;
+  if ((input.specItemProgressCount ?? 0) > 0) return undefined;
+  if (forwardTransitionPaired(input)) return undefined;
+  return detectLoopStuck(input, toolSameRepeat);
 }
 
 function clip(text: string, n: number): string {
@@ -154,7 +207,7 @@ function clip(text: string, n: number): string {
  * or undefined when it's working normally. Checks run cheapest-and-most-
  * certain first; the first hit wins so the reason stays specific.
  */
-export function detectLoopStuck(input: LoopStuckInput): string | undefined {
+export function detectLoopStuck(input: LoopStuckInput, toolResultRepeatOverride?: number): string | undefined {
   const { assistantText, recentPrints, previousText, recentToolResults, toollessStreak } = input;
 
   // Narration only: iterations that never touch tools produce nothing inspectable.
@@ -189,14 +242,17 @@ export function detectLoopStuck(input: LoopStuckInput): string | undefined {
   }
 
   // Same tool, same output, three times running: the loop is re-reading a result it already has.
-  const recentTools = recentToolResults.slice(-REPETITION.toolResultRepeat);
+  // v0.25.1: toolsamerepeat=0 disables this branch entirely (new detector only).
+  const toolResultRepeat = toolResultRepeatOverride ?? REPETITION.toolResultRepeat;
+  const recentTools = toolResultRepeat > 0 ? recentToolResults.slice(-toolResultRepeat) : [];
   if (
-    recentTools.length === REPETITION.toolResultRepeat &&
+    toolResultRepeat > 0 &&
+    recentTools.length === toolResultRepeat &&
     recentTools.every((r) => r.tool === recentTools[0]!.tool && r.hash === recentTools[0]!.hash)
   ) {
     return recentTools.every((r) => r.isError)
-      ? `same ${recentTools[0]!.tool} error ${REPETITION.toolResultRepeat}× in a row`
-      : `same ${recentTools[0]!.tool} result ${REPETITION.toolResultRepeat}× in a row (no new information)`;
+      ? `same ${recentTools[0]!.tool} error ${toolResultRepeat}× in a row`
+      : `same ${recentTools[0]!.tool} result ${toolResultRepeat}× in a row (no new information)`;
   }
 
   return undefined;

package/extensions/goal-settings.ts

@@ -0,0 +1,153 @@
+// pi-goal-list-loop-audit — v0.25.0
+// extensions/goal-settings.ts
+//
+// The settings layer, extracted from loops/goal.ts so tests can drive it
+// without importing the whole extension. Two-tier config (v0.7.0): GLOBAL
+// is the normal home, PROJECT the rare local override. Resolution:
+// project > global > defaults (per key).
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+  DEFAULT_AUDIT_FEEDBACK_CHARS,
+  DEFAULT_QUOTA_RETRY_MINUTES,
+  mergeSettings,
+  piGlaDir,
+} from "./goal-loop-core.ts";
+import type { SubagentModelStrategy } from "./goal-loop-subagents.js";
+
+export interface Settings {
+  /** "provider/model-id" or bare "model-id". Unset → session model. */
+  auditorModel?: string;
+  auditorThinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+  /** Shell command run on goal complete / goal pause / loop stop; message passed as $1. */
+  notifyCmd?: string;
+  /** Per-goal token budget; crossing it pauses the goal. Off by default
+   * (opt-in guard, v0.12.0): unset/0 = no budget. */
+  tokenLimit?: number;
+  /** v0.23.2: minutes of busy-but-silent before the wedge alert fires
+   * (hung-command detector). Unset = 45; 0 = off. */
+  wedgeAlertMinutes?: number;
+  /** on → restored goals/loops/lists auto-resume even in fresh sessions
+   * (unattended rigs). Default off: restore holds until /goal resume. */
+  autoResume?: boolean;
+  /** v0.24.2: pause the goal after N consecutive auditor disapprovals (0 = unlimited).
+   * Default 5 (raised from 3 in v0.25.0, contract item 7). */
+  auditCap?: number;
+  /** Maximum auditor-report characters returned to the executor after a
+   * disapproval (0 = full report). Default 0 (full report). */
+  auditFeedbackChars?: number;
+  /** v0.25.0: flip the continuation defaults toward keep-going
+   * (contract item 5): autoResume on, auditCap 10, stuckMax 10, wedge off,
+   * quota errors auto-retry silently. Explicit per-key settings still win. */
+  aggressiveMode?: boolean;
+  /** Minutes to wait before auto-retrying a quota-exhausted auditor when
+   * the upstream gave no Retry-After hint (contract item 11). Default 60. */
+  quotaRetryMinutes?: number;
+  /** Consecutive stuck interventions before a loop stops (default 5,
+   * 10 under aggressiveMode). */
+  stuckMaxInterventions?: number;
+  /** on → propose_* drafts activate WITHOUT the Confirm dialog and the
+   * interview floor is skipped — the seed carries the intent (unattended
+   * rigs). Default off: nothing activates before the user confirms. */
+  autoAcceptDrafts?: boolean;
+  /** v0.24.6: subagent model strategy for pi-subagents default agents that
+   * pin a model (Explore pins claude-haiku-4-5, which silently routes
+   * subagents to a different provider/quota pool than the session).
+   * "inherit-parent" (default) writes a managed ~/.pi/agent/agents/Explore.md
+   * override without the model pin so subagents share the session model and
+   * its quota; "agent-default" restores upstream behavior. Applies to NEW
+   * sessions (pi-subagents registers agents at session start). */
+  subagentModelStrategy?: SubagentModelStrategy;
+  /** v0.24.6: per-agent-type model pin, e.g. { "Explore": "minimax/MiniMax-M3" }.
+   * Always wins over subagentModelStrategy — the managed override is written
+   * WITH this pin regardless of strategy. */
+  subagentModelOverrides?: Record<string, string>;
+}
+
+export const DEFAULT_SETTINGS: Settings = {
+  // Unset = follow the pi session thinking level (user selects thinking in
+  // pi, auditor follows), floor "high" — the auditor is the verification
+  // gate, depth is worth more there than speed. /glla thinking= overrides.
+  auditorThinkingLevel: undefined,
+  // v0.24.6: subagents inherit the session model by default — one quota
+  // pool, no surprise 403s from a pinned default agent's provider.
+  subagentModelStrategy: "inherit-parent",
+  auditFeedbackChars: DEFAULT_AUDIT_FEEDBACK_CHARS,
+  // v0.25.0 (contract Section B): keep-going is opt-in via aggressiveMode;
+  // the dial flips DEFAULTS, never explicit per-key user settings.
+  aggressiveMode: false,
+  quotaRetryMinutes: DEFAULT_QUOTA_RETRY_MINUTES,
+};
+
+export function globalSettingsPath(): string {
+  return path.join(os.homedir(), ".pi", "agent", "pi-goal-list-loop-audit.settings.json");
+}
+
+export function projectSettingsPath(cwd: string): string {
+  return path.join(piGlaDir(cwd), "settings.json");
+}
+
+export function readSettingsFile(file: string): Partial<Settings> {
+  try {
+    if (!fs.existsSync(file)) return {};
+    const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+    return typeof parsed === "object" && parsed !== null ? parsed as Partial<Settings> : {};
+  } catch {
+    return {};
+  }
+}
+
+export function loadSettings(cwd: string): Settings {
+  return mergeSettings(
+    DEFAULT_SETTINGS as unknown as Record<string, unknown>,
+    readSettingsFile(globalSettingsPath()) as Record<string, unknown>,
+    readSettingsFile(projectSettingsPath(cwd)) as Record<string, unknown>,
+  ) as unknown as Settings;
+}
+
+/** Every provenance-tracked key (the /glla headless display + UI). */
+export const SETTINGS_KEYS: Array<keyof Settings> = [
+  "auditorModel",
+  "auditorThinkingLevel",
+  "notifyCmd",
+  "tokenLimit",
+  "wedgeAlertMinutes",
+  "autoResume",
+  "autoAcceptDrafts",
+  "auditCap",
+  "auditFeedbackChars",
+  "subagentModelStrategy",
+  "subagentModelOverrides",
+  "aggressiveMode",
+  "quotaRetryMinutes",
+  "stuckMaxInterventions",
+];
+
+/** Where each effective setting comes from (for the /glla display). */
+export function settingsProvenance(cwd: string): Record<keyof Settings, { value: unknown; source: "project" | "global" | "default" }> {
+  const proj = readSettingsFile(projectSettingsPath(cwd));
+  const glob = readSettingsFile(globalSettingsPath());
+  const effective = loadSettings(cwd);
+  const out: Record<string, { value: unknown; source: "project" | "global" | "default" }> = {};
+  for (const k of SETTINGS_KEYS) {
+    if ((proj as Record<string, unknown>)[k] !== undefined) out[k] = { value: (proj as any)[k], source: "project" };
+    else if ((glob as Record<string, unknown>)[k] !== undefined) out[k] = { value: (glob as any)[k], source: "global" };
+    else out[k] = { value: (effective as any)[k], source: "default" };
+  }
+  return out as Record<keyof Settings, { value: unknown; source: "project" | "global" | "default" }>;
+}
+
+export function saveSettings(scope: "global" | "project", cwd: string, patch: Partial<Settings>): void {
+  const file = scope === "global" ? globalSettingsPath() : projectSettingsPath(cwd);
+  const current = readSettingsFile(file);
+  const next: Record<string, unknown> = { ...current };
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === undefined) delete next[k]; // key=unset removes the key
+    else next[k] = v;
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(next, null, 2));
+}