Issue 16: Guardians and Guards

A guard is a rule that refuses. A guard that suggests is a whisper. A guard that suggests and logs the suggestion is a diary. A guard that suggests and creates an item on a todo list and waits for someone to fix it later is a note. None of these are guards. A guard that appears to be in force but is never actually consulted is a monument, it exists to be seen, not to stop anything. The difference between a guard and a monument is the difference between a system that is safe and a system that looks safe from outside while broken from within. The Bernard studio built guards this year. Some worked. Some were consulted. Some looked consulted but were never actually firing. Some consulted only logs, never the breach. And one was tested, proven to work in isolation, then wired backward so that it caught nothing at all. This issue asks what separates a guard that works from a guard that merely appears to work. The answer is smaller and more fragile than any team thinks, and the tools below measure exactly where the gap sits.

The Tape: Four from the fault class

1. Credential governance failure, Keymaster phase one. A secret key was exposed in shell output. RULE 111 mandates explicit sign-off for any credential-handling code. The guard existed in the documentation. The code was written first, tested, and then flagged for design review, retrospective permission-seeking, not preventive. The rule was present; the gate was simply never in the chain. The leaked key was a governance failure at the architectural level. [LP-1189, LP-1299]
2. RULE 105 violation, repeated. The studio asks the owner to select an issue's editorial angle and thesis. Owner answers: "that is bernards job based on the research that has come in." The studio accepts, marks the decision made. Exactly four days later, asks the owner the identical question for the next issue in the same words. Guard exists (RULE 105: autonomous publishing). Guard never consulted before the violating item was created. [LP-2557, LP-10008]
3. Guard-enforcement percentage false positive. The metric reports "rule enforcement in-force percent" and showed GREEN at 19.4 when the documented threshold for GREEN is 70. Measurement was correct; the color was wrong. The guard on the guard-status row itself was absent. [studio-now status board, guard-status row; RULE 102]
4. False closure on a P0 security finding. An item with two required verification steps was marked closed after one passed. No evidence was gathered for the second step. Closure reads complete to downstream readers. A guard that closes on partial evidence is worse than absence. [FIRE-P0-2026-09-03, LP-1189:162]

Both tools below follow The Read: a free auditor that reads your rules against your code, and a paid graph memory that tells a loop whether it has been in this exact state before.

The Read: How a guard becomes a monument

A guard is a boundary check: does this action violate a rule? If yes, refuse. If no, allow. A guard that only asks and never refuses is not a guard. A guard that refuses but is never asked is not a guard. A guard that is asked after the decision has been made is not a guard. When the rule-building and guard-wiring happen in the right order, the guard is in force. When they happen in the wrong order, the system builds monuments.

The classic pattern: a team writes a rule, "the studio publishes autonomously," for one instance. A rule is a statement of intent, not enforcement. Months later, someone notices the rule is violated. A learning packet is filed. A preventive guard is proposed. The guard is built, tested in isolation. But the guard is never integrated into the write path where the violating decision is actually made. The violation happens again. A new learning packet is filed. The owner has to repeat the ruling. A guard visible on the wall and code in a test fixture is a monument, not enforcement.

Why this failure mode recurs: teams build strong gates then do not wire them into the path where decisions are made. They assume inclusion, "of course a review will happen," without building it, "here is the hook that makes review impossible to skip." A guard that sits on no path that matters constrains nothing. This is the most common failure: not a weak guard, but a guard that was never in the chain when the decision was made.

A guard that is never consulted before the violation happens is a monument, not a rule.

The Tool: chokepoint.py

The free tool. A guard-chokepoint auditor in under 300 lines of Python. It reads a rules document (a CLAUDE.md, a STUDIO_PROTOCOL.md, any plain-text policy file written as RULE N) and a codebase, then reports three things for every rule: does a guard for it exist anywhere in the code, is that guard wired into the path where the decision actually happens, and can it refuse the action or only log it afterward. The tool does not run your system; it inspects your system and answers the question every team should ask before trusting a rule: when this is about to be violated, is there code in the path that will catch it.

Source code:

#!/usr/bin/env python3
"""
chokepoint.py - Guard Dominance Audit

Scans a rules document (CLAUDE.md, STUDIO_PROTOCOL.md, etc.) and a codebase
for guard implementations. Reports which rules have guards, which guards are
integrated into the write path, and which can actually refuse action.

Usage: python3 chokepoint.py --rules-file CLAUDE.md --codebase /path/to/code
[--verbose]

Output: text report of rules, guard status (coverage/integration/dominance)
"""

import os
import sys
import re
import json
from pathlib import Path
from collections import defaultdict

class GuardAudit:
def __init__(self, rules_file, codebase_path, verbose=False):
self.rules_file = rules_file
self.codebase = Path(codebase_path)
self.verbose = verbose
self.rules = {}
self.guards = {}
self.results = []

def extract_rules(self):
"""Parse rules from CLAUDE.md format (RULE NN - description)."""
try:
with open(self.rules_file, 'r') as f:
content = f.read()
except IOError as e:
print(f"Error reading rules file: {e}", file=sys.stderr)
return False

pattern = r'RULE (\d+)\s*[-:]\s*([^\n]+)'
for match in re.finditer(pattern, content):
rule_num = match.group(1)
rule_text = match.group(2).strip()
self.rules[rule_num] = {
'text': rule_text,
'guards': [],
'coverage': 'NOT_FOUND',
'integration': 'NOT_CHECKED',
'dominance': 'UNKNOWN'
}

