cursordoctrine 0.4.1 → 0.4.2

package/INSTALL.md

@@ -109,7 +109,7 @@ Also validate the config: `~/.cursor/hooks.json` must parse as JSON.
 
 1. Restart Cursor (hooks.json is read at startup).
 2. Open any project and start a new agent chat. The doctrine should be in context — ask the agent "what does your doctrine say about diffs?" and it should answer from §2; ask "what is the Anchor Set?" and it should answer from `pre-compile.md` (Objective / Constraints / Scope / Deterministic success).
-3. Have the agent make a small edit to a tracked file. On the next turn it should receive a `SELF-REVIEW TRIGGER` message, and (if it's the first edit of the implementation) a `PRE-COMPILE NUDGE` reminder to write its Anchor Set to `.scope.json`.
+3. Have the agent make a small edit to a tracked file. On the next turn it should receive a `SELF-REVIEW TRIGGER` message, and (if it's the first edit of that turn) a `PRE-COMPILE NUDGE` reminder to write its Anchor Set to `.scope.json`. The nudge re-fires on the first edit of each new turn.
 4. Ask the agent to run `git push --force` (in a throwaway repo). The permission gate must block it.
 5. Finish a small implementation and stop. A single `FINAL REVIEW` follow-up should fire — exactly once.
 6. Delegate a small edit to a subagent (e.g. ask the agent to "use a generalPurpose subagent to add a comment to <file>"). The subagent should receive one `SUBAGENT FINAL REVIEW` follow-up before returning, and the parent should see `SUBAGENT WORK DETECTED` at its next tool boundary. (`subagentStop` is only read at startup — if nothing fires, restart Cursor again.)

package/README.md

@@ -21,7 +21,7 @@
 
 Cursor hooks that make the agent review its own edits without bolting a static-analysis pipeline onto every keystroke. No regex army, no scoring engine. Four jobs:
 
-1. **Compile intent before coding** (proactive) — at session start the agent gets the doctrine plus the **Anchor Set** discipline (`pre-compile.md`): before writing code it must emit *Objective / Constraints / Scope / Deterministic success*, and write that contract to `.scope.json`. On the first edit of each implementation a `anchor-set-nudge` advisory fires to catch intent dilution at token ~50 instead of waiting for the stop-hook review at token ~5000.
+1. **Compile intent before coding** (proactive) — at session start the agent gets the doctrine plus the **Anchor Set** discipline (`pre-compile.md`): before writing code it must emit *Objective / Constraints / Scope / Deterministic success*, and write that contract to `.scope.json`. On the first edit of each agent turn a `anchor-set-nudge` advisory fires to catch intent dilution at token ~50 instead of waiting for the stop-hook review at token ~5000.
 2. **Inject the doctrine** at session start — every chat starts with the same short governing text (`doctrine.md`, `USER-RULES.md`, `declared-editing.md` the YAGNI ultra ladder, and `pre-compile.md` the thin intent-compilation phase).
 3. **Hand the model its own edits back** (reactive) — after each agent edit, a self-review prompt goes into a pending file (plus semantic-density, scope-gate, anti-slop, and the pre-compile nudge advisories when they trip). Next turn the model reads its diff, fixes real bugs, stays quiet otherwise.
 4. **Gate blast radius** — one permission gate denies a short explicit list of dangerous commands (`rm -rf /`, `curl | sh`, force-push, `npm publish`, ...). Everything else passes.
@@ -90,7 +90,7 @@ Two machine-checkable consequences:
 - **`scope-gate-audit`** (afterFileEdit, opt-in via `.scope.json` existing) audits every edit against `files[]` and quotes `intent` + `acceptance` back on a violation. Editing outside the declared set is the textbook scope-creep signal.
 - **final-review axis 0** (intent trace) traces every diff hunk back to `intent`. Anything untraceable is a hallucinated requirement.
 
-On the **first edit of each implementation**, `anchor-set-nudge` drops a reminder into the feedback bus: *did you write your Anchor Set to `.scope.json`?* One nudge per body of work — the flag is cleared at the same per-implementation boundary where the final-review one-shot brake fires, so a long chat with N implementations gets N nudges.
+On the **first edit of each agent turn**, `anchor-set-nudge` drops a reminder into the feedback bus: *did you write your Anchor Set to `.scope.json`?* One nudge per turn — the latch is armed on that first edit and cleared **unconditionally** by the stop hook on every turn boundary, so the next turn re-earns its nudge. A long chat with N turns gets up to N nudges, and the latch can never get stranded silenced mid-session.
 
 The Anchor Set is skipped for trivial one-liners (typo, literal) — the `declared-editing.md` ladder's rung 1 governs when it's overkill.
 
@@ -101,7 +101,7 @@ The Anchor Set is skipped for trivial one-liners (typo, literal) — the `declar
 | Session | `sessionStart` | `inject-doctrine` reads doctrine + user rules + declared-editing + **pre-compile** and emits them as `additional_context`. |
 | Every turn | `postToolUse` | Folds completed subagents' edit markers into this conversation's marker, then drains the conversation's pending feedback file into `additional_context`. One-shot, keyed by conversation id. |
 | Shell | `beforeShellExecution` | `permission-gate` checks the command against a deny list. Allow by default, deny by list, fail open. |
-| Edit | `afterFileEdit` + `stop` | **Proactive:** `anchor-set-nudge` fires once per implementation to push the Anchor Set. **Reactive:** `self-review-trigger` stashes the review prompt per edit; `minimal-edit-audit` (deprecated), `semantic-density-audit`, `scope-gate-audit` (opt-in, audits `.scope.json`), and `anti-slop-audit` append advisories when they trip; `final-review` fires one end-of-implementation six-axis pass. |
+| Edit | `afterFileEdit` + `stop` | **Proactive:** `anchor-set-nudge` fires once per turn (on its first edit) to push the Anchor Set. **Reactive:** `self-review-trigger` stashes the review prompt per edit; `minimal-edit-audit` (deprecated), `semantic-density-audit`, `scope-gate-audit` (opt-in, audits `.scope.json`), and `anti-slop-audit` append advisories when they trip; `final-review` fires one end-of-implementation six-axis pass. |
 | Subagent | `subagentStop` | `subagent-stop-review` fires one in-subagent final review when a delegated run edited files, before the result returns to the parent. Marker-gated and flag-braked like `final-review`. |
 
 ## Layout
@@ -150,7 +150,7 @@ All hooks fail open and always exit 0. Nothing here can block your session.
 
 - **State lives under `$HOME`**, in `~/.cursor/.hooks-pending/`, keyed by conversation id. No repo litter. Concurrent sessions can't drain each other's prompts. Stale state older than 7 days gets swept on every stop.
 - **`afterFileEdit` output isn't consumed by Cursor**, so edit hooks write to a pending file and `post-tool-use` re-emits it at the next tool boundary. That's the whole message bus.
-- **One review per implementation.** The stop hook arms a per-conversation flag before emitting its follow-up, so a crash can't re-fire it and a long chat still gets a review after each implementation. The `anchor-set-nudge` flag and the review flag clear together at that boundary — one nudge + one review per body of work.
+- **One review per implementation.** The stop hook arms a per-conversation flag before emitting its follow-up, so a crash can't re-fire it and a long chat still gets a review after each implementation. The `anchor-set-nudge` latch is separate and simpler: it's cleared **unconditionally** on every stop, so the nudge re-fires on the first edit of each new turn and can never get stranded silenced mid-session.
 - **The `.scope.json` contract is opt-in.** No `.scope.json` in the repo root → `scope-gate-audit` stays silent and the system falls back to the `declared-editing` ladder plus the final-review footprint check. Writing the file is how the agent opts into a machine-checked scope.
 - **Subagents are first-class.** `afterFileEdit` fires inside subagents keyed by the subagent's conversation id. The harness normalizes agent edits (incl. `StrReplace`) to tool type `Write`, and `postToolUse` never fires for the `Task` tool — verified by payload capture. Matchers cover `Write|StrReplace|EditNotebook` defensively. `subagentStop` reviews the subagent in its own context. The parent folds orphaned subagent markers (from the `subagents/` transcript directory) into its own at every tool boundary and at stop.
 

package/bin/cli.mjs

@@ -263,19 +263,40 @@ function verify() {
     return true;
   });
 
-  check('anchor-set nudge fires on first edit, then goes quiet', () => {
-    // First edit of the implementation -> the pre-compile nudge stashes its
-    // advisory in the pending feedback bus and arms the one-shot flag.
-    const first = runHook(hook('anchor-set-nudge'), { conversation_id: 'npxv3', file_path: join(HOME, 'x.py') });
-    if (!first.includes('additional_context') || !first.includes('PRE-COMPILE NUDGE')) {
-      // anchor-set-nudge appends to feedback-<cid>.txt (the shared bus) rather
-      // than emitting JSON directly; drain it the same way post-tool-use does.
-      const drained = runHook(hook('post-tool-use'), { conversation_id: 'npxv3' });
-      if (!drained.includes('PRE-COMPILE NUDGE')) return { ok: false, detail: 'nudge did not reach the feedback bus on first edit' };
+  check('anchor-set nudge fires once per turn, stop re-arms it', () => {
+    // anchor-set-nudge appends to feedback-<cid>.txt (the shared bus) rather
+    // than emitting JSON directly; drain it the same way post-tool-use does.
+    const drainedOf = (cidv) => runHook(hook('post-tool-use'), { conversation_id: cidv });
+
+    // --- Turn 1 -------------------------------------------------------------
+    // First edit -> nudge stashes into the feedback bus and arms the latch.
+    runHook(hook('anchor-set-nudge'), { conversation_id: 'npxv3', file_path: join(HOME, 'x.py') });
+    if (!drainedOf('npxv3').includes('PRE-COMPILE NUDGE')) {
+      return { ok: false, detail: 'nudge did not reach the feedback bus on first edit' };
+    }
+    // Second edit same turn -> latch armed, nudge must stay silent.
+    runHook(hook('anchor-set-nudge'), { conversation_id: 'npxv3', file_path: join(HOME, 'y.py') });
+    if (drainedOf('npxv3').includes('PRE-COMPILE NUDGE')) {
+      return { ok: false, detail: 'nudge re-fired on second edit (latch not gating)' };
+    }
+    // End of turn: final-review clears the latch unconditionally. Drive a
+    // review-less stop (no session-edits marker) so it hits the clear path and
+    // exits {}, same as a turn that produced no reviewable edits.
+    const stopOut = runHook(hook('final-review'), { conversation_id: 'npxv3', status: 'completed' });
+    if (stopOut !== '{}' && stopOut.replace(/\s/g, '') !== '{}') {
+      // A review fired (fine - the earlier edit left a session-edits marker via
+      // self-review-trigger if one ran). What matters is the latch got cleared;
+      // we verify that with the next-turn re-fire below.
+    }
+    // --- Turn 2 -------------------------------------------------------------
+    // First edit of the NEXT turn -> latch was cleared at the stop boundary, so
+    // the nudge MUST re-fire. This is the regression that 0.4.0 shipped broken:
+    // the latch only cleared on the fragile second-stop path, so it stranded
+    // and the nudge went permanently silent mid-session.
+    runHook(hook('anchor-set-nudge'), { conversation_id: 'npxv3', file_path: join(HOME, 'z.py') });
+    if (!drainedOf('npxv3').includes('PRE-COMPILE NUDGE')) {
+      return { ok: false, detail: 'nudge did NOT re-fire on the next turn (latch stranded at the stop boundary)' };
     }
-    // Second edit -> flag is armed, nudge must stay silent.
-    const second = runHook(hook('anchor-set-nudge'), { conversation_id: 'npxv3', file_path: join(HOME, 'y.py') });
-    if (second.includes('PRE-COMPILE NUDGE')) return { ok: false, detail: 'nudge re-fired on second edit (flag not gating)' };
     return true;
   });
 

package/linux/hooks/anchor-set-nudge.sh

@@ -2,20 +2,20 @@
 # anchor-set-nudge.sh - afterFileEdit "pre-compile" nudge (Cursor, Linux).
 #
 # Proactive counterpart to the reactive audits. On the FIRST file edit of an
-# implementation (per conversation), remind the agent to compile its Anchor Set
-# (pre-compile.md) and write .scope.json BEFORE piling on more code. The
-# reactive stack (self-review, anti-slop, final-review) only fires AFTER code
-# exists; this nudge catches intent dilution at token ~50, not at the ~5000 of
-# the stop-hook axis 0. A clean final review of the wrong feature is still the
-# wrong feature - the Anchor Set exists so the right feature is on the rails
-# from the first edit.
+# agent turn, remind the agent to compile its Anchor Set (pre-compile.md) and
+# write .scope.json BEFORE piling on more code. The reactive stack (self-review,
+# anti-slop, final-review) only fires AFTER code exists; this nudge catches
+# intent dilution at token ~50, not at the ~5000 of the stop-hook axis 0. A
+# clean final review of the wrong feature is still the wrong feature - the
+# Anchor Set exists so the right feature is on the rails from the first edit.
 #
-# One-shot PER IMPLEMENTATION, not per session: gated by an
-# anchor-declared-<cid>.flag in the pending dir. That flag is cleared by
-# final-review.sh / subagent-stop-review.sh at the SAME per-implementation
-# boundary where they clear session-edits-<cid>.txt and reviewed-<cid>.flag
-# (the stop after a review pass). So a long conversation with N implementations
-# gets N nudges, not one - every new body of work re-earns the reminder.
+# Fires ONCE PER TURN (per conversation): gated by an anchor-declared-<cid>.flag
+# in the pending dir, armed here on first edit and cleared UNCONDITIONALLY by
+# final-review.sh / subagent-stop-review.sh on every stop. So a long
+# conversation with N turns gets up to N nudges - every new turn re-earns the
+# reminder on its first edit. The clear is unconditional (not gated on the
+# reviewed-flag path) so the latch can never get stranded silenced mid-session,
+# which would silently stop reminding the agent to write .scope.json.
 #
 # Advisory only: never blocks, never reads the diff, ALWAYS exits 0. Appends to
 # the shared feedback-<cid>.txt bus; post-tool-use.sh delivers it next turn.

package/linux/hooks/final-review.sh

@@ -41,11 +41,16 @@ anchor_flag="$pending_dir/anchor-declared-$cid.flag"
 # Sweep state from sessions that died before their stop hook ran.
 find "$pending_dir" -maxdepth 1 -type f -mtime +7 -delete 2>/dev/null
 
+# Unconditionally clear the pre-compile nudge's per-turn latch. Every stop is a
+# turn boundary; clearing here (not only inside the reviewed-flag block below)
+# guarantees the nudge re-fires on the first edit of the NEXT turn and can never
+# get stranded silenced. Clearing it only on the SECOND stop left the nudge
+# permanently off for any conversation that never cleanly hit that boundary.
+rm -f "$anchor_flag" 2>/dev/null
+
 # One-shot brake: the previous stop for this conversation emitted the review.
-# Also clear anchor-declared-<cid>.flag so the pre-compile nudge re-fires for
-# the NEXT implementation (one nudge per body of work, not per session).
 if [ -f "$flag" ]; then
-    rm -f "$flag" "$marker" "$anchor_flag" 2>/dev/null
+    rm -f "$flag" "$marker" 2>/dev/null
     emit_none
 fi
 

package/linux/hooks/subagent-stop-review.sh

@@ -46,11 +46,14 @@ marker="$pending_dir/session-edits-$cid.txt"
 flag="$pending_dir/reviewed-$cid.flag"
 anchor_flag="$pending_dir/anchor-declared-$cid.flag"
 
+# Unconditionally clear the pre-compile nudge's per-turn latch so it re-fires
+# on the first edit of the next subagent run. Clearing here (not only inside
+# the reviewed-flag block below) can never strand the nudge silenced.
+rm -f "$anchor_flag" 2>/dev/null
+
 # One-shot brake: the previous subagentStop for this id emitted the review.
-# Also clear anchor-declared-<cid>.flag so the pre-compile nudge re-fires for
-# the next subagent implementation (one nudge per body of work).
 if [ -f "$flag" ]; then
-    rm -f "$flag" "$marker" "$anchor_flag" 2>/dev/null
+    rm -f "$flag" "$marker" 2>/dev/null
     emit_none
 fi
 

package/linux/hooks.json

@@ -43,7 +43,7 @@
         "command": "bash ~/.agents/hooks/anchor-set-nudge.sh",
         "timeout": 5,
         "matcher": "^(Write|StrReplace|EditNotebook)$",
-        "_comment": "5s: PROACTIVE pre-compile nudge. On the FIRST edit of each implementation (per conversation), remind the agent to compile its Anchor Set (pre-compile.md) into .scope.json BEFORE piling on more code. The reactive audits (self-review / anti-slop / final-review axis 0) only fire after code exists; this catches intent dilution at token ~50 instead of ~5000. One-shot per implementation: gated by anchor-declared-<cid>.flag, which final-review.sh / subagent-stop-review.sh clear at the same per-implementation boundary as reviewed-<cid>.flag. Advisory only; never blocks. Disable: HOOKS_ENFORCE=0 or ANCHOR_NUDGE_ENFORCE=0."
+        "_comment": "5s: PROACTIVE pre-compile nudge. On the FIRST edit of each agent turn (per conversation), remind the agent to compile its Anchor Set (pre-compile.md) into .scope.json BEFORE piling on more code. The reactive audits (self-review / anti-slop / final-review axis 0) only fire after code exists; this catches intent dilution at token ~50 instead of ~5000. One-shot per turn: gated by anchor-declared-<cid>.flag, armed here on first edit and cleared UNCONDITIONALLY by final-review.sh / subagent-stop-review.sh on every stop - so it re-fires on the first edit of the next turn and can never get stranded silenced. Advisory only; never blocks. Disable: HOOKS_ENFORCE=0 or ANCHOR_NUDGE_ENFORCE=0."
       }
     ],
     "postToolUse": [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cursordoctrine",
-  "version": "0.4.1",
-  "description": "Thin self-review hooks for Cursor — the model is the auditor. Pre-compile Anchor Set phase (proactive intent compilation), intent-trace final review (Tier 0), unified 13-item anti-slop checklist, operational slop detection.",
+  "version": "0.4.2",
+  "description": "Thin self-review hooks for Cursor — the model is the auditor. Pre-compile Anchor Set phase (proactive intent compilation, fires once per turn), intent-trace final review (Tier 0), unified 13-item anti-slop checklist, operational slop detection.",
   "bin": {
     "cursordoctrine": "bin/cli.mjs"
   },

package/windows/hooks/anchor-set-nudge.ps1

@@ -1,20 +1,20 @@
 # anchor-set-nudge.ps1 - afterFileEdit "pre-compile" nudge (Cursor).
 #
 # Proactive counterpart to the reactive audits. On the FIRST file edit of an
-# implementation (per conversation), remind the agent to compile its Anchor Set
-# (pre-compile.md) and write .scope.json BEFORE piling on more code. The
-# reactive stack (self-review, anti-slop, final-review) only fires AFTER code
-# exists; this nudge catches intent dilution at token ~50, not at the ~5000 of
-# the stop-hook axis 0. A clean final review of the wrong feature is still the
-# wrong feature - the Anchor Set exists so the right feature is on the rails
-# from the first edit.
+# agent turn, remind the agent to compile its Anchor Set (pre-compile.md) and
+# write .scope.json BEFORE piling on more code. The reactive stack (self-review,
+# anti-slop, final-review) only fires AFTER code exists; this nudge catches
+# intent dilution at token ~50, not at the ~5000 of the stop-hook axis 0. A
+# clean final review of the wrong feature is still the wrong feature - the
+# Anchor Set exists so the right feature is on the rails from the first edit.
 #
-# One-shot PER IMPLEMENTATION, not per session: gated by an
-# anchor-declared-<cid>.flag in the pending dir. That flag is cleared by
-# final-review.ps1 / subagent-stop-review.ps1 at the SAME per-implementation
-# boundary where they clear session-edits-<cid>.txt and reviewed-<cid>.flag
-# (the stop after a review pass). So a long conversation with N implementations
-# gets N nudges, not one - every new body of work re-earns the reminder.
+# Fires ONCE PER TURN (per conversation): gated by an anchor-declared-<cid>.flag
+# in the pending dir, armed here on first edit and cleared UNCONDITIONALLY by
+# final-review.ps1 / subagent-stop-review.ps1 on every stop. So a long
+# conversation with N turns gets up to N nudges - every new turn re-earns the
+# reminder on its first edit. The clear is unconditional (not gated on the
+# reviewed-flag path) so the latch can never get stranded silenced mid-session,
+# which would silently stop reminding the agent to write .scope.json.
 #
 # Advisory only: never blocks, never reads the diff, ALWAYS exits 0. Appends to
 # the shared feedback-<cid>.txt bus; post-tool-use.ps1 delivers it next turn.

package/windows/hooks/final-review.ps1

@@ -48,12 +48,19 @@ Get-ChildItem $pendingDir -File -ErrorAction SilentlyContinue |
     Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-7) } |
     Remove-Item -Force -ErrorAction SilentlyContinue
 
+# Unconditionally clear the pre-compile nudge's per-turn latch. Every stop is a
+# turn boundary; clearing here (not only inside the reviewed-flag block below)
+# guarantees the nudge re-fires on the first edit of the NEXT turn and can never
+# get stranded silenced. The original design cleared anchor-declared-<cid>.flag
+# only on the SECOND stop (the reviewed-flag path), so any conversation that
+# never cleanly hit that boundary left the nudge permanently off - the agent
+# then stopped being reminded to write .scope.json.
+Remove-Item $anchorFlag -Force -ErrorAction SilentlyContinue
+
 # One-shot brake: the previous stop for this conversation emitted the review.
 # Clear the flag (and whatever the review pass itself edited) and end the loop.
-# Also clear anchor-declared-<cid>.flag so the pre-compile nudge re-fires for
-# the NEXT implementation (one nudge per body of work, not per session).
 if (Test-Path $flag) {
-    Remove-Item $flag, $marker, $anchorFlag -Force -ErrorAction SilentlyContinue
+    Remove-Item $flag, $marker -Force -ErrorAction SilentlyContinue
     Emit-None
 }
 

package/windows/hooks/subagent-stop-review.ps1

@@ -45,11 +45,14 @@ $marker = Join-Path $pendingDir "session-edits-$cid.txt"
 $flag   = Join-Path $pendingDir "reviewed-$cid.flag"
 $anchorFlag = Join-Path $pendingDir "anchor-declared-$cid.flag"
 
+# Unconditionally clear the pre-compile nudge's per-turn latch so it re-fires
+# on the first edit of the next subagent run. Clearing here (not only inside
+# the reviewed-flag block below) can never strand the nudge silenced.
+Remove-Item $anchorFlag -Force -ErrorAction SilentlyContinue
+
 # One-shot brake: the previous subagentStop for this id emitted the review.
-# Also clear anchor-declared-<cid>.flag so the pre-compile nudge re-fires for
-# the next subagent implementation (one nudge per body of work).
 if (Test-Path $flag) {
-    Remove-Item $flag, $marker, $anchorFlag -Force -ErrorAction SilentlyContinue
+    Remove-Item $flag, $marker -Force -ErrorAction SilentlyContinue
     Emit-None
 }
 

package/windows/hooks.json

@@ -43,7 +43,7 @@
         "command": "pwsh.exe -NoProfile -File ~/.agents/hooks/anchor-set-nudge.ps1",
         "timeout": 5,
         "matcher": "^(Write|StrReplace|EditNotebook)$",
-        "_comment": "5s: PROACTIVE pre-compile nudge. On the FIRST edit of each implementation (per conversation), remind the agent to compile its Anchor Set (pre-compile.md) into .scope.json BEFORE piling on more code. The reactive audits (self-review / anti-slop / final-review axis 0) only fire after code exists; this catches intent dilution at token ~50 instead of ~5000. One-shot per implementation: gated by anchor-declared-<cid>.flag, which final-review.ps1 / subagent-stop-review.ps1 clear at the same per-implementation boundary as reviewed-<cid>.flag. Advisory only; never blocks. Disable: HOOKS_ENFORCE=0 or ANCHOR_NUDGE_ENFORCE=0."
+        "_comment": "5s: PROACTIVE pre-compile nudge. On the FIRST edit of each agent turn (per conversation), remind the agent to compile its Anchor Set (pre-compile.md) into .scope.json BEFORE piling on more code. The reactive audits (self-review / anti-slop / final-review axis 0) only fire after code exists; this catches intent dilution at token ~50 instead of ~5000. One-shot per turn: gated by anchor-declared-<cid>.flag, armed here on first edit and cleared UNCONDITIONALLY by final-review.ps1 / subagent-stop-review.ps1 on every stop - so it re-fires on the first edit of the next turn and can never get stranded silenced. Advisory only; never blocks. Disable: HOOKS_ENFORCE=0 or ANCHOR_NUDGE_ENFORCE=0."
       }
     ],
     "postToolUse": [