The Guard You Argue With
Part II: The Shared Machine
You are here if
A control you installed just refused you, and you are sure it is wrong. The hook bounced a tool call. The push came back denied. The delete demanded a token, took the token, and refused anyway. A review dispatch tripped a keyword filter that was never written with reviews in mind. The operation is legitimate, you can see it is, and the thing that cannot see it is a dozen lines of matching logic you wrote yourself on a calmer day.
You are here if your hand is already moving toward the pattern: one more exclusion, one looser regex, one commented-out line, just for today. You are here if you have re-fired the identical blocked call twice on the theory the guard might change its mind. You are here from the quiet side too: you found a tool surface no guard covers, or hardened one harness and started wondering about its sibling, because the second failure this chapter owns never fires anything.
If the gate belongs to someone else, a platform, a registry, a provider's policy, that is chapter 7. If the no came from a stale or wrong reading of the world and no control fired, that is chapter 1. If nothing fired and the friction is an untested assumption, that is chapter 11. This chapter is for the guard that is yours.
The mechanism
A guard is an operated system like everything else you run: authored once, matching text while the work it polices follows meaning. It fails in two directions. The false fire is loud: the rule was written wider than its target, and today it caught a literal string, a path shape, a sentence about the forbidden thing rather than one doing it. The silent gap is the other: the map the guard was written from is smaller than the machine, and a whole surface, the write path, the sibling tool, the second harness, goes unwatched. Same author, same plane, both directions at once.
The type specimen. A guard that scanned whole command strings for guarded phrases fired on a search query that contained, as literal text, the phrase the guard was built to stop. The command was reading about the thing, not doing it. The obvious fix was to narrow the pattern, and every drafted narrowing reopened a documented bypass the guard had been built fail-closed to hold shut. The false fire was not a defect to patch out; it was the purchase price of the floor. The fix that shipped cost the floor nothing: reword the query, move the logic into a script file, keep trigger phrases out of unrelated arguments. In the same season the dual arrived: an entire tool-call lane carried no guard at all, because every matcher targeted the shell-shaped calls the author had been burned by. The plane that cried wolf about a search query had been silent about a door.
That asymmetry is the chapter's economics. A false fire is loud and cheap; it files its complaint within the minute. A gap is silent and free until the day it is neither. So every pressure pushes toward narrowing what fires and never auditing what doesn't, and a plane maintained by irritation alone converges on quiet and useless. Book One earns the argument, from the guard that enumerates loses through two harnesses over one floor; this chapter inherits it whole and adds the minute after the block. The guards are also the one actor in this manual you installed personally: arguing with one is arguing with yourself, and winning by making it smaller is the one victory you cannot afford.
The discipline
Fix guard friction behaviorally, with a different tool, a different phrasing, or an explicit operator override, never by narrowing the guard, and audit the guard surface for the control that has never fired: a block is a signal to adapt, not an obstacle to defeat, and silence is not evidence of coverage.
That override has a boundary, printed here with it. An override is explicit, written, operator-issued, and stated in the report. All four. An approval you infer, remember, or grant yourself is not an override; it is the defeat the rule forbids, wearing the rule's own carve-out.
The ritual:
- Name the guard and what it matched. Identify from the block message which control fired, the pattern it keyed on, and what it exists to stop. Pass: you can state the guard's purpose and the text it matched as two separate facts.
- Classify the fire against the purpose, not the pattern. If the blocked operation is what the guard exists to stop, the guard is working and your plan changes. If not, it is a false fire: too broad, which is different from wrong. Pass: the classification argues from the guard's purpose, not your deadline.
- Probe what actually enforces. What a layer actually blocks is a claim like any other. If the next move depends on it, run one cheap live probe. Pass: the belief about enforcement was tested this session, not remembered from a document.
- Adapt in kind. A different tool: the authenticated CLI where raw requests are blocked. A different phrasing: reword the query, put the logic in a script file. A different location: scratch instead of the protected path. Or the sanctioned equivalent: the explicit file list, the merge instead of the rebase, the detached workspace. Pass: the retry differs in kind; an identical re-fire fails this step by definition.
- If no behavioral path exists, get the four-part override. Ask the operator, get it in writing, take the authorized path, and state it in the report. Pass: all four parts are present. Three of four is a defeat, not an override.
- File the false fire as a bug against the matching logic. The pattern has a defect; record it where guard fixes get made. Any fix must prove out in both directions: still blocking every documented bypass, now passing the legitimate operation. Pass: the entry exists, and no narrowing ships on the strength of one irritating afternoon.
- Audit the dual before you leave. The fire you just argued with is evidence the plane's map is out of date. Check read and write parity, sibling tool vectors, the sibling harness, and every surface added since the guard was written; a new surface is unguarded until proven otherwise. Pass: you can name the newest surface on the machine and say what guards it.
The case ledger
Sixteen entries. Most are fires argued with; three (E110, E111, E119) never fired, which is their point.
[E033] Working directory hardcoded into a hard-denied path (2026-06-28) Receipt: a self-tuning workflow hardcoded its working directory inside a protected path and hit a hard deny with no exception available. Rule: run such workflows in a scratch location; only the final artifact belongs under the protected path, and the operator moves it there.
[E048] Destructive git operations need harness-aware workarounds (2026-06-07 / 2026-06-12) Receipt: destructive git operations under the harness's guards each needed a non-obvious workaround: a modern history-rewrite tool, an explicit file list instead of a recursive delete, an alternate branch-delete command. Rule: default to the sanctioned safe equivalents for destructive git work, and check for other live worktrees before assuming a rogue process.
[E051] The no-push-from-main guard blocks legitimate backups too (undated) Receipt: a no-push-from-main guard blocked a legitimate emergency backup push, because it keys on the current branch, not the push destination. Rule: for backup or off-machine pushes from main, get the operator's explicit written go-ahead and bypass verification for that one push only, never for production deploys, and leave the guard's key alone.
[E053] The safe branch-delete check measures against the wrong head (2026-06-20) Receipt: deleting a local branch already merged into trunk failed, because the safe-delete check compares against the current head, which was elsewhere. Rule: to delete branches merged into a different reference, spin up a throwaway detached workspace at that reference and delete from there.
[E056] Stale PRs become mergeable without force-push (undated) Receipt: the reflex to rebase a stale PR onto main is not permitted under the harness's no-force-push policy. Rule: merge the base into the branch, never rebase, and merge server-side with squash so history stays clean without a force-push.
[E108] Don't narrow a fail-closed guard to kill its false positives (2026-06-20) Receipt: two major harness guards were fail-closed by design, and every proposed narrowing to kill a false positive reopened a documented critical bypass. Rule: fix a conservative guard's false positive behaviorally, with a different tool, different phrasing, or an explicit operator override; never narrow or weaken the guard itself.
[E110] Hardening one harness while its sibling stays loose (2026-06-12 / 2026-06-19 / 2026-06-20) Receipt: hardening a guard on one coding harness while a second defaulted to a much looser mode made the weaker harness the easier path to the same shared state. Rule: when you harden a guard on one harness, check the sibling for the same guarantee and port the pattern; keep any list two guard files share in one live-read policy file.
[E111] Write-side guards lag their read-side counterparts (2026-06-19) Receipt: a write-side guard lagged its read-side counterpart on path coverage, and another covered one tool vector but not its sibling, leaving gaps where control state could be rewritten unnoticed. Rule: when reviewing or adding a guard, check read/write parity and both tool vectors, and protect any directory whose contents a guard trusts as control state.
[E112] Keyword-matching dispatch guards block legitimate reviews (2026-05-31) Receipt: a keyword-matching dispatch guard blocked legitimate code-review dispatches even with an explicit model override set. Rule: reword the dispatch to avoid the trigger phrases, and if a small low-stakes review still blocks, do it inline rather than fighting the guard.
[E113] A block is a signal to adapt, not to retry blindly (2026-04-12) Receipt: the reflex on a blocked tool call was to re-fire the identical call, fighting the guard instead of adapting to it. Rule: read the block message and change something real, the tool, the path, or the question to the operator; never re-fire the same call, and never narrow the guard to get through.
[E114] String-scan guards trip on unrelated literal text (2026-06-02 / 2026-06-12 / 2026-06-14) Receipt: whole-command string scans fired on literal text in a search query or heredoc that merely resembled a guarded phrase. Rule: use the prescribed safe flow for guarded operations and keep trigger phrases out of unrelated command arguments; never disable verification to get past a false positive.
[E115] A confirm-token gate false-positived on path shapes (2026-05-30, resolved historically) Receipt: a confirmation-token gate false-positived on delete paths containing certain hyphenated character sequences. Rule: treat a token-gate false positive as a bug report against the gate's matching logic, not a reason to route around the gate.
[E117] Forbid gates must check commitment, not bare keywords (undated) Receipt: a keyword forbid gate kept false-firing on dismissed or explained mentions of the forbidden term: dismissal is semantic, not a fixed negation word. Rule: gate a forbid rule on actual commitment, a verb-plus-token pattern in the right-sized scope, with a wide vocabulary for dismissals.
[E119] An entire tool-call surface was unguarded (2026-06-07) Receipt: every pre-tool-use matcher targeted shell, edit, and agent calls, leaving the whole MCP tool-call surface unguarded until noticed and closed. Rule: treat any new tool surface as unguarded until proven otherwise; that lane now runs through its own policy-driven guard.
[E120] A valid token does not clear every gate (2026-05-30 / 2026-06-07 / 2026-06-19) Receipt: a valid one-time confirmation token cleared the token gate, and a separate permission layer still refused a recursive delete under the home directory. Rule: don't spend tokens trying to force a deep recursive delete under the home directory; hand the operator the exact command to run themselves.
[E125] An egress guard blocks raw requests but not an authenticated CLI (2026-06-27 / 2026-07-03) Receipt: a network-egress guard blocked plain HTTP to hosting and registry domains while the authenticated deploy CLI and a dedicated fetch tool reached the same endpoints fine. Rule: under an egress restriction, deploy with the authenticated CLI and verify with the dedicated fetch tool, rather than assuming the network is unreachable.
Adjacent doors
If the gate that refused you belongs to someone else, a platform's classifier, a registry's policy, most of this chapter is unavailable: there is no matching logic to file a bug against, no sibling file to port a pattern to. You adapt or comply, and the disciplines for that on machines you don't own are chapter 7's.
If the no was a reading, not a rule, an index saying not shipped about a publish that landed, a status computed from a stale source, then no control fired and nothing here applies. A guard tripping on a literal string is not lying; its rule is too broad. A signal misreporting the world was never enforcing anything. A false red with no control behind it is chapter 1's.
If nothing fired at all, and the friction is an assumption that something would, you are not arguing with a guard, you are imagining one, and the correction runs in the opposite direction: that is chapter 11. The guard you argue with at least exists. It fired, it left a message, it can be named, probed, and filed against. The one you only assumed never did, and deference to it buys nothing.