@stigmer/runner 3.0.9-dev.20260616060535 → 3.1.0

package/src/activities/execute-cursor/prompt-builder.ts

@@ -117,17 +117,30 @@ export function buildEnhancedPrompt(options: EnhancedPromptOptions): string {
  * tool-call ids, which mean nothing to the model. A resumed agent re-issues the
  * approved tool with a fresh id; the approval gate (see approval-state.ts grants)
  * is what actually lets the re-attempt through.
+ *
+ * `appliedToolCallIds` are approved whole-file writes the RUNNER has already
+ * applied to the workspace itself (exact-apply — the "what you approve is what
+ * gets applied" guarantee). Those are described as ALREADY DONE so the model
+ * does not redo them; only the remaining approved actions (hunk edits, shell,
+ * MCP) are the ones it must still carry out. No grant is issued for an applied
+ * write, so if the model edits that file again it is correctly re-gated.
  */
 export function buildReinvocationPrompt(
   pendingApprovals: PendingApproval[],
   approvalDecisions: Map<string, ApprovalAction>,
+  appliedToolCallIds: ReadonlySet<string> = new Set(),
 ): string {
   const approved: string[] = [];
+  const alreadyApplied: string[] = [];
   const skipped: string[] = [];
 
   for (const pa of pendingApprovals) {
     const action = approvalDecisions.get(pa.toolCallId);
-    if (action === ApprovalAction.APPROVE) {
+    const isApproved =
+      action === ApprovalAction.APPROVE || action === ApprovalAction.APPROVE_ALL;
+    if (isApproved && appliedToolCallIds.has(pa.toolCallId)) {
+      alreadyApplied.push(describeApproval(pa));
+    } else if (isApproved) {
       approved.push(describeApproval(pa));
     } else if (action === ApprovalAction.SKIP) {
       skipped.push(describeApproval(pa));
@@ -135,6 +148,15 @@ export function buildReinvocationPrompt(
   }
 
   const parts: string[] = [];
+  if (alreadyApplied.length) {
+    parts.push(
+      "The user reviewed and APPROVED the following change(s), and the platform " +
+        "has ALREADY applied them to the workspace exactly as shown. Do NOT redo " +
+        "or rewrite them — treat them as done and continue with the rest of the " +
+        "task:\n" +
+        alreadyApplied.map((a) => `- ${a}`).join("\n"),
+    );
+  }
   if (approved.length) {
     parts.push(
       "The user reviewed the following action(s) you proposed and APPROVED them. " +
@@ -387,22 +409,66 @@ export function formatResponseRules(): string {
  * rather than asking for permission in prose. It is the only lever Cursor's
  * hook model leaves available.
  */
+const TOOL_APPROVAL_PROTOCOL_INTRO =
+  "You run inside a platform that automatically gates sensitive actions for human approval.";
+
+/**
+ * The platform's tool-approval rules, authored once and rendered in two places:
+ * the system prompt (see {@link formatToolApprovalProtocol}) and an always-applied
+ * Cursor project rule (see {@link buildToolApprovalRuleFile}). Keeping a single
+ * source means the two surfaces can never drift.
+ *
+ * The fourth rule is the load-bearing fix for the Cursor harness: because the
+ * deny-based gate surfaces an approval pause to the model as a tool *failure*
+ * (often Cursor's own generic "blocked by a hook" text — confirmed in Phase 0,
+ * and unavoidable since the SDK exposes no non-leaky approval primitive), a
+ * well-behaved model otherwise concludes the environment is broken and tells the
+ * user to "enable hooks in your Cursor settings", contradicting the approval
+ * card. This rule reframes that signal as the gate working as designed.
+ */
+const TOOL_APPROVAL_PROTOCOL_RULES: readonly string[] = [
+  "Carry out every action by calling the appropriate tool directly. Never describe an action you intend to take and then stop, and never ask the user for permission in prose.",
+  "When an action needs approval, the platform pauses it, asks the user, and resumes you automatically after they decide. You do not request approval yourself — invoking the tool is how you request it.",
+  "Even if a tool or MCP server instructs you to confirm with the user before acting (for example before sending, deleting, or purchasing), do NOT ask in prose. Invoke the tool and let the platform's approval step handle it.",
+  "A tool result that says the action was blocked, denied, requires approval, or was \"blocked by a hook\" is the platform's approval gate doing its job — it is NOT an error and NOT a Cursor misconfiguration. Never tell the user to change Cursor settings, enable hooks, or fix their configuration; the gate is intentional and the platform will resume you automatically once the user decides.",
+  "If an action is declined, do not retry it or attempt a workaround for it; continue with the rest of the task.",
+];
+
 export function formatToolApprovalProtocol(): string {
   return [
     "<tool_approval_protocol>",
-    "You run inside a platform that automatically gates sensitive actions for",
-    "human approval. Follow these rules without exception:",
-    "- Carry out every action by calling the appropriate tool directly. Never",
-    "  describe an action you intend to take and then stop, and never ask the",
-    "  user for permission in prose.",
-    "- When an action needs approval, the platform pauses it, asks the user, and",
-    "  resumes you automatically after they decide. You do not request approval",
-    "  yourself — invoking the tool is how you request it.",
-    "- Even if a tool or MCP server instructs you to confirm with the user before",
-    "  acting (for example before sending, deleting, or purchasing), do NOT ask",
-    "  in prose. Invoke the tool and let the platform's approval step handle it.",
-    "- If an action is declined, do not retry it or attempt a workaround for it;",
-    "  continue with the rest of the task.",
+    TOOL_APPROVAL_PROTOCOL_INTRO,
+    "Follow these rules without exception:",
+    ...TOOL_APPROVAL_PROTOCOL_RULES.map((rule) => `- ${rule}`),
     "</tool_approval_protocol>",
   ].join("\n");
 }
+
+/**
+ * Render the tool-approval protocol as an always-applied Cursor project rule
+ * (`.cursor/rules/*.mdc`).
+ *
+ * A `.cursor/rules` entry with `alwaysApply: true` is injected into the model's
+ * context on EVERY turn and takes precedence over a connected MCP server's
+ * `instructions`. The system-prompt copy ({@link formatToolApprovalProtocol})
+ * only reliably reaches the FIRST user message; the rule file is the durable,
+ * higher-precedence surface that keeps the protocol in force across resumed
+ * turns and against server-authored "ask the user first" guidance. The runner
+ * installs it into the workspace for the duration of a turn and restores the
+ * workspace afterward (see workspace-setup.ts).
+ */
+export function buildToolApprovalRuleFile(): string {
+  return [
+    "---",
+    "description: Stigmer platform tool-approval protocol — how human-in-the-loop approvals work and why a denied/blocked tool is not an error",
+    "alwaysApply: true",
+    "---",
+    "",
+    "# Tool approval protocol",
+    "",
+    TOOL_APPROVAL_PROTOCOL_INTRO,
+    "",
+    ...TOOL_APPROVAL_PROTOCOL_RULES.map((rule) => `- ${rule}`),
+    "",
+  ].join("\n");
+}

package/src/activities/execute-cursor/workspace-setup.ts

@@ -31,14 +31,34 @@
  * PID is gone, and the relocated artifacts are not in the repo.
  */
 
-import { writeFile, readFile, mkdir, chmod, rm } from "node:fs/promises";
-import { join } from "node:path";
+import { writeFile, readFile, mkdir, chmod, rm, rmdir, readdir } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 import { generateHookScript } from "./hook-script.js";
-import { writeApprovalStateFile, resetDenialLedger, type ApprovalStateFile } from "./approval-state.js";
+import { buildToolApprovalRuleFile } from "./prompt-builder.js";
+import {
+  writeApprovalStateFile,
+  resetDenialLedger,
+  activePointerPath,
+  writeActiveTurnPointer,
+  removeActiveTurnPointer,
+  type ApprovalStateFile,
+} from "./approval-state.js";
+import { resetCasObservations } from "./cas-observations.js";
+import { ensureHitlGateDir } from "../../shared/workspace/platform-dir.js";
 
 const CURSOR_DIR = ".cursor";
 const HOOKS_CONFIG_FILE = "hooks.json";
 const HOOK_SCRIPT_FILE = "stigmer-approval.sh";
+const RULES_DIR = "rules";
+// Pre-#173 the gate wrote its script/state/ledger INTO the repo here, as
+// `stigmer-*` files. Newer runs relocate them to the session HITL dir, but the
+// old files (and their hooks.json entry) linger in already-touched repos — see
+// removeLegacyWorkspaceHookArtifacts / isStigmerHookEntry.
+const LEGACY_HOOKS_DIR = "hooks";
+const RUNNER_OWNED_HOOK_FILE_PREFIX = "stigmer-";
+// Unmistakably runner-owned filename so installing it never collides with a
+// user's own project rules and restoring it never touches one.
+const TOOL_APPROVAL_RULE_FILE = "stigmer-tool-approval.mdc";
 
 /**
  * Cursor hook events the gate registers, both pointing at the same script (which
@@ -71,6 +91,24 @@ export interface HitlGateHandle {
    * before this turn (in which case teardown deletes the file).
    */
   restoreTo: string | null;
+  /**
+   * The `.cursor/rules/stigmer-tool-approval.mdc` this turn manages: its
+   * absolute path and the bytes to restore (null → teardown deletes the file,
+   * the normal case since the filename is runner-owned).
+   */
+  rule: WorkspaceFileSnapshot;
+  /**
+   * Workspace-scoped gate directory holding the stable hook script and the
+   * active-turn pointer. Teardown drops the pointer (see removeHitlGate) so the
+   * gate is inert between turns.
+   */
+  gateDir: string;
+}
+
+/** Absolute path + restore target for a single workspace file the gate manages. */
+interface WorkspaceFileSnapshot {
+  path: string;
+  restoreTo: string | null;
 }
 
 /**
@@ -88,14 +126,41 @@ export async function installHitlGate(params: {
 }): Promise<HitlGateHandle> {
   const { workspaceRoot, hitlDir, approvalState, runnerPid } = params;
 
-  const approvalScriptPath = await writeHitlArtifacts(hitlDir, approvalState, runnerPid);
+  // Heal any pre-#173 in-workspace gate leftovers before installing. Without
+  // this, a stale `.cursor/hooks/stigmer-approval.sh` (from a runner build that
+  // wrote the gate into the repo) keeps running alongside the current
+  // out-of-workspace gate and — reading an old, taskless approval-state with no
+  // grant for the current action — vetoes EVERY gated tool, including ones the
+  // user just approved ("blocked despite approval"). Its denials also land in a
+  // ledger this runner never reads, so the denial never surfaces as a pause and
+  // the run silently completes with the file never written. The merge below
+  // strips the stale hooks.json entry (see isStigmerHookEntry); this removes the
+  // orphaned script/state/ledger files so nothing can re-run them.
+  await removeLegacyWorkspaceHookArtifacts(workspaceRoot);
+
+  const { scriptPath: approvalScriptPath, gateDir } = await writeHitlArtifacts(
+    workspaceRoot,
+    hitlDir,
+    approvalState,
+    runnerPid,
+  );
   // One script, two events: preToolUse gates built-ins; beforeMCPExecution is
   // the only event Cursor enforces for MCP tools. The script branches internally
   // on hook_event_name so MCP is gated in exactly one place.
-  return installWorkspaceHook(workspaceRoot, [
+  const hookHandle = await installWorkspaceHook(workspaceRoot, [
     { event: PRE_TOOL_USE_EVENT, scriptPath: approvalScriptPath },
     { event: BEFORE_MCP_EVENT, scriptPath: approvalScriptPath },
   ]);
+
+  // Install the always-applied tool-approval rule. The deny-based gate surfaces
+  // an approval pause to the model as a tool failure (Cursor's generic "blocked
+  // by a hook" text), and the SDK exposes no non-leaky approval primitive — so
+  // this rule, which takes precedence over MCP-server instructions and persists
+  // across resumed turns, is the strongest available lever to stop the model
+  // from misreading the gate as a broken environment.
+  const rule = await installWorkspaceRule(workspaceRoot);
+
+  return { ...hookHandle, rule, gateDir };
 }
 
 /**
@@ -105,48 +170,149 @@ export async function installHitlGate(params: {
  * and a leftover hooks.json is inert anyway (see the module doc).
  */
 export async function removeHitlGate(handle: HitlGateHandle): Promise<void> {
+  await restoreWorkspaceFile(handle.hooksJsonPath, handle.restoreTo);
+  // Drop the active-turn pointer so the gate is INERT between turns: a hook that
+  // fires while no turn is active (a cached hooks.json, the user's own IDE on the
+  // same repo) reads no pointer and allows immediately. The stable hook script
+  // itself is intentionally left in place — it is harmless without a pointer and
+  // is reused (and refreshed) by the next turn.
+  await removeActiveTurnPointer(handle.gateDir);
+  if (handle.rule) {
+    await restoreWorkspaceFile(handle.rule.path, handle.rule.restoreTo);
+    // When we deleted our own rule file (restoreTo === null) and the `.cursor/
+    // rules` dir is now empty, remove it too so a repo that had no rules before
+    // is left exactly as we found it. rmdir only removes an empty dir, so a
+    // workspace with the user's own rules is untouched.
+    if (handle.rule.restoreTo === null) {
+      try {
+        await rmdir(dirname(handle.rule.path));
+      } catch {
+        // Non-empty (user has other rules) or already gone — nothing to clean.
+      }
+    }
+  }
+}
+
+/**
+ * Restore a single gate-managed workspace file to its pre-turn state: delete it
+ * when nothing existed before (restoreTo === null), else write the snapshot
+ * bytes back. Best-effort and never throws — a teardown failure must not fail
+ * the execution, and a leftover artifact is inert (see the module doc).
+ */
+async function restoreWorkspaceFile(path: string, restoreTo: string | null): Promise<void> {
   try {
-    if (handle.restoreTo === null) {
-      await rm(handle.hooksJsonPath, { force: true });
+    if (restoreTo === null) {
+      await rm(path, { force: true });
     } else {
-      await writeFile(handle.hooksJsonPath, handle.restoreTo, "utf-8");
+      await writeFile(path, restoreTo, "utf-8");
     }
   } catch (err) {
     console.warn(
-      `removeHitlGate: failed to restore ${handle.hooksJsonPath} (non-fatal): ` +
+      `removeHitlGate: failed to restore ${path} (non-fatal): ` +
       `${err instanceof Error ? err.message : err}`,
     );
   }
 }
 
 /**
- * Write the runner-owned gate artifacts (approval-state file, fresh denial
- * ledger, hook script) into the session HITL directory and return the absolute
- * hook-script path. The script is regenerated every turn so the current runner
- * PID and the current state-file/ledger paths are always baked in.
+ * Delete pre-#173 in-workspace gate leftovers: the runner-owned `stigmer-*`
+ * files an older runner build wrote to `.cursor/hooks/` (the hook script, its
+ * approval-state, its denial ledger). These are the orphan that shadows the
+ * current gate (see installHitlGate). Best-effort and never throws — a cleanup
+ * failure must not fail the run.
+ *
+ * Only `stigmer-`-prefixed files are removed (the unmistakably runner-owned
+ * namespace, like the rule filename), so a user's own scripts in `.cursor/hooks`
+ * are untouched; the directory itself is removed only if it ends up empty.
+ */
+async function removeLegacyWorkspaceHookArtifacts(workspaceRoot: string): Promise<void> {
+  const hooksDir = join(workspaceRoot, CURSOR_DIR, LEGACY_HOOKS_DIR);
+  let entries: string[];
+  try {
+    entries = await readdir(hooksDir);
+  } catch {
+    return; // no legacy hooks dir — nothing to heal
+  }
+
+  let removedAny = false;
+  for (const name of entries) {
+    if (!name.startsWith(RUNNER_OWNED_HOOK_FILE_PREFIX)) continue;
+    try {
+      await rm(join(hooksDir, name), { force: true });
+      removedAny = true;
+    } catch (err) {
+      console.warn(
+        `removeLegacyWorkspaceHookArtifacts: failed to remove ${name} (non-fatal): ` +
+        `${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
+
+  if (removedAny) {
+    // rmdir only succeeds on an empty dir, so a user who keeps their own hooks
+    // here is left untouched; an empty (entirely-ours) dir is cleaned away.
+    try {
+      await rmdir(hooksDir);
+    } catch {
+      // Non-empty (user owns other hooks) or already gone — nothing to clean.
+    }
+  }
+}
+
+/**
+ * Write this turn's gate artifacts and return the STABLE hook-script path plus
+ * the workspace gate directory.
+ *
+ * Two surfaces, deliberately split by scope:
+ *
+ * - Per-SESSION (in {@link hitlDir}): the approval-state file (hook input) and a
+ *   freshly-reset denial ledger (hook output the runner reads). Reset every turn
+ *   so the runner only ever reads denials from the current run, even across HITL
+ *   reinvocations and Temporal activity retries.
+ *
+ * - Per-WORKSPACE (in the gate dir): the STABLE hook script and the active-turn
+ *   pointer. The script path is stable across executions because the Cursor SDK
+ *   caches `.cursor/hooks.json` (the script path) for the runner process — a
+ *   per-session script would be cached at the first execution and reused for all
+ *   later ones, sending their denials to the first session's ledger (the
+ *   empty-ledger → COMPLETED regression). The script bakes NO per-session paths;
+ *   it reads the pointer, which we repoint (atomically) every turn to THIS turn's
+ *   state file, ledger, and runner PID. See generateHookScript / writeActiveTurnPointer.
  */
 async function writeHitlArtifacts(
+  workspaceRoot: string,
   hitlDir: string,
   approvalState: ApprovalStateFile,
   runnerPid: number,
-): Promise<string> {
+): Promise<{ scriptPath: string; gateDir: string }> {
   await mkdir(hitlDir, { recursive: true });
 
   const stateFilePath = await writeApprovalStateFile(hitlDir, approvalState);
-  // Reset the denial ledger for this turn so the runner only reads denials
-  // produced by the current run, even across HITL reinvocations on the durable
-  // HITL directory and Temporal activity retries.
   const ledgerFilePath = await resetDenialLedger(hitlDir);
-
-  const approvalScriptPath = join(hitlDir, HOOK_SCRIPT_FILE);
-  await writeFile(
-    approvalScriptPath,
-    generateHookScript(stateFilePath, ledgerFilePath, runnerPid),
-    "utf-8",
-  );
-  await chmod(approvalScriptPath, 0o755);
-
-  return approvalScriptPath;
+  // Reset the cas-observations sidecar too, so the turn boundary only ever reads
+  // gitignored observations the hook staged this run (deterministic across HITL
+  // reinvocations and Temporal retries, exactly like the denial ledger).
+  await resetCasObservations(hitlDir);
+
+  const gateDir = await ensureHitlGateDir(workspaceRoot);
+  const pointerPath = activePointerPath(gateDir);
+  const scriptPath = join(gateDir, HOOK_SCRIPT_FILE);
+  // Bake the workspace root so capture mode's `git check-ignore` runs against the
+  // right repo regardless of the hook's cwd. The root is stable per workspace
+  // (the gate dir is keyed by it), so the script stays stable across executions.
+  await writeFile(scriptPath, generateHookScript(pointerPath, workspaceRoot), "utf-8");
+  await chmod(scriptPath, 0o755);
+
+  // Point the stable hook at THIS turn's per-session artifacts (atomic, last
+  // write wins) — the single indirection that makes a process-cached hook resolve
+  // the current execution instead of the first one's.
+  await writeActiveTurnPointer(gateDir, {
+    stateFile: stateFilePath,
+    ledgerFile: ledgerFilePath,
+    runnerPid,
+  });
+
+  return { scriptPath, gateDir };
 }
 
 /**
@@ -157,7 +323,7 @@ async function writeHitlArtifacts(
 async function installWorkspaceHook(
   workspaceRoot: string,
   registrations: HookRegistration[],
-): Promise<HitlGateHandle> {
+): Promise<Omit<HitlGateHandle, "rule" | "gateDir">> {
   const cursorDir = join(workspaceRoot, CURSOR_DIR);
   const hooksJsonPath = join(cursorDir, HOOKS_CONFIG_FILE);
 
@@ -176,6 +342,31 @@ async function installWorkspaceHook(
   return { hooksJsonPath, restoreTo };
 }
 
+/**
+ * Snapshot and install the always-applied tool-approval rule into
+ * `.cursor/rules/stigmer-tool-approval.mdc`, returning the path + restore
+ * target. The filename is runner-owned, so restoreTo is normally null (teardown
+ * deletes it); if a same-named file somehow pre-exists (e.g. a crash-leftover
+ * from a prior turn), its bytes are captured and restored so we never clobber a
+ * file we did not create.
+ */
+async function installWorkspaceRule(workspaceRoot: string): Promise<WorkspaceFileSnapshot> {
+  const rulesDir = join(workspaceRoot, CURSOR_DIR, RULES_DIR);
+  const rulePath = join(rulesDir, TOOL_APPROVAL_RULE_FILE);
+
+  let restoreTo: string | null = null;
+  try {
+    restoreTo = await readFile(rulePath, "utf-8");
+  } catch {
+    restoreTo = null;
+  }
+
+  await mkdir(rulesDir, { recursive: true });
+  await writeFile(rulePath, buildToolApprovalRuleFile(), "utf-8");
+
+  return { path: rulePath, restoreTo };
+}
+
 /**
  * A hook entry the gate installs. Absolute `command` so the hook is found
  * regardless of which workspace root a multi-root IDE resolves against.
@@ -185,19 +376,28 @@ function buildHookEntry(scriptPath: string): Record<string, unknown> {
 }
 
 /**
- * Identify a hook entry the gate itself wrote (in this or a prior, crash-leftover
- * turn) so a re-install never duplicates it and a restore strips it. Matched by
- * the unmistakable runner-owned HITL script path (`~/.stigmer/sessions/.../*.sh`),
- * never by a user's own hook — covers every event and every gate script.
+ * Identify a hook entry the gate itself wrote — in this turn, a prior
+ * crash-leftover turn, or a pre-#173 runner build — so a re-install never
+ * duplicates it and a restore strips it. Matches two runner-owned shapes, never
+ * a user's own hook:
+ *
+ * 1. Current: any script under the runner-owned `~/.stigmer/` tree (the session
+ *    HITL dir or the workspace gate dir, `~/.stigmer/.../*.sh`) — location-based,
+ *    so it covers every gate script regardless of name.
+ * 2. Legacy: a `stigmer-*.sh` script (historically the in-workspace
+ *    `.cursor/hooks/stigmer-approval.sh`) — recognized by its unmistakably
+ *    runner-owned basename. Without this, the old in-workspace hook is treated
+ *    as a user hook and preserved by the merge, so it keeps running alongside
+ *    (and vetoing) the current gate. The `stigmer-` prefix is the same
+ *    runner-owned namespace convention as the rule filename.
  */
 function isStigmerHookEntry(entry: unknown): boolean {
   if (!entry || typeof entry !== "object") return false;
   const command = (entry as { command?: unknown }).command;
-  return (
-    typeof command === "string" &&
-    command.includes("/.stigmer/sessions/") &&
-    command.endsWith(".sh")
-  );
+  if (typeof command !== "string" || command.length === 0) return false;
+  if (command.includes("/.stigmer/") && command.endsWith(".sh")) return true;
+  const file = basename(command);
+  return file.startsWith(RUNNER_OWNED_HOOK_FILE_PREFIX) && file.endsWith(".sh");
 }
 
 const STANDALONE_CONFIG = (registrations: HookRegistration[]): string =>
@@ -274,11 +474,26 @@ export function buildMergedConfig(
 
   const merged = JSON.stringify({ ...root, version, hooks: mergedHooks }, null, 2);
 
-  // Restore the user's exact original bytes — unless we stripped a stale Stigmer
-  // entry, in which case restore the cleaned form so our leftover never lingers.
-  const restoreTo = strippedStale
-    ? JSON.stringify({ ...root, version, hooks: cleaned }, null, 2)
-    : originalRaw;
+  // No stale Stigmer entry → restore the user's exact original bytes.
+  if (!strippedStale) {
+    return { merged, restoreTo: originalRaw };
+  }
+
+  // We stripped a stale Stigmer entry, so never restore the original bytes (that
+  // would re-plant our leftover). If stripping leaves NO user hooks at all and
+  // the file carried nothing but `version`/`hooks`, the entire hooks.json was our
+  // own leftover (the pre-#173 design wrote the whole file) — delete it on
+  // teardown so a polluted repo is left pristine. Otherwise restore the cleaned,
+  // Stigmer-free form, preserving the user's other hooks and root fields.
+  const onlyVersionAndHooks = Object.keys(root).every(
+    (k) => k === "version" || k === "hooks",
+  );
+  const noUserHooksRemain = Object.values(cleaned).every(
+    (v) => Array.isArray(v) && v.length === 0,
+  );
+  const restoreTo = onlyVersionAndHooks && noUserHooksRemain
+    ? null
+    : JSON.stringify({ ...root, version, hooks: cleaned }, null, 2);
 
   return { merged, restoreTo };
 }