claude-code-kit 0.52.0__tar.gz → 0.53.0__tar.gz

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "claude-kit",
       "source": "./",
       "description": "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC config (no app code, no Docker): install CLAUDE.md + .claude/ (rules, the profile's agents/skills, hooks, artifact templates) + optional .mcp.json, then run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop.",
-      "version": "0.52.0",
+      "version": "0.53.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "description": "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC config (no app code, no Docker). `claude-kit init` asks ordered questions and installs CLAUDE.md + .claude/ (rules, the profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates with working memory and a self-improving learnings loop.",
   "author": {
     "name": "Arjunsingh Yadav",

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/CHANGELOG.md

@@ -4,6 +4,76 @@ All notable changes to claude-kit are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and the project uses
 [semantic versioning](https://semver.org/).
 
+## [0.53.0] — 2026-06-28
+
+**Adopt the verified wins from an exhaustive review of three GitHub orgs — `Netflix`, `aws`, and
+`apple`** (all **1,214** public repos: Netflix 234 · aws 549 · apple 431). Every repo was surveyed (34
+agents over every page across the three orgs — no repo skipped), candidates deep-read for license +
+transferable practice, and the shortlist **adversarially verified** against the live source. These orgs
+are overwhelmingly SDKs, CLIs, cloud-product code, and running services with nothing transferable to a
+config scaffolder — but the review surfaced a real **gap**: the kit had `agent-resilience` (the coding
+agent's own retries) yet **no service-level resilience rule at all**. **7 adoptions across the three
+orgs; 1 new rule (`resilience-engineering`), the rest extensions to existing files — 0 new
+agents/skills** (skill counts unchanged at 104/56/48; MCP fragments unchanged at 17; **core rules
+23 → 24**). Everything re-derived **in prose, never vendored**; all sources Apache-2.0 or MIT/Apache-2.0.
+
+A note on method: the per-repo deep-dive initially skipped several famous repos on "the source is a
+library/tool, not documentation" grounds — but the kit ships *prose*, so a Java library or a C++ database
+is a perfectly valid *source* for a re-derived discipline. The adversarial-verify pass (one skeptic per
+item, reading the live README + license) judged the **discipline**, not the artifact type, and confirmed
+all seven hold, are stack-agnostic, genuinely new, and permissively licensed.
+
+Rules:
+
+- **`resilience-engineering.md`** (NEW — the kit's first service-level resilience rule, explicitly
+  distinct from `agent-resilience.md`, which is about the coding agent's own machinery). Three sections:
+  (1) **stability patterns** at every remote-call boundary — timeout + deadline budget, retry with
+  budget/jitter, circuit breaker, bulkhead/isolation, backpressure, load shedding, graceful
+  degradation — plus **adaptive concurrency limiting** (TCP-congestion-control + Little's Law to find the
+  limit from latency instead of hand-tuning it, server- and client-side, with priority partitioning;
+  from the Apache-2.0 `Netflix/concurrency-limits`); (2) **distributed-time correctness** — never compare
+  raw wall-clocks across nodes; treat "now" as a `[earliest, latest]` interval and commit-wait for
+  cross-node ordering (from the MIT/Apache-2.0 `aws/clock-bound` + Google TrueTime); (3) **chaos
+  engineering** — steady-state hypothesis, vary real-world events, minimize blast radius with an automated
+  abort, prefer production, run continuously (from the Apache-2.0 `Netflix/chaosmonkey` + Principles of
+  Chaos).
+- **`devops-observability.md`** — a **failure-domain-aware progressive rollout** section: update one
+  failure domain (zone/region/rack/cell/shard) at a time to contain blast radius, accelerate in
+  exponential batches with a readiness gate between them, roll back newest-first to escape a bad revision
+  fastest, and pause-on-alarm automatically (from the Apache-2.0 `aws/zone-aware-controllers-for-k8s`).
+- **`testing.md`** — a **Deterministic Simulation Testing** section for concurrency/distributed-system
+  bugs: funnel all nondeterminism (clock, RNG, scheduling, IO, network) through injectable seams, drive
+  the system from a single seed in single-threaded virtual time so a failing run replays bit-for-bit, and
+  inject faults aggressively in-sim (the "buggify" idea); complements fuzzing + property-based testing
+  (from the Apache-2.0 `apple/foundationdb`).
+
+Skills:
+
+- **`spec-driven-development`** — a third proposal mode beyond full-spec and delta-spec: an **RFC track**
+  for one-way-door changes (public/cross-service APIs). Adds working-backwards artifacts (write the future
+  CHANGELOG/README first), a designated API **bar-raiser** with interface veto, a staged lifecycle
+  (feedback → final-comment → API sign-off → implementation planning), and separation of API approval from
+  implementation approval (from the Apache-2.0 `aws/aws-cdk-rfcs`).
+- **`security-and-hardening`** — a **Continuous Least-Privilege** section: least privilege is a decay
+  loop, not a one-time grant — periodically audit which grants/scopes/roles were *actually exercised* over
+  a trailing window, auto-revoke the unused, snapshot policies for fast rollback, and keep an exempt-list
+  for break-glass access (from the Apache-2.0 `Netflix/repokid`).
+
+Docs/counts: core rules **23 → 24** across `README.md` (5 anchors), `CLAUDE.md`, and
+`docs/architecture.md`; `agent-resilience.md` cross-links the new service-level rule (and vice versa); a
+new Influences row + depth blurb (kept to the latest three reviews — the microsoft 0.50 blurb rolls off).
+
+What we **did not** add (already covered, or fails the bar): `Netflix/chaosmonkey`-the-tool,
+`Netflix/dispatch` (archived incident-management *app* — covered by `incident-postmortem` +
+`incident-responder`), `Netflix/maestro` (a workflow-orchestration *platform*, like Airflow/Temporal —
+a tool to use, not a practice), `Netflix/security-bulletins` (disclosure output, covered by the security
+layer); the AWS service/SDK material — `aws-sam-cli`, `aws-pdk`, `aws-lakeformation-best-practices`,
+`aws-networking-best-practices`, `aws-sam-cli-pipeline-init-templates`, `device-storelibrary-cpp`,
+`mcp-proxy-for-aws` (AWS-IAM auth transport, not a tool-exposing MCP server); and `apple`'s
+`apple-root-program` (PKI/CA policy, no license), `batch-processing-gateway` (a Spark-on-K8s service), and
+`pkl-evolution` (a language-evolution RFC — redundant with the richer `aws-cdk-rfcs` RFC track adopted
+above).
+
 ## [0.52.0] — 2026-06-28
 
 **Adopt the verified wins from an exhaustive review of the entire `facebook` (Meta) GitHub org** (all

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/CLAUDE.md

@@ -22,7 +22,7 @@ distributed two ways from one source of truth:
 | `skills/` | Agent skills (auto-discovered by the plugin); `skills/sdlc/` is the `/sdlc` entrypoint |
 | `commands/` | Slash commands: `/claude-kit:init`, `:sdlc`, `:status` (init prefers the pip CLI, falls back to `init.sh`; sdlc delegates to the `sdlc` skill) |
 | `hooks/hooks.json` + `hooks/scripts/` | Event hooks (paths via `${CLAUDE_PLUGIN_ROOT}`) |
-| `rules/` | The 23-file stack-agnostic engineering rule set (scaffolded into `.claude/rules/`), including the agent-operation rules (reasoning, guardrails, resilience, goal-setting, human-in-the-loop, model-tiers, evals, tool-design — see `docs/agentic-patterns.md`) and the org-core rules `autonomy-levels` + `risk-classification` (see `docs/org-capabilities.md`) |
+| `rules/` | The 24-file stack-agnostic engineering rule set (scaffolded into `.claude/rules/`), including the agent-operation rules (reasoning, guardrails, resilience, goal-setting, human-in-the-loop, model-tiers, evals, tool-design — see `docs/agentic-patterns.md`), the service-level `resilience-engineering` rule, and the org-core rules `autonomy-levels` + `risk-classification` (see `docs/org-capabilities.md`) |
 | `catalog/` | **Data-driven registry** — `stacks.yaml` · `profiles.yaml` · `mcp.yaml` · `org.yaml`. The only thing that decides what `resolve()` installs. Adding a stack/profile/server/pack is a data change here. |
 | `templates/` | `CLAUDE.md`, `CLAUDE.stack.md.tmpl`, `README.claude-sdlc.md.tmpl`, `CONTINUITY.template.md`, `settings.json`, `artifacts/`, `agent-memory/` seed |
 | `templates/stacks/<kind>/<id>/` | Per-stack **overlay** content: `rules/` (+ `agents/` for DB stacks). **No application code, no Docker** — the only place stack-specific content lives. |
@@ -49,7 +49,7 @@ root are read directly by the plugin **and** bundled into the wheel (mapped to
    and is wired up via `catalog/stacks.yaml` — never leak it into the agnostic core, and never add
    application code or Docker anywhere.
 2. **Reference rules by their canonical filename** under `.claude/rules/…` (that's where they
-   land in a user project). The current core rule set is the 23 files in `rules/` (org policy/vibe
+   land in a user project). The current core rule set is the 24 files in `rules/` (org policy/vibe
    rules under `templates/org/rules/` install only in organization scope).
 3. **Plugin components live at the repo root**, never inside `.claude-plugin/` (only the
    manifest goes there).

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.52.0
+Version: 0.53.0
 Summary: Cookiecutter-style scaffolder for an autonomous Claude Code SDLC configuration (no app code, no Docker). Asks ordered questions and installs CLAUDE.md + .claude/ (rules, the chosen profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop.
 Project-URL: Homepage, https://github.com/ajyadav013/claude-kit
 Project-URL: Repository, https://github.com/ajyadav013/claude-kit
@@ -84,7 +84,7 @@ Quick start) for the full breakdown of any row.
 | 🔁 **Pipeline & quality gates** | Gate-enforced progression (zero open Critical/High/Medium to advance), per-profile gate sets, a fast-track for small changes, and an anti-sycophancy `devils-advocate` pass |
 | 🤖 **Agent roster** | **28** tiered agents + per-database overlays + **6** org personas, led by an Orchestrator that never writes code |
 | 🔍 **Self-verification & review** | RARV green-Verify (real commands, not imagined), blind parallel review, and read-only risk classification |
-| 📐 **Rules & skills** | **23** stack-agnostic core rules (incl. 8 agent-operation rules) + **104** context-activated skills (56 core + 48 stack-collection) |
+| 📐 **Rules & skills** | **24** stack-agnostic core rules (incl. 8 agent-operation rules) + **104** context-activated skills (56 core + 48 stack-collection) |
 | 🧱 **Stacks & overlays** | Stack-agnostic core + **10** overlay rule sets (React · FastAPI · Go · Postgres · Mongo) wired to your exact commands, incl. a full React design system |
 | 🎚️ **Profiles, scopes & org** | **3** rigor profiles · **3** scopes · **5** autonomy levels · **7** org packs + **10** policy rules |
 | 🧠 **Memory & learning** | Working memory across context compaction + a cost-aware learnings loop (`capture_mode`) so the same mistake isn't repeated |
@@ -278,7 +278,7 @@ need.
 
 <br>
 
-- **23 stack-agnostic core rules** in [`rules/`](rules/) — `mandatory-workflow`, `quality-gates`,
+- **24 stack-agnostic core rules** in [`rules/`](rules/) — `mandatory-workflow`, `quality-gates`,
   `rarv-cycle`, `continuity`, plus eight agent-operation rules and `autonomy-levels` +
   `risk-classification` (see [`docs/agentic-patterns.md`](docs/agentic-patterns.md)).
 - **104 on-demand skills** in [`skills/`](skills/) (56 core + 48 stack-collection) — spec-driven dev, planning, TDD, debugging, code
@@ -437,7 +437,7 @@ owned gates, and the rule that **no gate passes on an unproven verdict**.
 | **[wshobson/agents](https://github.com/wshobson/agents)** & similar agent collections | Large libraries of individual subagent prompts you pick from | A **smaller, opinionated set wired into a sequenced pipeline with owned quality gates** — agents aren't a menu, they're stages that hand off and block on each other. Adopt-by-reuse, not by accumulation. |
 | **[GitHub spec-kit](https://github.com/github/spec-kit)** | A spec-driven workflow (constitution → spec → tasks → analyze) | The same coverage-gate idea (the `story-planner` 1f gate + `task-tracker-sync`) **absorbed into a broader** lifecycle that also covers review, security, build, test, release, and observability gates. Complementary, wider scope. |
 | **claude-flow / multi-agent runtimes** | Runtime orchestrators that *execute* swarms of agents | **Portable configuration**, not a running process — the orchestration is described in rules the host (Claude Code) executes. No daemon, no lock-in, no app code. |
-| **dotfiles / `CLAUDE.md` starters** | A single rules file or settings snippet | A **catalog-driven generator**: resolves your stack/profile/scope into the right subset of 23 rules, 28 agents, 104 skills, gates, and hooks, kept **upgradeable** (`claude-kit upgrade` preserves your edits via owner + checksum). |
+| **dotfiles / `CLAUDE.md` starters** | A single rules file or settings snippet | A **catalog-driven generator**: resolves your stack/profile/scope into the right subset of 24 rules, 28 agents, 104 skills, gates, and hooks, kept **upgradeable** (`claude-kit upgrade` preserves your edits via owner + checksum). |
 
 **Choose claude-kit when** you want a consistent, reviewable, **gate-enforced** autonomous-SDLC setup
 that's the same across every repo and stack, installs in seconds, ships nothing you have to run, and
@@ -520,6 +520,7 @@ non-duplicative gaps**, minimally and catalog-wired.
 | **[microsoft](https://github.com/microsoft) org review** (all 8,147 repos) | OWASP Agentic Top-10 (ASI01–ASI10) agent threats; agent-aware evals (multi-judge panels, multi-turn degradation, tool-vs-response grading); validator-in-the-loop + Medprompt prompting; sandbox policy schema & layered prompt-injection defense; approval-gate implementation; security-lint layer & SBOM; operationalized GenAI red-teaming; priority-based prompt pruning; quantified-lines PR sizing; first-party MCP servers | Extensions across `agent-guardrails` (ASI01–ASI10 + sandbox policy + injection layers), `evals` (§3 panels, §8 multi-turn), `reasoning-techniques`, `human-in-the-loop`, `linting-and-formatting`, `threat-model`, `security-and-hardening` (SBOM), `context-engineering`, `code-review-and-quality` + 4 MCP fragments (Azure · Azure DevOps · MS Learn · Wassette) — **0 new agents/skills/rules** (from agent-governance-toolkit · mxc · llmail-inject-challenge · lost_in_conversation · llm-as-judge · EvalsforAgentsInterop · promptbase · dsl-copilot · agents-humanoversight · PyRIT · eslint-plugin-sdl · sbom-tool · vscode-prompt-tsx · PullRequestQuantifier) | `0.50.0` |
 | **[google](https://github.com/google) org review** (all 2,881 repos) | Reproducible-build verification & source-level missing-patch detection; secure-by-construction injection defense; archive-extraction & ReDoS hardening; multi-party authorization / breakglass; coverage-guided & continuous fuzzing; parameterized + semantic-equality + parallel/flaky testing; compile-time logic-bug & license-header lint layers + deterministic block sorting; multi-window burn-rate alerting & log rate-limiting; long-document extraction; prompt-as-code; statistical browser benchmarking; durable atomic writes; record-replay API testing; first-party SecOps MCP servers | Prose extensions across `security-and-hardening` (reproducible-build · missing-patch · secure-by-construction · archive · ReDoS), `human-in-the-loop` (MPA/breakglass), `testing` (fuzzing · parameterized · semantic-equality · parallel/flaky), `linting-and-formatting` (logic-bug + license-header layers · block sorting), `devops-observability` (burn-rate · log rate-limit), `context-engineering` (long-doc extraction), `reasoning-techniques` (prompt-as-code), `performance-optimization` (statistical benchmarking), `tool-design` (durable atomic writes), `api-integration` (record-replay) + **4 first-party SecOps MCP fragments** (Chronicle SIEM · GTI · SCC · SOAR) — **0 new agents/skills/rules** (from oss-rebuild · vanir · safe-active-record/mug · safearchive · re2 · building-secure-and-reliable-systems · patrick · go-cmp · atheris/honggfuzz/clusterfuzzlite · gtest-parallel · error-prone · addlicense · keep-sorted · prometheus-slo-burn · flogger · langextract · dotprompt · tachometer · renameio · test-server · mcp-security) | `0.51.0` |
 | **[facebook](https://github.com/facebook) (Meta) org review** (all 168 repos) | Interprocedural taint / data-flow security analysis (source→sink across functions); continuous A/B performance-regression CI gate; defense-in-depth agent-sandbox enforcement (argument validation + OS-level backstop) | Prose extensions to `linting-and-formatting` (taint/data-flow layer), `devops-observability` (perf-regression gate), `agent-guardrails` (§4 layered sandbox enforcement) — **0 new agents/skills/rules** (from pyre-check/Pysa · mariana-trench · FAI-PEP · mcpguard-dynamic; the org is mostly libraries/frameworks, so the verify pass *dropped* the rest — `DNE-TaaC`, `mbt`, plus already-covered `infer`/`mariana-trench`-as-tool, `fbt`, `memlab`, …) | `0.52.0` |
+| **[Netflix](https://github.com/Netflix) · [aws](https://github.com/aws) · [apple](https://github.com/apple) org review** (all **1,214** repos) | Service-level resilience the kit lacked entirely — stability patterns (timeout/retry-budget/circuit-breaker/bulkhead) + adaptive concurrency limiting, chaos engineering, and bounded-clock distributed time; failure-domain-aware progressive rollout; deterministic simulation testing; a formal RFC process (working-backwards + API bar-raiser); continuous usage-based least-privilege | The **new `resilience-engineering` rule** (chaos + stability patterns + bounded clocks, from `Netflix/concurrency-limits` · `Netflix/chaosmonkey` · `aws/clock-bound`); plus prose extensions to `devops-observability` (failure-domain rollout, from `aws/zone-aware-controllers-for-k8s`), `testing` (deterministic simulation testing, from `apple/foundationdb`), `spec-driven-development` (RFC track, from `aws/aws-cdk-rfcs`), and `security-and-hardening` (continuous least-privilege, from `Netflix/repokid`) — **1 new rule, 0 new agents/skills** (the orgs are overwhelmingly SDKs/CLIs/services, so the survey kept only 7 of 1,214) | `0.53.0` |
 
 > Each adoption is detailed in the [CHANGELOG](CHANGELOG.md) — including, for every review, what we
 > deliberately **did not** add because the kit already covered it.
@@ -529,21 +530,6 @@ non-duplicative gaps**, minimally and catalog-wired.
 
 <br>
 
-**🟦 microsoft org review → agentic-AI hardening (0.50.0).** We reviewed **all 8,147 repos** in the
-Microsoft org (165 survey agents over every page → deep-dive the top candidates → adversarially verify
-the shortlist). The vast majority — SDKs, samples, Azure-product code, ML infra, OS/editor — carried
-nothing transferable, and the verify pass *dropped* two plausible picks (`ToolTalk`, whose
-ground-truth-sequence grading contradicts `evals`' "grade outcomes, not paths"; and `prompty`, an
-LLM-app product, not an SDLC practice). Eighteen survived — all **prose extensions to existing files**,
-zero new agents/skills/rules: the OWASP **Agentic Top-10 (ASI01–ASI10)** mapping, a sandbox **policy
-schema**, and layered prompt-injection defense in `agent-guardrails`; agent-aware evals (multi-judge
-panels in §3, multi-turn degradation in §8) in `evals`; validator-in-the-loop + Medprompt in
-`reasoning-techniques`; approval-gate implementation in `human-in-the-loop`; a security-lint layer in
-`linting-and-formatting`; operationalized GenAI red-teaming in `threat-model`; SBOM generation in
-`security-and-hardening`; priority-based prompt pruning in `context-engineering`; quantified-lines PR
-sizing in `code-review-and-quality`; and **4 first-party MCP fragments** (Azure · Azure DevOps · MS
-Learn · Wassette).
-
 **🔴 google org review → 21 hardening & testing patterns (0.51.0).** We reviewed **all 2,881 repos** in
 the Google org (60 survey agents over every page → deep-dive the top ~300 candidates → adversarially
 verify the shortlist). The vast majority — Android/Kotlin, C++ libraries, ML frameworks, language
@@ -580,6 +566,27 @@ to cancel environment noise, gate on the relative delta) in `devops-observabilit
 **defense-in-depth agent-sandbox enforcement** (argument-validation layer + OS-level eBPF/seccomp backstop
 *below* the existing declarative policy) in `agent-guardrails` §4 (from `mcpguard-dynamic`).
 
+**⬛🟧 Netflix · aws · apple org review → resilience engineering & more (0.53.0).** We reviewed **all
+1,214 repos** across the three orgs (34 survey agents over every page → deep-dive the candidates →
+adversarially verify the shortlist). The orgs are overwhelmingly SDKs, CLIs, cloud-product code, and
+running services — almost nothing transferable to a config scaffolder — and the verify pass scrutinized
+each survivor against the live README + license. **Seven** genuine, stack-agnostic, permissively-licensed
+disciplines survived. The biggest finding was a real **gap**: the kit had `agent-resilience` (the coding
+agent's own retries) but **no service-level resilience rule at all**, so this review adds the kit's
+**first new rule in many releases — `resilience-engineering`**: stability patterns
+(timeout/retry-budget/circuit-breaker/bulkhead/load-shedding/fallback) + **adaptive concurrency limiting**
+(TCP-congestion-control + Little's Law, from `Netflix/concurrency-limits`), **chaos engineering**
+(steady-state hypothesis, blast-radius control, automated abort, from `Netflix/chaosmonkey`), and
+**bounded-clock distributed time** (timestamps as `[earliest, latest]` + commit-wait, from
+`aws/clock-bound`). The other four are prose extensions to existing files: **failure-domain-aware
+progressive rollout** (one zone/region/cell at a time, exponential batches, reverse-order rollback) in
+`devops-observability` (from `aws/zone-aware-controllers-for-k8s`); **deterministic simulation testing**
+(single-seed control of all nondeterminism + in-sim fault injection) in `testing` (from
+`apple/foundationdb`); a formal **RFC track** for one-way-door API changes (working-backwards artifacts +
+API bar-raiser + staged sign-off) in `spec-driven-development` (from `aws/aws-cdk-rfcs`); and
+**continuous, usage-based least-privilege** (audit exercised grants → auto-revoke the unused → versioned
+rollback) in `security-and-hardening` (from `Netflix/repokid`).
+
 </details>
 
 > **Comparing claude-kit to native subagents / Agent Teams, agent collections, spec-kit, or
@@ -633,7 +640,7 @@ to cancel environment noise, gate on the relative delta) in `devops-observabilit
 
 ## Rules & skills
 
-**Rules** ([`rules/`](rules/)) are the 23 stack-agnostic contracts every agent obeys — the
+**Rules** ([`rules/`](rules/)) are the 24 stack-agnostic contracts every agent obeys — the
 `mandatory-workflow` pipeline, `quality-gates`, `rarv-cycle`, `continuity`, `documentation`,
 `testing`, the eight agent-operation rules (`reasoning-techniques`, `agent-guardrails`,
 `agent-resilience`, `goal-setting-and-monitoring`, `human-in-the-loop`, `model-tiers`, `evals`,
@@ -784,7 +791,7 @@ build attestations** for supply-chain provenance. Report vulnerabilities private
 ```
 claude-kit/
 ├── .claude-plugin/        plugin.json + marketplace.json
-├── agents/                28 SDLC agents          rules/        23 engineering rules
+├── agents/                28 SDLC agents          rules/        24 engineering rules
 ├── skills/                on-demand skills        templates/    CLAUDE.md, settings, artifacts, memory seeds
 ├── commands/              /claude-kit:* commands  hooks/        hooks.json + scripts/
 ├── catalog/         stacks·profiles·mcp·org       templates/stacks/  per-stack overlay rules + agents

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/README.md

@@ -54,7 +54,7 @@ Quick start) for the full breakdown of any row.
 | 🔁 **Pipeline & quality gates** | Gate-enforced progression (zero open Critical/High/Medium to advance), per-profile gate sets, a fast-track for small changes, and an anti-sycophancy `devils-advocate` pass |
 | 🤖 **Agent roster** | **28** tiered agents + per-database overlays + **6** org personas, led by an Orchestrator that never writes code |
 | 🔍 **Self-verification & review** | RARV green-Verify (real commands, not imagined), blind parallel review, and read-only risk classification |
-| 📐 **Rules & skills** | **23** stack-agnostic core rules (incl. 8 agent-operation rules) + **104** context-activated skills (56 core + 48 stack-collection) |
+| 📐 **Rules & skills** | **24** stack-agnostic core rules (incl. 8 agent-operation rules) + **104** context-activated skills (56 core + 48 stack-collection) |
 | 🧱 **Stacks & overlays** | Stack-agnostic core + **10** overlay rule sets (React · FastAPI · Go · Postgres · Mongo) wired to your exact commands, incl. a full React design system |
 | 🎚️ **Profiles, scopes & org** | **3** rigor profiles · **3** scopes · **5** autonomy levels · **7** org packs + **10** policy rules |
 | 🧠 **Memory & learning** | Working memory across context compaction + a cost-aware learnings loop (`capture_mode`) so the same mistake isn't repeated |
@@ -248,7 +248,7 @@ need.
 
 <br>
 
-- **23 stack-agnostic core rules** in [`rules/`](rules/) — `mandatory-workflow`, `quality-gates`,
+- **24 stack-agnostic core rules** in [`rules/`](rules/) — `mandatory-workflow`, `quality-gates`,
   `rarv-cycle`, `continuity`, plus eight agent-operation rules and `autonomy-levels` +
   `risk-classification` (see [`docs/agentic-patterns.md`](docs/agentic-patterns.md)).
 - **104 on-demand skills** in [`skills/`](skills/) (56 core + 48 stack-collection) — spec-driven dev, planning, TDD, debugging, code
@@ -407,7 +407,7 @@ owned gates, and the rule that **no gate passes on an unproven verdict**.
 | **[wshobson/agents](https://github.com/wshobson/agents)** & similar agent collections | Large libraries of individual subagent prompts you pick from | A **smaller, opinionated set wired into a sequenced pipeline with owned quality gates** — agents aren't a menu, they're stages that hand off and block on each other. Adopt-by-reuse, not by accumulation. |
 | **[GitHub spec-kit](https://github.com/github/spec-kit)** | A spec-driven workflow (constitution → spec → tasks → analyze) | The same coverage-gate idea (the `story-planner` 1f gate + `task-tracker-sync`) **absorbed into a broader** lifecycle that also covers review, security, build, test, release, and observability gates. Complementary, wider scope. |
 | **claude-flow / multi-agent runtimes** | Runtime orchestrators that *execute* swarms of agents | **Portable configuration**, not a running process — the orchestration is described in rules the host (Claude Code) executes. No daemon, no lock-in, no app code. |
-| **dotfiles / `CLAUDE.md` starters** | A single rules file or settings snippet | A **catalog-driven generator**: resolves your stack/profile/scope into the right subset of 23 rules, 28 agents, 104 skills, gates, and hooks, kept **upgradeable** (`claude-kit upgrade` preserves your edits via owner + checksum). |
+| **dotfiles / `CLAUDE.md` starters** | A single rules file or settings snippet | A **catalog-driven generator**: resolves your stack/profile/scope into the right subset of 24 rules, 28 agents, 104 skills, gates, and hooks, kept **upgradeable** (`claude-kit upgrade` preserves your edits via owner + checksum). |
 
 **Choose claude-kit when** you want a consistent, reviewable, **gate-enforced** autonomous-SDLC setup
 that's the same across every repo and stack, installs in seconds, ships nothing you have to run, and
@@ -490,6 +490,7 @@ non-duplicative gaps**, minimally and catalog-wired.
 | **[microsoft](https://github.com/microsoft) org review** (all 8,147 repos) | OWASP Agentic Top-10 (ASI01–ASI10) agent threats; agent-aware evals (multi-judge panels, multi-turn degradation, tool-vs-response grading); validator-in-the-loop + Medprompt prompting; sandbox policy schema & layered prompt-injection defense; approval-gate implementation; security-lint layer & SBOM; operationalized GenAI red-teaming; priority-based prompt pruning; quantified-lines PR sizing; first-party MCP servers | Extensions across `agent-guardrails` (ASI01–ASI10 + sandbox policy + injection layers), `evals` (§3 panels, §8 multi-turn), `reasoning-techniques`, `human-in-the-loop`, `linting-and-formatting`, `threat-model`, `security-and-hardening` (SBOM), `context-engineering`, `code-review-and-quality` + 4 MCP fragments (Azure · Azure DevOps · MS Learn · Wassette) — **0 new agents/skills/rules** (from agent-governance-toolkit · mxc · llmail-inject-challenge · lost_in_conversation · llm-as-judge · EvalsforAgentsInterop · promptbase · dsl-copilot · agents-humanoversight · PyRIT · eslint-plugin-sdl · sbom-tool · vscode-prompt-tsx · PullRequestQuantifier) | `0.50.0` |
 | **[google](https://github.com/google) org review** (all 2,881 repos) | Reproducible-build verification & source-level missing-patch detection; secure-by-construction injection defense; archive-extraction & ReDoS hardening; multi-party authorization / breakglass; coverage-guided & continuous fuzzing; parameterized + semantic-equality + parallel/flaky testing; compile-time logic-bug & license-header lint layers + deterministic block sorting; multi-window burn-rate alerting & log rate-limiting; long-document extraction; prompt-as-code; statistical browser benchmarking; durable atomic writes; record-replay API testing; first-party SecOps MCP servers | Prose extensions across `security-and-hardening` (reproducible-build · missing-patch · secure-by-construction · archive · ReDoS), `human-in-the-loop` (MPA/breakglass), `testing` (fuzzing · parameterized · semantic-equality · parallel/flaky), `linting-and-formatting` (logic-bug + license-header layers · block sorting), `devops-observability` (burn-rate · log rate-limit), `context-engineering` (long-doc extraction), `reasoning-techniques` (prompt-as-code), `performance-optimization` (statistical benchmarking), `tool-design` (durable atomic writes), `api-integration` (record-replay) + **4 first-party SecOps MCP fragments** (Chronicle SIEM · GTI · SCC · SOAR) — **0 new agents/skills/rules** (from oss-rebuild · vanir · safe-active-record/mug · safearchive · re2 · building-secure-and-reliable-systems · patrick · go-cmp · atheris/honggfuzz/clusterfuzzlite · gtest-parallel · error-prone · addlicense · keep-sorted · prometheus-slo-burn · flogger · langextract · dotprompt · tachometer · renameio · test-server · mcp-security) | `0.51.0` |
 | **[facebook](https://github.com/facebook) (Meta) org review** (all 168 repos) | Interprocedural taint / data-flow security analysis (source→sink across functions); continuous A/B performance-regression CI gate; defense-in-depth agent-sandbox enforcement (argument validation + OS-level backstop) | Prose extensions to `linting-and-formatting` (taint/data-flow layer), `devops-observability` (perf-regression gate), `agent-guardrails` (§4 layered sandbox enforcement) — **0 new agents/skills/rules** (from pyre-check/Pysa · mariana-trench · FAI-PEP · mcpguard-dynamic; the org is mostly libraries/frameworks, so the verify pass *dropped* the rest — `DNE-TaaC`, `mbt`, plus already-covered `infer`/`mariana-trench`-as-tool, `fbt`, `memlab`, …) | `0.52.0` |
+| **[Netflix](https://github.com/Netflix) · [aws](https://github.com/aws) · [apple](https://github.com/apple) org review** (all **1,214** repos) | Service-level resilience the kit lacked entirely — stability patterns (timeout/retry-budget/circuit-breaker/bulkhead) + adaptive concurrency limiting, chaos engineering, and bounded-clock distributed time; failure-domain-aware progressive rollout; deterministic simulation testing; a formal RFC process (working-backwards + API bar-raiser); continuous usage-based least-privilege | The **new `resilience-engineering` rule** (chaos + stability patterns + bounded clocks, from `Netflix/concurrency-limits` · `Netflix/chaosmonkey` · `aws/clock-bound`); plus prose extensions to `devops-observability` (failure-domain rollout, from `aws/zone-aware-controllers-for-k8s`), `testing` (deterministic simulation testing, from `apple/foundationdb`), `spec-driven-development` (RFC track, from `aws/aws-cdk-rfcs`), and `security-and-hardening` (continuous least-privilege, from `Netflix/repokid`) — **1 new rule, 0 new agents/skills** (the orgs are overwhelmingly SDKs/CLIs/services, so the survey kept only 7 of 1,214) | `0.53.0` |
 
 > Each adoption is detailed in the [CHANGELOG](CHANGELOG.md) — including, for every review, what we
 > deliberately **did not** add because the kit already covered it.
@@ -499,21 +500,6 @@ non-duplicative gaps**, minimally and catalog-wired.
 
 <br>
 
-**🟦 microsoft org review → agentic-AI hardening (0.50.0).** We reviewed **all 8,147 repos** in the
-Microsoft org (165 survey agents over every page → deep-dive the top candidates → adversarially verify
-the shortlist). The vast majority — SDKs, samples, Azure-product code, ML infra, OS/editor — carried
-nothing transferable, and the verify pass *dropped* two plausible picks (`ToolTalk`, whose
-ground-truth-sequence grading contradicts `evals`' "grade outcomes, not paths"; and `prompty`, an
-LLM-app product, not an SDLC practice). Eighteen survived — all **prose extensions to existing files**,
-zero new agents/skills/rules: the OWASP **Agentic Top-10 (ASI01–ASI10)** mapping, a sandbox **policy
-schema**, and layered prompt-injection defense in `agent-guardrails`; agent-aware evals (multi-judge
-panels in §3, multi-turn degradation in §8) in `evals`; validator-in-the-loop + Medprompt in
-`reasoning-techniques`; approval-gate implementation in `human-in-the-loop`; a security-lint layer in
-`linting-and-formatting`; operationalized GenAI red-teaming in `threat-model`; SBOM generation in
-`security-and-hardening`; priority-based prompt pruning in `context-engineering`; quantified-lines PR
-sizing in `code-review-and-quality`; and **4 first-party MCP fragments** (Azure · Azure DevOps · MS
-Learn · Wassette).
-
 **🔴 google org review → 21 hardening & testing patterns (0.51.0).** We reviewed **all 2,881 repos** in
 the Google org (60 survey agents over every page → deep-dive the top ~300 candidates → adversarially
 verify the shortlist). The vast majority — Android/Kotlin, C++ libraries, ML frameworks, language
@@ -550,6 +536,27 @@ to cancel environment noise, gate on the relative delta) in `devops-observabilit
 **defense-in-depth agent-sandbox enforcement** (argument-validation layer + OS-level eBPF/seccomp backstop
 *below* the existing declarative policy) in `agent-guardrails` §4 (from `mcpguard-dynamic`).
 
+**⬛🟧 Netflix · aws · apple org review → resilience engineering & more (0.53.0).** We reviewed **all
+1,214 repos** across the three orgs (34 survey agents over every page → deep-dive the candidates →
+adversarially verify the shortlist). The orgs are overwhelmingly SDKs, CLIs, cloud-product code, and
+running services — almost nothing transferable to a config scaffolder — and the verify pass scrutinized
+each survivor against the live README + license. **Seven** genuine, stack-agnostic, permissively-licensed
+disciplines survived. The biggest finding was a real **gap**: the kit had `agent-resilience` (the coding
+agent's own retries) but **no service-level resilience rule at all**, so this review adds the kit's
+**first new rule in many releases — `resilience-engineering`**: stability patterns
+(timeout/retry-budget/circuit-breaker/bulkhead/load-shedding/fallback) + **adaptive concurrency limiting**
+(TCP-congestion-control + Little's Law, from `Netflix/concurrency-limits`), **chaos engineering**
+(steady-state hypothesis, blast-radius control, automated abort, from `Netflix/chaosmonkey`), and
+**bounded-clock distributed time** (timestamps as `[earliest, latest]` + commit-wait, from
+`aws/clock-bound`). The other four are prose extensions to existing files: **failure-domain-aware
+progressive rollout** (one zone/region/cell at a time, exponential batches, reverse-order rollback) in
+`devops-observability` (from `aws/zone-aware-controllers-for-k8s`); **deterministic simulation testing**
+(single-seed control of all nondeterminism + in-sim fault injection) in `testing` (from
+`apple/foundationdb`); a formal **RFC track** for one-way-door API changes (working-backwards artifacts +
+API bar-raiser + staged sign-off) in `spec-driven-development` (from `aws/aws-cdk-rfcs`); and
+**continuous, usage-based least-privilege** (audit exercised grants → auto-revoke the unused → versioned
+rollback) in `security-and-hardening` (from `Netflix/repokid`).
+
 </details>
 
 > **Comparing claude-kit to native subagents / Agent Teams, agent collections, spec-kit, or
@@ -603,7 +610,7 @@ to cancel environment noise, gate on the relative delta) in `devops-observabilit
 
 ## Rules & skills
 
-**Rules** ([`rules/`](rules/)) are the 23 stack-agnostic contracts every agent obeys — the
+**Rules** ([`rules/`](rules/)) are the 24 stack-agnostic contracts every agent obeys — the
 `mandatory-workflow` pipeline, `quality-gates`, `rarv-cycle`, `continuity`, `documentation`,
 `testing`, the eight agent-operation rules (`reasoning-techniques`, `agent-guardrails`,
 `agent-resilience`, `goal-setting-and-monitoring`, `human-in-the-loop`, `model-tiers`, `evals`,
@@ -754,7 +761,7 @@ build attestations** for supply-chain provenance. Report vulnerabilities private
 ```
 claude-kit/
 ├── .claude-plugin/        plugin.json + marketplace.json
-├── agents/                28 SDLC agents          rules/        23 engineering rules
+├── agents/                28 SDLC agents          rules/        24 engineering rules
 ├── skills/                on-demand skills        templates/    CLAUDE.md, settings, artifacts, memory seeds
 ├── commands/              /claude-kit:* commands  hooks/        hooks.json + scripts/
 ├── catalog/         stacks·profiles·mcp·org       templates/stacks/  per-stack overlay rules + agents

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/docs/architecture.md

@@ -17,7 +17,7 @@ flowchart LR
         S["skills/"]
         C["commands/"]
         H["hooks/"]
-        R["rules/ (23)"]
+        R["rules/ (24)"]
         T["templates/ (+ stacks/ & org/ overlays)"]
         K["catalog/ (stacks · profiles · mcp · org)"]
     end
@@ -156,12 +156,12 @@ flowchart TB
         OPOL["org policy/vibe rules<br/>secrets · pii · production-data · branch-and-pr · compliance · …"]
     end
 
-    subgraph RULES["rules/ — 23 contracts the agents obey"]
+    subgraph RULES["rules/ — 24 contracts the agents obey"]
         MW["mandatory-workflow · quality-gates · rarv-cycle"]
         MEM["continuity · agent-memory"]
         AGENTOP["reasoning-techniques · agent-guardrails · agent-resilience<br/>goal-setting-and-monitoring · human-in-the-loop · model-tiers"]
         ORGCORE["autonomy-levels · risk-classification (org-core)"]
-        CRAFT["design-patterns · code-organization · documentation<br/>linting-and-formatting · testing<br/>frontend-best-practices · responsive-and-accessibility · devops-observability"]
+        CRAFT["design-patterns · code-organization · documentation<br/>linting-and-formatting · testing · resilience-engineering<br/>frontend-best-practices · responsive-and-accessibility · devops-observability"]
     end
 
     subgraph SUPPORT["Cross-cutting systems"]
@@ -208,7 +208,7 @@ claude-kit/
 ├── hooks/
 │   ├── hooks.json             # plugin hooks via ${CLAUDE_PLUGIN_ROOT}
 │   └── scripts/               # load-continuity, load-learnings, lint-fix, type-check, warn-* / validate-* / audit-log
-├── rules/                     # 23 stack-agnostic engineering rules (incl. agent-operation + org-core rules)
+├── rules/                     # 24 stack-agnostic engineering rules (incl. agent-operation + org-core rules)
 ├── catalog/                   # stacks.yaml · profiles.yaml · mcp.yaml · org.yaml (the resolver's data)
 ├── templates/
 │   ├── CLAUDE.md · CLAUDE.stack.md.tmpl · README.claude-sdlc.md.tmpl

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.52.0"
+version = "0.53.0"
 description = "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC configuration (no app code, no Docker). Asks ordered questions and installs CLAUDE.md + .claude/ (rules, the chosen profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop."
 readme = "README.md"
 requires-python = ">=3.9"

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/rules/agent-resilience.md

@@ -11,11 +11,14 @@ governed traditional systems for decades.
 > Adapted from *Agentic Design Patterns* (A. Gulli), Ch. 12 "Exception Handling and Recovery" (and the
 > "treat agents as software" thesis of Ch. 18). Concepts paraphrased for this kit.
 
-This is **distinct** from two neighbors:
+This is **distinct** from three neighbors:
 - `.claude/rules/quality-gates.md` owns *gate* retry **budgets** (a review/test failing on its merits
   and looping the lane). This rule is about *operational* failures of the tooling, not failed verdicts.
 - The `debugging-and-error-recovery` skill finds the root cause of a bug in the **product**. This rule
   is about the **agent's own run** surviving a transient or hard failure.
+- `.claude/rules/resilience-engineering.md` applies the same vocabulary (circuit-breaker, fallback,
+  backpressure, graceful degradation) to the **product's services** — how the system you build survives
+  *its* dependencies. This rule is the **agent machinery**; that rule is the **shipped system**.
 
 ## When an operation fails
 

{claude_code_kit-0.52.0 → claude_code_kit-0.53.0}/rules/devops-observability.md

@@ -114,6 +114,36 @@ on every change:
 > control/treatment runs to isolate code from environment; gate on the relative delta) from the
 > Apache-2.0 [`facebook/FAI-PEP`](https://github.com/facebook/FAI-PEP). Re-derived in prose; not vendored.
 
+### Failure-domain-aware progressive rollout (contain the blast radius)
+
+A new revision is the most likely cause of the next outage, so **never deploy it everywhere at once**.
+Roll it out progressively, and make the rollout *respect the system's failure boundaries* so a bad
+revision can only ever take down one of them:
+
+- **One failure domain at a time.** Identify the unit of correlated failure — an availability zone, a
+  region, a rack, a data center, a shard, a cell — and **update only one at a time, never several
+  simultaneously**. If the new revision is poison, at most one domain is affected and the rest keep
+  serving. (This is orthogonal to canary/feature-flags: canary picks *how much* traffic sees the
+  change; this picks *which blast-radius boundary* it's confined to.)
+- **Accelerate as confidence builds.** Within a domain, update in **exponentially growing batches**
+  (e.g. 1 → 2 → 4 …, capped by a max-unavailable bound), with a **readiness/health gate between
+  batches** — proceed only once the just-updated units are healthy. Slow where it's risky (the first
+  units), fast where it's proven.
+- **Roll back in reverse order, newest-first.** On failure, undo the **most-recently-updated units
+  first** — they're the ones running the bad revision, so reversing chronologically escapes it fastest
+  instead of waiting out the units that were never touched.
+- **Pause on the alarm automatically.** Wire the rollout to the SLO signals above (burn-rate alert,
+  canary error-rate/latency breach) so a regression **halts progression** without a human in the loop;
+  a breach is **High** (`.claude/rules/quality-gates.md`) and routes the fix back to the dev lane.
+- **Scope it.** Worth the machinery for a multi-domain / SLO-bearing service; *skip (note why in
+  `CONTINUITY.md`)* for a single-instance or non-critical surface.
+
+> Stack-agnostic adaptation of zone-aware progressive rollout (one failure domain at a time, exponential
+> batches with readiness gates, reverse-order rollback, pause-on-alarm) from the Apache-2.0
+> [`aws/zone-aware-controllers-for-k8s`](https://github.com/aws/zone-aware-controllers-for-k8s).
+> Re-derived in prose; not vendored — the discipline applies to zones/regions/racks/cells/shards on any
+> platform, not just Kubernetes.
+
 ---
 
 ## Notes

claude_code_kit-0.53.0/rules/resilience-engineering.md

@@ -0,0 +1,143 @@
+# Resilience Engineering
+
+**A distributed system is a set of failure modes that occasionally computes something. Design for the
+failure modes, then go prove they're handled.**
+
+How the **service or system you are building** stays correct and available when its dependencies are
+slow, partitioned, overloaded, or down — and how you *verify* that resilience instead of assuming it.
+Three disciplines: design for failure (stability patterns), keep distributed decisions correct under
+clock skew (bounded time), and inject real failure to find the weaknesses first (chaos engineering).
+
+This is **distinct** from `.claude/rules/agent-resilience.md`, which is about the *coding agent's own
+machinery* surviving a tool error or a flaky network. That rule borrows the same vocabulary
+(circuit-breaker, fallback, graceful degradation) for the agent's run; **this** rule applies those
+patterns to the **product's** services. Same physics, different subject.
+
+## When this rule applies (conditional)
+
+Apply it when the change adds or touches a **networked dependency under load** — a service that calls
+another service, a database, a cache, a queue, or a third-party API on a hot path; anything with an
+SLO (`.claude/rules/devops-observability.md`); or any decision that depends on ordering events across
+more than one machine. **Skip (note why in `CONTINUITY.md`)** for a pure local computation, a
+single-process script, or a change with no concurrency-sensitive or cross-node surface.
+
+---
+
+## 1. Stability patterns — design the service to survive its dependencies
+
+A call to a dependency *will* eventually be slow or fail. Without containment, one slow dependency
+exhausts your threads/connections, and the failure propagates back up the call graph until the whole
+system is down — a **cascading failure**. The patterns below stop the spread. Apply them at every
+**remote** call boundary (in-process calls don't need them).
+
+| Pattern | Failure it contains | The discipline |
+|---------|--------------------|----------------|
+| **Timeout** | A dependency that hangs forever | Every remote call has a finite, explicit deadline. "No timeout" is the most common production outage. Propagate a **deadline/budget** down the call chain so the total stays bounded. |
+| **Retry with budget + jitter** | A *transient* blip | Retry only **idempotent** operations, with capped attempts, exponential backoff, and **randomized jitter** (synchronized retries are a self-inflicted DDoS). Cap retries as a **fraction of traffic** (a retry budget), not per-call — so a broad outage can't multiply load. |
+| **Circuit breaker** | A dependency that is *down*, not blipping | After a failure threshold, **open** the circuit and fail fast for a cooldown instead of hammering a dead dependency; **half-open** with a trial request before closing. Turns a 30s timeout pile-up into an instant, cheap rejection. |
+| **Bulkhead / isolation** | One dependency starving all capacity | Give each dependency (or tenant, or workload class) its **own** pool of threads/connections/permits, so saturating one can't sink the rest — like watertight compartments in a ship. |
+| **Backpressure & adaptive concurrency** | More load arriving than you can serve | Bound in-flight work and **shed or queue** the excess rather than accepting everything and collapsing. Prefer an **adaptive** limit over a hand-tuned constant (below). |
+| **Load shedding** | Saturation despite limits | When over budget, reject *early and cheaply* (fast 429/503), and **prioritize** — drop low-value/optional traffic first so critical paths keep working. |
+| **Graceful degradation / fallback** | A non-critical dependency is unavailable | Serve a sensible default, a cached/stale value, or reduced functionality instead of a hard error — and make the degradation **observable** (it is not "fine"). |
+
+### Adaptive concurrency limiting (don't hand-tune a magic number)
+
+A fixed "max N concurrent" limit is wrong the moment latency changes: too low wastes capacity, too high
+lets a queue build until latency explodes. Borrow from **TCP congestion control** and **Little's Law**
+(`concurrency ≈ throughput × latency`): measure round-trip latency continuously and **search for the
+limit where queueing begins**.
+
+- **Detect the inflection, don't guess it.** Track a baseline (best-observed) latency and the current
+  latency; when current latency rises above baseline by a gradient, you are queueing — **shrink** the
+  limit. When latency is near baseline, **grow** it. (This is the delay-based / "Vegas"/"Gradient"
+  family — the same idea TCP uses to find link capacity without being told.)
+- **Place the limit where the queue would form** — at the server (reject to protect the dependency from
+  overload and retry storms) and/or at the client (apply backpressure so callers slow down instead of
+  piling on).
+- **Reserve a floor for critical traffic.** Partition the limit by priority/tenant so a flood of
+  low-priority work can't starve SLA-bearing requests.
+
+> Stack-agnostic adaptation of adaptive concurrency limiting (TCP-congestion-control + Little's Law to
+> find the limit from latency, server- and client-side, with priority partitioning) from the Apache-2.0
+> [`Netflix/concurrency-limits`](https://github.com/Netflix/concurrency-limits). Re-derived in prose;
+> not vendored — the algorithm maps onto any language's concurrency primitive (semaphore, pool, worker
+> count).
+
+**Self-check at every remote call:** does it have a timeout and a deadline budget; is its retry
+idempotent, jittered, and budgeted; is there a breaker so a *down* dependency fails fast; and is its
+resource pool isolated so it can't starve the rest?
+
+---
+
+## 2. Distributed-time correctness — never trust a single clock for ordering
+
+The moment a decision depends on "did A happen before B?" *across machines*, raw wall-clock timestamps
+become a correctness bug. Clocks drift; even with NTP/PTP the synchronization error is bounded but
+**non-zero**. Comparing two nodes' timestamps directly can order events backwards.
+
+- **Treat "now" as an interval, not a point.** A correct clock reports `[earliest, latest]` — the true
+  time is somewhere inside a window whose width is the **clock error bound** (local offset + drift /
+  root dispersion + a share of network delay). A point timestamp silently throws this uncertainty away.
+- **Wait out the uncertainty when ordering matters (commit-wait).** To guarantee event B is seen as
+  *after* event A across nodes, ensure B's `earliest` exceeds A's `latest` — if needed, **wait** for the
+  uncertainty window to pass before committing. This is how globally-consistent ordering is achieved
+  without a single coordinator (the TrueTime / ClockBound pattern).
+- **Prefer logical ordering where you don't need wall-clock meaning.** For pure causality (not "what
+  human time"), **logical/Lamport or vector clocks** order events with no physical-clock dependency at
+  all — reach for them first; use bounded physical time only when real-world timestamps must be
+  comparable across nodes.
+
+> Stack-agnostic adaptation of bounded-uncertainty time (timestamps as `[earliest, latest]` intervals +
+> commit-wait for cross-node ordering) from the MIT/Apache-2.0
+> [`aws/clock-bound`](https://github.com/aws/clock-bound) and Google's TrueTime. Re-derived in prose;
+> not vendored — the discipline applies wherever distributed nodes order events.
+
+---
+
+## 3. Chaos engineering — verify resilience by injecting failure
+
+Stability patterns and clock discipline are *hypotheses* until something breaks them in anger. **Chaos
+engineering** is the discipline of deliberately injecting real-world failure to find the weaknesses
+*before* an incident does — empirical verification of the resilience designed in §1–2.
+
+- **Start from a steady-state hypothesis.** Define normal as a **measurable** output (throughput, p99
+  latency, error rate, a business metric), then hypothesize it *stays within bounds* during a failure.
+  An experiment that doesn't predict a steady-state outcome is just breaking things.
+- **Vary real-world events.** Inject the failures that actually happen: instance/process death, a
+  dependency returning errors or extra latency, a network partition or packet loss, a full disk, clock
+  skew, a resource exhausted. Prioritize by likelihood × impact.
+- **Minimize the blast radius, then grow it.** Begin in staging or on a tiny fraction of production
+  traffic with a **tested, fast abort** (automatically halt and roll back the instant the steady-state
+  metric breaches). Expand scope only as confidence builds. Chaos without a kill switch is an outage.
+- **Prefer production, but earn it.** Real weaknesses live in prod (config, scale, real traffic mix);
+  run there once experiments are safe and aborts are proven — never as the first step.
+- **Automate and make it continuous.** A one-off "game day" finds today's weakness; **automated,
+  recurring** experiments catch the regression a deploy introduces next month. Each confirmed weakness
+  becomes a fix *and* a permanent experiment (the resilience analogue of a regression test).
+
+A chaos finding is a real defect: classify it by `.claude/rules/quality-gates.md` severity and route the
+fix back through the dev lane, the same as any bug.
+
+> Stack-agnostic adaptation of chaos engineering (steady-state hypothesis, vary real-world events,
+> minimize blast radius with an automated abort, prefer production, run continuously) from the Apache-2.0
+> [`Netflix/chaosmonkey`](https://github.com/Netflix/chaosmonkey) and the Principles of Chaos. Re-derived
+> in prose; not vendored — the discipline is independent of any one fault-injection tool.
+
+---
+
+## Relationship to other rules
+
+- **`.claude/rules/agent-resilience.md`** — the same patterns applied to the *coding agent's* own run
+  (the agent surviving a tool/network failure), not the product's services. Read both; don't conflate.
+- **`.claude/rules/devops-observability.md`** — resilience is unmeasurable without SLOs, burn-rate
+  alerting, and the failure-domain progressive-rollout discipline; chaos experiments assert against the
+  SLOs defined there.
+- **`.claude/rules/quality-gates.md`** — a chaos finding or an unhandled cascading-failure path is a
+  finding classified and gated like any other.
+- **`.claude/rules/testing.md`** — deterministic simulation testing injects faults *in a reproducible
+  simulation*; chaos engineering injects them *in a real environment*. Complementary, not redundant.
+
+**This rule is working if** every remote call on a hot path has a timeout, a budgeted retry, and a
+breaker; one slow dependency can't take down the whole service; cross-node ordering never rests on a raw
+timestamp comparison; and the system's resilience has been *demonstrated* by injected failure, not just
+asserted in a design doc.