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

{claude_code_kit-0.51.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.51.0",
+      "version": "0.53.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

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

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.51.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.51.0 → claude_code_kit-0.53.0}/CHANGELOG.md

@@ -4,6 +4,117 @@ 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
+**168** repos — Meta long ago spun React, PyTorch, Jest, etc. into dedicated orgs, so the `facebook` org
+itself is small). Every repo was surveyed (7 agents over every page — no repo skipped), candidates
+deep-read for license + transferable practice, and the shortlist **adversarially verified** against the
+live source. The org is almost entirely libraries/frameworks/language-tooling with nothing transferable
+to a config scaffolder, and several famous repos were **already covered** (`infer` by the 0.51
+compile-time-logic-bug lint layer; React by the kit's React overlay; testing by an already-deep
+`testing.md`). The verify pass *dropped* the weak picks — `DNE-TaaC` (datacenter network-device testing,
+1★, overlaps the config-driven skills) and `mbt` (a 0★ Meta-service-specific binary-transparency client;
+that practice belongs to Sigstore/Certificate-Transparency, not this org). **3 adoptions, all extensions
+to existing rules — 0 new agents/skills/rules** (skill counts unchanged at 104/56/48; MCP fragments
+unchanged at 17). All sources MIT / Apache-2.0.
+
+Rules:
+
+- **`linting-and-formatting.md`** — a new **Interprocedural Taint / Data-Flow Analysis** layer: declare
+  untrusted **sources**, dangerous **sinks**, and **sanitizers**, then trace data flow *across function
+  boundaries* and flag any unsanitized source→sink path — distinct from the single-line Security-Lint
+  layer and the Compile-Time Logic-Bug layer, and the automated codebase-wide complement to
+  `security-and-hardening`'s secure-by-construction wrappers (from the MIT `facebook/pyre-check`/Pysa and
+  `facebook/mariana-trench`; engines: Pysa/Mariana Trench/CodeQL/Semgrep).
+- **`devops-observability.md`** — a **continuous performance-regression CI gate**: run the baseline
+  (control) and the PR commit (treatment) **concurrently on the same machine** to cancel environmental
+  variance, and gate on the **relative delta** (with a tolerance band) rather than an absolute number —
+  catching the gradual regressions the one-shot Load-vs-SLO gate misses (from the Apache-2.0
+  `facebook/FAI-PEP`).
+- **`agent-guardrails.md`** — extended §4's sandbox **policy** with **defense-in-depth enforcement**:
+  L1 policy decision (existing) + L2 argument validation at the boundary (path canonicalization,
+  injection screening, response sanitization) + L3 OS-level runtime backstop (eBPF-LSM/seccomp
+  intercepting `open`/`connect`/`exec`) so a tool that ignores the declarative policy still cannot escape
+  scope (from the MIT `facebook/mcpguard-dynamic`).
+
+What we **did not** add (already covered, or fails the bar): `infer`/`mariana-trench`-as-a-tool and
+`sapp` (the kit's compile-time-logic-bug + new taint layer cover the discipline); `fbt` i18n (JS-specific,
+archived); `memlab` (JS-only heap analysis); `Ax` (ML hyperparameter optimization, a library);
+`chef-cookbooks`/`IT-CPE`/`taste-tester` (Chef IaC / IT fleet management); `ThreatExchange`/`threat-research`
+(content-moderation / CTI data, out of SDLC scope); `akd`/`private_processing` (domain-specific crypto
+libraries); plus the dropped `DNE-TaaC` and `mbt`.
+
 ## [0.51.0] — 2026-06-28
 
 **Adopt the verified wins from an exhaustive review of the entire `google` GitHub org** (all **2,881**

{claude_code_kit-0.51.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.51.0 → claude_code_kit-0.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.51.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
@@ -519,6 +519,8 @@ non-duplicative gaps**, minimally and catalog-wired.
 | **[alibaba/open-code-review](https://github.com/alibaba/open-code-review)** | Partition-for-coverage review — deterministic full-file coverage on large changesets, related-file bundling, plan-before-deep-pass | The "Cover Every Changed File" section in `code-review-and-quality` + a Coverage category in `sdlc-code-reviewer` | `0.48.0` |
 | **[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.
@@ -528,29 +530,6 @@ non-duplicative gaps**, minimally and catalog-wired.
 
 <br>
 
-**🔍 alibaba/open-code-review → coverage-partition review (0.48.0).** A detailed read showed most of its
-methodology (multi-axis review, line-level grounding + re-verify, severity, multi-model) was *already*
-in `code-review-and-quality`. The one genuine gap: **complete file coverage on large changesets** —
-where AI reviewers silently skip files. We added "Cover Every Changed File: Partition, Plan, Then
-Weight Depth" (enumerate from the diff as the checklist of record → bundle related files →
-isolated-context concurrent review → reconcile every file to a verdict), reframing the existing hotspot
-guidance as the *depth* step that follows coverage.
-
-**🟦 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
@@ -571,6 +550,43 @@ burn-rate alerting & log rate-limiting in `devops-observability`; long-document
 `api-integration`; and **4 first-party Google Security Operations MCP fragments** (Chronicle SIEM · GTI ·
 SCC · SOAR).
 
+**🔵 facebook (Meta) org review → 3 hardening & reliability patterns (0.52.0).** We reviewed **all 168
+repos** in the Meta org (Meta long ago spun React, PyTorch, Jest, etc. into their own orgs, so the
+`facebook` org is small). The org is almost entirely libraries, frameworks, and language tooling with
+nothing transferable to a config scaffolder — and several famous repos were **already covered** (e.g.
+`infer` by the 0.51 compile-time-logic-bug lint layer; React by the kit's React overlay; testing by an
+already-deep `testing.md`). The verify pass *dropped* the weak picks: `DNE-TaaC` (datacenter
+network-device testing, 1★, overlaps the config-driven skills) and `mbt` (a 0★ Meta-service-specific
+binary-transparency client — that practice belongs to Sigstore/Certificate-Transparency, not this org).
+Three genuine, stack-agnostic survivors, all **prose extensions, zero new agents/skills/rules**:
+**interprocedural taint / data-flow analysis** (declare sources/sinks/sanitizers, trace untrusted data
+across functions — distinct from single-line lint) in `linting-and-formatting` (from Pysa/`pyre-check` +
+`mariana-trench`); a **continuous A/B performance-regression CI gate** (concurrent control vs treatment
+to cancel environment noise, gate on the relative delta) in `devops-observability` (from `FAI-PEP`); and
+**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
@@ -624,7 +640,7 @@ SCC · SOAR).
 
 ## 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`,
@@ -775,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.51.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
@@ -489,6 +489,8 @@ non-duplicative gaps**, minimally and catalog-wired.
 | **[alibaba/open-code-review](https://github.com/alibaba/open-code-review)** | Partition-for-coverage review — deterministic full-file coverage on large changesets, related-file bundling, plan-before-deep-pass | The "Cover Every Changed File" section in `code-review-and-quality` + a Coverage category in `sdlc-code-reviewer` | `0.48.0` |
 | **[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.
@@ -498,29 +500,6 @@ non-duplicative gaps**, minimally and catalog-wired.
 
 <br>
 
-**🔍 alibaba/open-code-review → coverage-partition review (0.48.0).** A detailed read showed most of its
-methodology (multi-axis review, line-level grounding + re-verify, severity, multi-model) was *already*
-in `code-review-and-quality`. The one genuine gap: **complete file coverage on large changesets** —
-where AI reviewers silently skip files. We added "Cover Every Changed File: Partition, Plan, Then
-Weight Depth" (enumerate from the diff as the checklist of record → bundle related files →
-isolated-context concurrent review → reconcile every file to a verdict), reframing the existing hotspot
-guidance as the *depth* step that follows coverage.
-
-**🟦 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
@@ -541,6 +520,43 @@ burn-rate alerting & log rate-limiting in `devops-observability`; long-document
 `api-integration`; and **4 first-party Google Security Operations MCP fragments** (Chronicle SIEM · GTI ·
 SCC · SOAR).
 
+**🔵 facebook (Meta) org review → 3 hardening & reliability patterns (0.52.0).** We reviewed **all 168
+repos** in the Meta org (Meta long ago spun React, PyTorch, Jest, etc. into their own orgs, so the
+`facebook` org is small). The org is almost entirely libraries, frameworks, and language tooling with
+nothing transferable to a config scaffolder — and several famous repos were **already covered** (e.g.
+`infer` by the 0.51 compile-time-logic-bug lint layer; React by the kit's React overlay; testing by an
+already-deep `testing.md`). The verify pass *dropped* the weak picks: `DNE-TaaC` (datacenter
+network-device testing, 1★, overlaps the config-driven skills) and `mbt` (a 0★ Meta-service-specific
+binary-transparency client — that practice belongs to Sigstore/Certificate-Transparency, not this org).
+Three genuine, stack-agnostic survivors, all **prose extensions, zero new agents/skills/rules**:
+**interprocedural taint / data-flow analysis** (declare sources/sinks/sanitizers, trace untrusted data
+across functions — distinct from single-line lint) in `linting-and-formatting` (from Pysa/`pyre-check` +
+`mariana-trench`); a **continuous A/B performance-regression CI gate** (concurrent control vs treatment
+to cancel environment noise, gate on the relative delta) in `devops-observability` (from `FAI-PEP`); and
+**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
@@ -594,7 +610,7 @@ SCC · SOAR).
 
 ## 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`,
@@ -745,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.51.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.51.0 → claude_code_kit-0.53.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.51.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.51.0 → claude_code_kit-0.53.0}/rules/agent-guardrails.md

@@ -125,6 +125,28 @@ agent on a broken foundation.* Before worrying about prompt injection, enforce t
 
   A ready WASM-sandboxed execution runtime ships as the optional `wassette` MCP server in
   `catalog/mcp.yaml` for projects that want an off-the-shelf containment backend.
+- **Enforce the policy in independent layers (defense in depth).** A declarative policy is necessary but
+  not sufficient: a misbehaving or compromised tool/MCP server can ignore an *advisory* policy, or smuggle
+  a forbidden action past it. So a high-risk tool call (especially one invoking an untrusted MCP server)
+  should pass **three independent checks**, each of which fails closed on its own:
+  - **L1 — policy decision.** The declarative policy above decides *is this call allowed at all* (which
+    tool, which scopes) before it runs.
+  - **L2 — argument validation at the boundary.** Validate the call's *arguments* against the policy:
+    **canonicalize** paths and resolve symlinks before the allow-check (so `../` and a symlinked path
+    can't escape an allowed prefix — mirrors the archive/path-traversal rule in `security-and-hardening`),
+    screen arguments for injection, and sanitize the tool's *response* before it re-enters the model
+    (it is untrusted content — §1).
+  - **L3 — runtime enforcement backstop.** Enforce the same scopes at the OS/runtime level —
+    seccomp / eBPF-LSM / container or microVM limits that intercept the actual `open`/`connect`/`exec`
+    syscalls — so a tool that ignored or hardcoded around L1/L2 *still* cannot touch a denied path,
+    host, or process. The backstop assumes the layers above it can be bypassed.
+
+  Log every denial to the §5 audit trail; an operator override is itself a scoped, audited action.
+
+  > Stack-agnostic adaptation of layered (defense-in-depth) MCP/agent tool-call sandboxing — declarative
+  > capability policy + argument-level validation + OS-level (eBPF-LSM/seccomp) enforcement backstop —
+  > from the MIT [`facebook/mcpguard-dynamic`](https://github.com/facebook/mcpguard-dynamic). Re-derived
+  > in prose; not vendored.
 - **Audit dependencies; don't auto-trust the ecosystem.** Treat third-party packages, MCP servers, and
   marketplace plugins as untrusted until reviewed — installing one grants it your agent's privileges.
 

{claude_code_kit-0.51.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.51.0 → claude_code_kit-0.53.0}/rules/devops-observability.md

@@ -89,6 +89,61 @@ under load:
 > Apache-2.0 [`google/flogger`](https://github.com/google/flogger). Re-derived in prose; not vendored —
 > the patterns apply to any logging framework.
 
+### Continuous performance-regression gate (A/B, not absolute thresholds)
+
+The Load-vs-SLO gate above is a *one-shot, pre-launch* check against an absolute budget. It won't catch a
+**gradual** regression — a change that quietly adds 15 ms per release until the SLO is blown six PRs
+later. For a hot / SLO-bearing path, add a **continuous** check that compares *this commit to a baseline*
+on every change:
+
+- **A/B the two commits to cancel environmental noise.** A single absolute number ("p95 = 210 ms") is
+  dominated by CI-runner variance, thermal throttling, and noisy neighbors — comparing today's run to
+  last week's run measures the *environment*, not the *code*. Instead run **control (baseline commit) and
+  treatment (the PR's commit) on the same machine, interleaved/concurrently**, and report the **relative
+  delta** (latency ratio, throughput delta), which cancels the shared environmental component.
+- **Gate on the delta, with a tolerance band.** Fail the check when the treatment is worse than control
+  by more than a stated margin (e.g. ">5 % p95 latency"); a band absorbs residual noise so the gate
+  isn't flaky. A breach is **High** (`.claude/rules/quality-gates.md`) — same severity as a Load-vs-SLO
+  breach — and routes the fix back to the dev lane.
+- **Scope it.** Run it for changes to a concurrency-sensitive or SLO-bearing path; *skip (note why in
+  `CONTINUITY.md`)* for changes with no performance surface. It complements, not replaces, the one-shot
+  Load-vs-SLO gate (absolute budget at launch) and frontend statistical benchmarking
+  (`.claude/skills/performance-optimization`).
+
+> Stack-agnostic adaptation of A/B continuous performance-regression detection (concurrent
+> 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