Catalog
affaan-m/delivery-gate

affaan-m

delivery-gate

Stop hook that blocks Claude from finishing until quality checks pass. Detects rationalization patterns (surface text heuristics), stale learning logs (filesystem mtime), and low disk space. Complements self-audit by mechanically enforcing learning capture habits.

global
origin:ECC
New~1.2k
v1.0Saved Jun 30, 2026

Delivery Gate — Mechanical Quality Gate for Claude Code

A Stop hook that checks three things before Claude can finish a session, using only deterministic checks — file modification timestamps, disk usage, and regex patterns on the transcript text. No AI inference.

This is distinct from reasoning gates (like self-audit): delivery-gate checks machine-verifiable facts; self-audit checks output quality across four reasoning dimensions. Together they form defense in depth:

  • delivery-gate: "Was the learning library touched today? Is disk space safe?"
  • self-audit: "Is the file content correct, complete, and honest?"

This is the same pattern as CI pipeline gates — automated, deterministic checks that verify machine-readable facts rather than trusting self-reported status.

What It Checks

Check Mechanism On Hit
Rationalization patterns Regex on transcript tail Warning only (never blocks)
Stale learning libraries mtime on 5 configurable paths Warning if some stale; Block if >=3 stale OR growth-log stale + complex task
Disk space < 50GB shutil.disk_usage Warning
Disk space < 15GB shutil.disk_usage Block (exit 2)

Rationalization detection warns about patterns like "skip tests for now" and "pre-existing bug" — surface signals that thinking may have been cut short. It never blocks on its own, because regex heuristics can false-positive. The blocking conditions are: disk critical, >=3 learning libs stale, OR growth-log specifically stale (all require complex task >=3 edits).

Why

Claude Code's built-in checks cover code quality (build → type → lint → test). But there's a different failure mode: the agent produces working code while the session hygiene was neglected — learning not captured, rationalized shortcuts, disk running out silently.

Over many sessions of "ship and forget," the human hasn't grown. This hook enforces the habit: complex task → must touch learning libraries.

Install

cp quality-gate.py ~/.claude/scripts/

Add to ~/.claude/settings.json:

{
  "hooks": {
    "Stop": [{
      "hooks": [{
        "type": "command",
        "command": "python3 ~/.claude/scripts/quality-gate.py",
        "timeout": 5000
      }]
    }]
  }
}

Learning Libraries

Create these files in your project's memory directory. The hook checks if at least one was updated today:

memory/
├── growth-log/          # Daily learning entries (directory)
├── decisions/log.md     # Decision log
├── output-index.md      # Index of session outputs
├── ratings-tracker.md   # Skill ratings over time
└── tooling_capabilities.md  # Known tools inventory

Customize the LIBS dict to match your own file structure.

Configuration

Edit quality-gate.py:

Variable Default Purpose
RATIONALIZE 4 patterns Regex patterns for rationalization detection
LIBS 5 libraries Files/dirs to check for today's updates
COMPLEX_THRESHOLD 3 Edit/Write calls to classify as complex
DISK_WARN_GB 50 Warn below this
DISK_CRIT_GB 15 Block below this

Examples

Simple session — allowed:

edit_count=1 (< 3, not complex) → exit 0

Complex task, learning captured — allowed:

edit_count=5 (complex) → checks LIBS → growth-log updated today → exit 0

Complex task, no learning — BLOCKED:

edit_count=4 (complex) → checks LIBS → all 5 stale → exit 2
stderr: "Blocked: complex task completed but no learning captured today."

Low disk space — BLOCKED:

disk_free=12GB < 15GB critical → exit 2
stderr: "Blocked: disk space at 12GB (threshold: 15GB)."

Limitations

The hook enforces the habit of touching learning libraries, not the quality of what was recorded. If output-index.md is updated but growth-log is skipped, the hook passes (1 of 5 libraries touched). This is by design: mechanical gates check machine-verifiable facts. For content quality verification, pair with self-audit.

Compatibility

  • Python 3.8+ (uses from __future__ import annotations)
  • Cross-platform: Windows, macOS, Linux
  • Zero dependencies beyond stdlib

Quality

This code went through 4 rounds of automated code review (CodeRabbit + Greptile) with 9 real bugs found and fixed.

See Also

  • self-audit — Reasoning quality gate (completeness/consistency/groundedness/honesty)
  • verification-loop — Code quality checks (build/type/lint/test)
  • gateguard — PreToolUse safety gate
Files2
2 files · 8.7 KB

Select a file to preview

Overall Score

87/100

Grade

A

Excellent

Safety

92

Quality

88

Clarity

85

Completeness

82

Summary

A deterministic stop hook that enforces session hygiene before Claude can finish. It checks for rationalization patterns in the transcript, verifies learning libraries were updated during complex tasks, and validates disk space—using only filesystem mtimes, regex patterns, and OS-level disk metrics. No AI inference, no network access, no file writes.

Detected Capabilities

filesystem read (mtime checks)transcript analysis (regex pattern matching)os-level disk usage queryprocess exit codes for stop hook protocoljson parsing of hook inputs

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

enforce learning captureblock incomplete sessionsstop hook quality gatesession hygiene enforcementcomplex task learning logdisk space monitorrationalization detection

Use Cases

  • /delivery-gate enforces the habit of capturing learning from complex tasks by mechanically blocking session exit when code changes are made without updating a growth log
  • Prevents silent failure modes where working code ships but the human hasn't learned anything or kept hygiene records
  • Serves as a complement to self-audit (reasoning quality) by checking machine-verifiable facts (filesystem timestamps, disk space, transcript patterns)
  • Detects early warning signs like rationalization patterns ("skip tests for now", "pre-existing bug") without blocking, to pair with human review
  • Ensures disk space remains safe during long agent sessions by blocking under critical thresholds (15GB) and warning before it becomes critical (30GB)

Quality Notes

  • Excellent scope documentation: clearly distinguishes delivery-gate (machine facts) from self-audit (reasoning quality), preventing scope creep
  • Strong error handling: per-file OSError handling allows partial memory directory scans; missing memory dir warns but does not block (avoiding new-user deadlock)
  • Well-motivated design: the problem statement (session hygiene neglect over time) is concrete and relatable; the three-level disk check (remind/warn/block) mirrors production monitoring patterns
  • Configuration flexibility: all thresholds and patterns are editable constants at file top, making customization straightforward
  • Clear blocking conditions: complex task (>=3 edits) blocks only if >=3 libs stale OR growth-log specifically stale—avoids false positives from passing on one updated file
  • Determinism is a feature, not a limitation: explicitly rejects AI inference for this gate because regex heuristics can false-positive (rationalization detection warns only, never blocks)
  • Examples in README trace all code paths (simple, complex+captured, complex+blocked, low disk) with actual exit codes and error messages
  • Cross-platform compatibility: uses os.path.join, shutil.disk_usage (not df/du), supports Windows/macOS/Linux
  • Code went through 4 rounds of automated review with 9 bugs fixed—demonstrates iterative quality commitment
  • Logging is structured (using Python logging module) and sent to stderr per Stop hook protocol (stderr = hook response message, not stdout)
Model: claude-haiku-4-5-20251001Analyzed: Jun 30, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Add affaan-m/delivery-gate to your library

Command Palette

Search for a command to run...

affaan-m/delivery-gate | SkillRepo