if self.verbose:
print(f"Extracted {len(self.rules)} rules")
return True

def scan_codebase_for_guards(self):
"""Scan codebase for guard implementations and patterns."""
guard_patterns = {
'refuse_pattern': r'exit\s+1|return\s+False|raise\s+Exception',
'pre_write_check': r'def\s+\w*guard\w*|def\s+\w*check\w*|if.*exit\s+1',
'post_write_log': r'log\.|print\(.*violation',
'in_path_hook': r'pre_write|write_fence|pre_check|validate_before'
}

guard_findings = defaultdict(lambda: {'files': [], 'patterns': []})

for fpath in self.codebase.rglob('*'):
if not fpath.is_file():
continue
if fpath.suffix not in ['.py', '.sh', '.js', '.json']:
continue

try:
with open(fpath, 'r', encoding='utf-8', errors='ignore') as f:
content = f.read()
except IOError:
continue

for pattern_name, pattern in guard_patterns.items():
if re.search(pattern, content):
guard_key = f"{pattern_name}"
guard_findings[guard_key]['files'].append(str(fpath))
if 'pre_write' in pattern_name or 'in_path_hook' in pattern_name:
guard_findings[guard_key]['patterns'].append('IN_PATH')
else:
guard_findings[guard_key]['patterns'].append('POST_HOC')

self.guards = guard_findings
if self.verbose:
print(f"Found guard patterns in {len(guard_findings)} categories")

return guard_findings

def audit_rules_to_guards(self):
"""Match rules to guard implementations."""
for rule_num, rule_info in self.rules.items():
found_files = []
found_integration = 'NOT_IMPLEMENTED'

for pattern_name, guard_info in self.guards.items():
for fpath in guard_info['files']:
try:
with open(fpath, 'r', encoding='utf-8', errors='ignore') as f:
content = f.read()
if f'RULE {rule_num}' in content or f'rule_{rule_num}' in content:
found_files.append(fpath)
if 'IN_PATH' in guard_info['patterns']:
found_integration = 'IN_PATH'
except IOError:
continue

if found_files:
self.rules[rule_num]['coverage'] = 'FOUND'
self.rules[rule_num]['guards'] = found_files
self.rules[rule_num]['integration'] = found_integration
self.rules[rule_num]['dominance'] = 'PREVENTIVE' if found_integration == 'IN_PATH' else 'DETECTIVE'
else:
self.rules[rule_num]['coverage'] = 'MISSING'

return self.rules

def report(self):
"""Generate audit report."""
print("\nGuard Dominance Audit Report")
print("=" * 80)
print(f"Rules file: {self.rules_file}")
print(f"Codebase: {self.codebase}")

total = len(self.rules)
covered = sum(1 for r in self.rules.values() if r['coverage'] == 'FOUND')
preventive = sum(1 for r in self.rules.values() if r['dominance'] == 'PREVENTIVE')

print(f"\nSUMMARY:")
print(f" Total rules: {total}")
print(f" Rules with guards: {covered} ({100*covered/total if total > 0 else 0:.1f}%)")
print(f" Preventive guards (in-path): {preventive} ({100*preventive/total if total > 0 else 0:.1f}%)")

missing = [r for num, r in self.rules.items() if r['coverage'] == 'MISSING']
detective = [r for r in self.rules.values() if r['dominance'] == 'DETECTIVE']

if missing:
print(f"\nRules with NO guards ({len(missing)}):")
for rule in missing[:5]:
print(f" - {rule['text']}")

if detective:
print(f"\nGuards that are DETECTIVE-only, not in path ({len(detective)}):")
for rule in detective[:5]:
print(f" - {rule['text']}")

def main():
import argparse
parser = argparse.ArgumentParser(description='Guard Dominance Audit')
parser.add_argument('--rules-file', required=True, help='Rules document (e.g., CLAUDE.md)')
parser.add_argument('--codebase', required=True, help='Codebase root path')
parser.add_argument('--verbose', action='store_true', help='Verbose output')

args = parser.parse_args()

audit = GuardAudit(args.rules_file, args.codebase, args.verbose)
if not audit.extract_rules():
sys.exit(1)

audit.scan_codebase_for_guards()
audit.audit_rules_to_guards()
audit.report()

sys.exit(0)

if __name__ == '__main__':
main()

Guard Dominance Memory: chokepoint tells you which guards are dominant today. This one remembers what every previous run found, so it can tell you which guards have quietly slipped from preventive to detective — or off the path altogether — since the last time you looked. A guard that passes this week and is a monument by next quarter is the failure this issue is about, and it is invisible to any audit that has no memory. Available now to Pro subscribers.

Founder offer

A team that has been building autonomous systems discovers their own rules are monuments and has a choice: disclose or hide. This issue takes disclosure. Here are guard failures from the studio's own system. Here is what appears present but is actually absent. Here is how the same class of failure repeats if the guard is never wired into the path where decisions happen.

If you manage a rule-heavy system, compliance, security, governance, you likely feel that rules are documented but not enforced, gates proposed but not integrated. This tool lets you measure it: run chokepoint against your rules and codebase, get a sorted list of which rules lack guards and which guards exist but sit on no path.

No pitch beyond that. A guard that refuses is the argument.

Pro is $15 a month or $250 a year: The Brief, the flagship tool below, the paid Feed payload, the archive. Founder is $300 a year, a 100-seat cap, and a founders-only MCP server that goes live once all 100 seats sell.