claude-code-kit 0.25.0__tar.gz → 0.26.1__tar.gz

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/.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.25.0",
+      "version": "0.26.1",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/.claude-plugin/plugin.json

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

@@ -4,6 +4,66 @@ 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.26.1] — 2026-06-24
+
+**A second strict practical review (installed and exercised end-to-end) surfaced seven papercuts on
+top of 0.26.0 — all bug fixes and polish, no behavior change for existing configs.**
+
+### Changed
+- **The destructive-delete guard is no longer order-dependent.** The previous regex only matched
+  `r…f` order, so `rm -fr`, `rm -r -f`, `rm -Rf`, and `rm --recursive --force` slipped through. It now
+  blocks any invocation that combines a recursive flag **and** a force flag in any order or spelling
+  (incl. `-R` and long flags); the plugin `hooks.json` and starter `settings.json` were regenerated
+  from the registry. New functional tests fire JSON payloads through the guard to lock the behavior in.
+- **CI lints shipped skill Python** (`ruff check … skills`), so future skill scripts are covered;
+  `zap_vapt.py` import ordering was fixed to match.
+
+### Fixed
+- **Upgrade artifacts are now gitignored.** `claude-kit upgrade` writes `.claude-kit.bak-*/` backup
+  dirs and `*.claude-kit` sidecars; a scaffolded `.gitignore` now lists both so `git add -A` never
+  commits a backup.
+- **Frontmatter hygiene, swept across every component.** Two skill descriptions over the 1024-char cap
+  (`design-patterns-and-conventions`, `shannon-ai-pentest`) were trimmed; `security-reviewer` and two
+  `templates/org` skills (`prompt-to-safe-task`, `repo-onboarding`) had unquoted `: ` scalars that
+  fail strict YAML and are now quoted; `smoke-test`'s `argument-hint` is a valid YAML string. A new
+  `tests/test_frontmatter.py` parses every shipped agent/command/skill under strict YAML and enforces
+  the description cap, so these regress loudly.
+
+## [0.26.0] — 2026-06-24
+
+**Post-hardening follow-up: two correctness/security fixes plus polish, all from a verified review
+punch list.**
+
+### Added
+- **Plugin now guards secret-file reads out of the box.** `protect-secrets` (PreToolUse/Read — blocks
+  reading `.env`/`.pem`/`.key`/`id_rsa`/credentials/…) was installed by the pip CLI (it's in the
+  `standard`/`all` profiles) but missing from the always-on plugin hook set, so plugin-only users had
+  no Read guard until they ran an init. It's now in `PLUGIN_HOOK_IDS`; `hooks/hooks.json` gains a
+  `PreToolUse`/`Read` group.
+- **`.github/dependabot.yml`** for the `github-actions` ecosystem (weekly, grouped) so CI/publish
+  actions are kept current and SHA-pinned by Dependabot's PRs, with auditable tag comments.
+  `pypa/gh-action-pypi-publish` stays on `release/v1` (required for Trusted Publishing + attestations).
+
+### Changed
+- **`pipeline close-gate` enforces the blocking-findings rule.** It now refuses to record a gate as
+  passed while any **critical/high/medium** findings are open (`rules/quality-gates.md`); low/cosmetic
+  still pass. A deliberate override requires `--force` **with** `--override-reason "<why>"`, recorded
+  under `gate_overrides[gate]` for human review.
+- **`pipeline validate` re-checks gate evidence.** When a gate is recorded passed and has a
+  `gate_evidence` path, validate now fails if that file no longer exists on disk, and surfaces any
+  force-closed gate. Lenient on the upgrade path (no evidence map → silent; partial map → warn).
+- **Inline hook guards quiet their `jq` calls** (`2>/dev/null || true`) so malformed/missing hook JSON
+  can't spam stderr — matching the script-backed guards; `guard-secrets.sh` aligned for consistency.
+
+### Fixed
+- **Docs consistency checker catches duplicate gate tables.** `check_docs_consistency.py` previously
+  keyed profile gate rows in a dict, so a second (possibly stale) table could silently overwrite an
+  earlier one; it now collects every occurrence, flags duplicates, and requires each to match
+  `profiles.yaml`.
+- **Stale comments in `scripts/init.sh`** corrected: it's described as the degraded, no-resolution
+  fallback (the pip CLI is the catalog-driven/upgrade-safe installer), and existing files are noted as
+  written to `*.claude-kit` sidecars (not `*.example`).
+
 ## [0.25.0] — 2026-06-24
 
 **PR4 of the phased hardening review: supply-chain provenance, an explicit trust model, and a full

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.25.0
+Version: 0.26.1
 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

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/agents/security-reviewer.md

@@ -1,6 +1,6 @@
 ---
 name: security-reviewer
-description: Security stage coordinator. Runs at Phase 5.4 (after test-coverage VERIFIED, before DevOps). Dispatches four sub-scanners in parallel — secret-scanner, dependency-scanner, owasp-reviewer, policy-validator — aggregates findings by severity, and owns the Security Clear gate. Read-only: routes fixes through the Orchestrator's defect loop.
+description: "Security stage coordinator. Runs at Phase 5.4 (after test-coverage VERIFIED, before DevOps). Dispatches four sub-scanners in parallel — secret-scanner, dependency-scanner, owasp-reviewer, policy-validator — aggregates findings by severity, and owns the Security Clear gate. Read-only: routes fixes through the Orchestrator's defect loop."
 tools: Agent, Read, Glob, Grep, Bash, SendMessage
 permissionMode: plan
 model: sonnet

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/hooks/hooks.json

@@ -29,11 +29,11 @@
         "hooks": [
           {
             "type": "command",
-            "command": "command -v jq >/dev/null 2>&1 || exit 0; CMD=$(jq -r '.tool_input.command'); if echo \"$CMD\" | grep -qE 'rm[[:space:]]+-[^[:space:]]*r[^[:space:]]*f'; then echo 'BLOCKED: rm -rf is disabled by claude-kit. Move to trash or delete specific paths explicitly.' >&2; exit 2; fi"
+            "command": "command -v jq >/dev/null 2>&1 || exit 0; CMD=$(jq -r '.tool_input.command' 2>/dev/null || true); if printf '%s' \"$CMD\" | grep -qE '(^|[^[:alnum:]_])rm([[:space:]]|$)' && printf '%s' \"$CMD\" | grep -qE '(^|[[:space:]])-[a-zA-Z]*[rR]|--recursive' && printf '%s' \"$CMD\" | grep -qE '(^|[[:space:]])-[a-zA-Z]*f|--force'; then echo 'BLOCKED: rm -rf (recursive+force, any flag order/spelling) is disabled by claude-kit. Move to trash or delete specific paths explicitly.' >&2; exit 2; fi"
           },
           {
             "type": "command",
-            "command": "command -v jq >/dev/null 2>&1 || exit 0; CMD=$(jq -r '.tool_input.command'); if echo \"$CMD\" | grep -qE 'git[[:space:]]+push.*[[:space:]:](main|master)([[:space:]]|$)'; then echo 'BLOCKED: refusing to push to main/master — use a feature branch and a PR.' >&2; exit 2; fi"
+            "command": "command -v jq >/dev/null 2>&1 || exit 0; CMD=$(jq -r '.tool_input.command' 2>/dev/null || true); if echo \"$CMD\" | grep -qE 'git[[:space:]]+push.*[[:space:]:](main|master)([[:space:]]|$)'; then echo 'BLOCKED: refusing to push to main/master — use a feature branch and a PR.' >&2; exit 2; fi"
           },
           {
             "type": "command",
@@ -49,6 +49,15 @@
           }
         ]
       },
+      {
+        "matcher": "Read",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "command -v jq >/dev/null 2>&1 || exit 0; FP=$(jq -r '.tool_input.file_path // empty' 2>/dev/null || true); if echo \"$FP\" | grep -qE '(^|/)\\.env$|\\.pem$|\\.key$|(^|/)id_rsa|(^|/)id_ed25519|(^|/)credentials(\\.json)?$|\\.p12$'; then echo 'BLOCKED: refusing to read a secrets file. Use .env.example or a secret manager.' >&2; exit 2; fi"
+          }
+        ]
+      },
       {
         "matcher": "Edit|Write",
         "hooks": [

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/hooks/scripts/guard-secrets.sh

@@ -3,7 +3,7 @@
 # Pairs with the secret-scanner agent and the protect-secrets read-guard — this is the automatic,
 # every-commit guardrail. Degrades to a no-op when not a git commit or git/jq is unavailable.
 command -v jq >/dev/null 2>&1 || exit 0
-CMD=$(jq -r '.tool_input.command // empty' 2>/dev/null)
+CMD=$(jq -r '.tool_input.command // empty' 2>/dev/null || true)
 echo "$CMD" | grep -qE 'git[[:space:]]+commit' || exit 0
 cd "${CLAUDE_PROJECT_DIR:-.}" 2>/dev/null || exit 0
 command -v git >/dev/null 2>&1 || exit 0

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.25.0"
+version = "0.26.1"
 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.25.0 → claude_code_kit-0.26.1}/rules/continuity.md

@@ -39,10 +39,14 @@ Schema (keep it small and truthful — omit a field rather than guess it):
   "lanes": { "<lane>": "not-started | in-progress | passed | failed" },
   "last_gate_passed": "<gate token, e.g. code-review>",
   "open_findings": { "critical": 0, "high": 0, "medium": 0 },
+  "gate_evidence": { "<gate token>": "<path to the evidence artifact>" },
+  "gate_overrides": { "<gate token>": "<why a blocking gate was force-closed>" },
   "next": "<the immediate next action>"
 }
 ```
 
+A gate is PASS only when zero **critical/high/medium** findings remain open (low/cosmetic may pass with notes). `gate_evidence` records the artifact backing each passed gate; `gate_overrides` is written **only** when a gate is deliberately force-closed despite open blocking findings, so a reviewer (or `claude-kit pipeline validate`) can surface and re-examine it.
+
 **Resume by reloading, not by re-running.** On resume, read the snapshot as *context* to decide where to continue — then continue from there. Do **not** re-run setup that already ran, re-apply edits already committed, or re-open a gate already PASSed. Re-enter at the first gate *after* `last_gate_passed`, re-running only un-passed or defect-affected lanes. The snapshot records what was *true when written*, so the verify-before-trust check still applies (`.claude/rules/agent-memory.md`): if a "passed" gate's artifact is gone, treat it as not passed. If the snapshot is absent or unparseable, fall back to the freeform CONTINUITY state (back-compatible) and proceed.
 
 ## Concurrency

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/scripts/check_docs_consistency.py

@@ -183,13 +183,17 @@ def _effective_gates() -> dict[str, set[str]]:
     return {name: resolve(name) for name in profiles}
 
 
-def _doc_gate_sets(relfile: str) -> dict[str, set[str]]:
-    """Parse the lean/standard/enterprise gate rows from a doc's profile→gate table."""
-    raw: dict[str, str] = {}
+def _doc_gate_sets(relfile: str) -> dict[str, list[set[str]]]:
+    """Parse *every* lean/standard/enterprise gate row from a doc (one entry per table occurrence).
+
+    Returns a list of gate sets per profile rather than a single value, so a second (possibly stale)
+    gate table can't silently overwrite an earlier one — each occurrence is checked independently.
+    """
+    raw: dict[str, list[str]] = {}
     for line in _read(relfile).splitlines():
         m = re.match(r"\|\s*\*\*(lean|standard|enterprise)\*\*\s*\|(.+?)\|\s*$", line)
         if m:
-            raw[m.group(1)] = m.group(2)
+            raw.setdefault(m.group(1), []).append(m.group(2))
 
     def tokens(cell: str) -> set[str]:
         return {
@@ -198,16 +202,18 @@ def _doc_gate_sets(relfile: str) -> dict[str, set[str]]:
             if t.strip().strip("*").strip("\\").strip()
         }
 
-    def expand(profile: str) -> set[str]:
-        cell = raw[profile]
+    def expand(cell: str) -> set[str]:
         if (
             "+" in cell
         ):  # e.g. "standard + pipeline-green · observability-ready · acceptance"
             base, extra = cell.split("+", 1)
-            return expand(base.strip().strip("*").lower()) | tokens(extra)
+            base_name = base.strip().strip("*").lower()
+            base_cells = raw.get(base_name)
+            base_gates = expand(base_cells[0]) if base_cells else set()
+            return base_gates | tokens(extra)
         return tokens(cell)
 
-    return {p: expand(p) for p in raw}
+    return {p: [expand(c) for c in cells] for p, cells in raw.items()}
 
 
 def check_profile_gates() -> list[str]:
@@ -216,21 +222,30 @@ def check_profile_gates() -> list[str]:
     for relfile in ("README.md", "skills/sdlc/SKILL.md"):
         doc = _doc_gate_sets(relfile)
         for profile in ("lean", "standard", "enterprise"):
-            if profile not in doc:
+            occurrences = doc.get(profile) or []
+            if not occurrences:
                 errors.append(f"{relfile}: no gate row found for profile {profile!r}")
                 continue
-            if doc[profile] != effective[profile]:
-                missing = effective[profile] - doc[profile]
-                extra = doc[profile] - effective[profile]
-                detail = []
-                if missing:
-                    detail.append(f"missing {sorted(missing)}")
-                if extra:
-                    detail.append(f"unexpected {sorted(extra)}")
+            if len(occurrences) > 1:
                 errors.append(
-                    f"{relfile}: {profile} gate row disagrees with profiles.yaml — "
-                    + "; ".join(detail)
+                    f"{relfile}: {len(occurrences)} gate rows for profile {profile!r} "
+                    "(duplicate gate table) — keep exactly one so a stale table can't hide "
+                    "behind a correct one"
                 )
+            for idx, gates in enumerate(occurrences):
+                if gates != effective[profile]:
+                    missing = effective[profile] - gates
+                    extra = gates - effective[profile]
+                    detail = []
+                    if missing:
+                        detail.append(f"missing {sorted(missing)}")
+                    if extra:
+                        detail.append(f"unexpected {sorted(extra)}")
+                    where = "" if len(occurrences) == 1 else f" (occurrence {idx + 1})"
+                    errors.append(
+                        f"{relfile}: {profile} gate row{where} disagrees with "
+                        "profiles.yaml — " + "; ".join(detail)
+                    )
     return errors
 
 

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/scripts/init.sh

@@ -5,13 +5,15 @@
 # project's .claude/ directory and drops a generic CLAUDE.md at the project root.
 #
 # Used by the /claude-kit:init slash command (plugin) and runnable directly from a checkout.
-# The pip CLI (`claude-kit init`) performs the same scaffolding in Python.
+# This is a degraded, no-resolution fallback: it copies the full payload as-is. The pip CLI
+# (`claude-kit init`) is the recommended installer — it is catalog-driven (stack/profile/MCP
+# resolution) and upgrade-safe (diff/upgrade), which this script does not do.
 #
 # Usage:  init.sh [TARGET_DIR] [--defaults] [--force] [--minimal] [--no-hooks]
 #   TARGET_DIR  project to scaffold into (default: $CLAUDE_PROJECT_DIR or current dir)
 #   --defaults  accepted for parity with the pip CLI (`claude-kit init --defaults`); a no-op here
 #               because this shell fallback is already non-interactive
-#   --force     overwrite existing CLAUDE.md / settings.json (otherwise written as *.example)
+#   --force     overwrite existing CLAUDE.md / settings.json (otherwise written as *.claude-kit sidecars)
 #   --minimal   only CLAUDE.md + rules/ (skip agents, skills, hooks, memory)
 #   --no-hooks  skip installing hook scripts and settings.json
 set -euo pipefail

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/skills/design-patterns-and-conventions/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: design-patterns-and-conventions
-description: Encodes the cross-cutting design patterns, naming conventions, folder layout, testing strategies, troubleshooting diagnostics, and catalogued anti-patterns observed across production Python/FastAPI backend services. Use when architecting new FastAPI services, refactoring code, reviewing structure, investigating technical debt, debugging session leaks or event loop blocks, setting up dependency injection, configuring multi-mode entrypoints (server/consumer/worker), implementing response envelopes, integrating Kafka or Temporal, organizing domain modules, or avoiding known anti-patterns (hardcoded secrets, CORS wildcards, sync clients in async code, unscoped sessions, deprecated lifecycle hooks). Particularly relevant for questions about layered architecture (router/service/dao), singleton patterns (ConnectionManager), CustomRequestRoute, loaded_config, naming standards (snake_case vs PascalCase), folder layout (per-domain modules), testing patterns (mocking, fixtures, TestClient), or troubleshooting common issues (session leaks, blocked event loop, duplicate routes, CORS errors, Kafka/Temporal problems).
+description: Encodes the cross-cutting design patterns, naming conventions, folder layout, testing strategies, troubleshooting diagnostics, and catalogued anti-patterns observed across production Python/FastAPI backend services. Use when architecting new FastAPI services, refactoring code, reviewing structure, investigating technical debt, debugging session leaks or event loop blocks, setting up dependency injection, configuring multi-mode entrypoints (server/consumer/worker), implementing response envelopes, integrating Kafka or Temporal, organizing domain modules, or avoiding known anti-patterns (hardcoded secrets, CORS wildcards, sync clients in async code, unscoped sessions, deprecated lifecycle hooks). Also covers layered architecture (router/service/dao), the ConnectionManager singleton, CustomRequestRoute, naming standards (snake_case vs PascalCase), per-domain folder layout, and testing patterns (mocking, fixtures, TestClient).
 ---
 
 Enforce consistent design patterns, naming conventions, and architectural decisions across FastAPI backends, derived from real-world production services.

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/skills/shannon-ai-pentest/SKILL.md

@@ -5,13 +5,12 @@ description: >
   app's source code, plans attacks, then runs real proof-of-concept exploits against the live app and
   reports only confirmed, reproducible findings. Covers installing/running the externally-distributed
   `npx @keygraph/shannon` CLI (setup, start, status, logs, stop, workspaces), configuring AI providers
-  (Anthropic / AWS Bedrock / Google Vertex AI / proxy) and model tiers, writing the YAML engagement
-  config (vuln classes, authentication + login flows + TOTP, scope avoid/focus rules, report
-  filtering, rate limits), reading the Markdown report, and the safety/authorization rules. Shannon is
-  a separate AGPL-3.0 tool you install yourself — this skill does NOT bundle it. Use when asked to run
-  Shannon, set up an autonomous/white-box AI pentest, exploit-test an app from its source, configure
-  `@keygraph/shannon`, write a Shannon engagement config, or produce a proof-by-exploitation security
-  report. Only for systems you own or are authorized to test, never production.
+  and model tiers, writing the YAML engagement config (vuln classes, auth + login flows + TOTP, scope
+  avoid/focus rules, report filtering, rate limits), reading the Markdown report, and the
+  safety/authorization rules. Shannon is a separate AGPL-3.0 tool you install yourself — this skill
+  does NOT bundle it. Use when asked to run Shannon, set up an autonomous/white-box AI pentest,
+  exploit-test an app from its source, write a Shannon engagement config, or produce a
+  proof-by-exploitation security report. Only for systems you own or are authorized to test.
 ---
 
 # Shannon — Autonomous White-Box AI Pentesting

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/skills/smoke-test/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: smoke-test
 description: Quick health check — verifies all services are running and basic user flow works. Use before starting development or after deployment.
-argument-hint: [optional: "backend-only" or "frontend-only"]
+argument-hint: 'backend-only | frontend-only (optional)'
 disable-model-invocation: true
 ---
 

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/skills/zap-vapt-scanning/scripts/zap_vapt.py

@@ -20,7 +20,6 @@ import atexit
 import base64
 import json
 import os
-from collections import Counter
 import platform
 import re
 import shlex
@@ -28,12 +27,13 @@ import shutil
 import subprocess
 import sys
 import time
+import xml.etree.ElementTree as ET
+from collections import Counter
 from dataclasses import dataclass, field
 from datetime import datetime
 from glob import glob
-from urllib.parse import urlsplit, quote_plus
+from urllib.parse import quote_plus, urlsplit
 from xml.sax.saxutils import escape as _xml_escape
-import xml.etree.ElementTree as ET
 
 # ----------------------------------------------------------------------------
 # Constants & small console helpers
@@ -1082,22 +1082,22 @@ def build_pdf(
     agg: Aggregates,
     unmatched: list | None = None,
 ):
-    from reportlab.lib.pagesizes import A4
     from reportlab.lib.colors import HexColor, white
     from reportlab.lib.enums import TA_CENTER
+    from reportlab.lib.pagesizes import A4
     from reportlab.lib.styles import ParagraphStyle
     from reportlab.lib.utils import ImageReader
     from reportlab.platypus import (
-        SimpleDocTemplate,
+        CondPageBreak,
+        Flowable,
+        Image,
+        ListFlowable,
+        PageBreak,
         Paragraph,
+        SimpleDocTemplate,
         Spacer,
         Table,
         TableStyle,
-        Image,
-        PageBreak,
-        ListFlowable,
-        Flowable,
-        CondPageBreak,
     )
 
     G, B, GR = HexColor(GREEN), HexColor(BLUE), HexColor(GRID)
@@ -2091,8 +2091,8 @@ def main() -> int:
         return run_selftest()
 
     try:
-        import requests  # noqa: F401
         import reportlab  # noqa: F401
+        import requests  # noqa: F401
     except ImportError:
         err("Missing dependencies. Run:  python3 -m pip install -r requirements.txt")
         return 2

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/src/claude_kit/__init__.py

@@ -7,4 +7,4 @@ Docker): ``claude-kit init`` asks ordered questions and lays down ``CLAUDE.md``
 as a plugin. Extensibility is data-driven via the ``catalog/`` (stacks, profiles, MCP).
 """
 
-__version__ = "0.25.0"
+__version__ = "0.26.1"

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/src/claude_kit/cli.py

@@ -381,9 +381,27 @@ def pipeline_close_gate(
         ..., "--evidence", help="path to the evidence artifact for this gate"
     ),
     path: str = typer.Argument(".", help="target project dir (default: .)"),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="close the gate despite open critical/high/medium findings (requires --override-reason)",
+    ),
+    override_reason: Optional[str] = typer.Option(
+        None,
+        "--override-reason",
+        help="justification recorded when --force bypasses open blocking findings",
+    ),
 ) -> None:
-    """Record a quality gate as passed, with an evidence file, in the pipeline snapshot."""
-    _print_report(*pipeline.close_gate(path, gate, evidence))
+    """Record a quality gate as passed, with an evidence file, in the pipeline snapshot.
+
+    Refuses to pass a gate while critical/high/medium findings are open unless --force is given with
+    an --override-reason (recorded for human review).
+    """
+    _print_report(
+        *pipeline.close_gate(
+            path, gate, evidence, force=force, override_reason=override_reason
+        )
+    )
 
 
 @pipeline_app.command("abort")

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/src/claude_kit/hooks.py

@@ -19,10 +19,12 @@ from typing import Any
 
 _RM_RF_GUARD = (
     "command -v jq >/dev/null 2>&1 || exit 0; "
-    "CMD=$(jq -r '.tool_input.command'); "
-    "if echo \"$CMD\" | grep -qE 'rm[[:space:]]+-[^[:space:]]*r[^[:space:]]*f'; then "
-    "echo 'BLOCKED: rm -rf is disabled by claude-kit. Move to trash or delete specific paths "
-    "explicitly.' >&2; exit 2; fi"
+    "CMD=$(jq -r '.tool_input.command' 2>/dev/null || true); "
+    "if printf '%s' \"$CMD\" | grep -qE '(^|[^[:alnum:]_])rm([[:space:]]|$)' "
+    "&& printf '%s' \"$CMD\" | grep -qE '(^|[[:space:]])-[a-zA-Z]*[rR]|--recursive' "
+    "&& printf '%s' \"$CMD\" | grep -qE '(^|[[:space:]])-[a-zA-Z]*f|--force'; then "
+    "echo 'BLOCKED: rm -rf (recursive+force, any flag order/spelling) is disabled by claude-kit. "
+    "Move to trash or delete specific paths explicitly.' >&2; exit 2; fi"
 )
 
 # Block pushes whose *target* ref is main/master. The branch token must be bounded by a space or
@@ -30,7 +32,7 @@ _RM_RF_GUARD = (
 # (maintenance, mainframe-fix, remaster-ui, domain-model) are NOT blocked.
 _PUSH_GUARD = (
     "command -v jq >/dev/null 2>&1 || exit 0; "
-    "CMD=$(jq -r '.tool_input.command'); "
+    "CMD=$(jq -r '.tool_input.command' 2>/dev/null || true); "
     "if echo \"$CMD\" | grep -qE 'git[[:space:]]+push.*[[:space:]:](main|master)([[:space:]]|$)'; "
     "then echo 'BLOCKED: refusing to push to main/master — use a feature branch and a PR.' >&2; "
     "exit 2; fi"
@@ -38,7 +40,7 @@ _PUSH_GUARD = (
 
 _SECRETS_GUARD = (
     "command -v jq >/dev/null 2>&1 || exit 0; "
-    "FP=$(jq -r '.tool_input.file_path // empty'); "
+    "FP=$(jq -r '.tool_input.file_path // empty' 2>/dev/null || true); "
     'if echo "$FP" | grep -qE \'(^|/)\\.env$|\\.pem$|\\.key$|(^|/)id_rsa|(^|/)id_ed25519|'
     "(^|/)credentials(\\.json)?$|\\.p12$'; then "
     "echo 'BLOCKED: refusing to read a secrets file. Use .env.example or a secret manager.' >&2; "
@@ -244,6 +246,7 @@ PLUGIN_HOOK_IDS: frozenset[str] = frozenset(
         "guard-rm-rf",
         "guard-push-main",
         "guard-destructive-git",
+        "protect-secrets",
         "guard-commit-secrets",
         "warn-shared-modules",
         "warn-llm-io",

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/src/claude_kit/pipeline.py

@@ -27,6 +27,9 @@ SCOPES = frozenset({"individual", "team", "organization"})
 MODES = frozenset({"A", "B", "C", "D"})
 LANE_STATES = frozenset({"not-started", "in-progress", "passed", "failed"})
 FINDING_KEYS = frozenset({"critical", "high", "medium", "low"})
+#: Severities that block a gate (rules/quality-gates.md: a gate is PASS only with zero of these;
+#: low/cosmetic may pass with notes). Ordered for stable messages.
+BLOCKING_FINDINGS = ("critical", "high", "medium")
 
 
 def _snapshot_path(target: str | Path) -> Path:
@@ -73,6 +76,23 @@ def _selection(target: str | Path) -> dict[str, Any]:
     return sel if isinstance(sel, dict) else {}
 
 
+def _blocking_findings(snap: dict[str, Any]) -> dict[str, int]:
+    """Return the ``{severity: count}`` of open findings that block a gate (count > 0).
+
+    Only :data:`BLOCKING_FINDINGS` severities count; malformed/absent counts are ignored (lenient
+    for older or partial snapshots).
+    """
+    raw = snap.get("open_findings")
+    if not isinstance(raw, dict):
+        return {}
+    out: dict[str, int] = {}
+    for sev in BLOCKING_FINDINGS:
+        count = raw.get(sev, 0)
+        if isinstance(count, int) and not isinstance(count, bool) and count > 0:
+            out[sev] = count
+    return out
+
+
 def validate(target: str | Path) -> tuple[bool, list[str]]:
     """Validate the pipeline snapshot's shape and coherence (no writes).
 
@@ -136,6 +156,31 @@ def validate(target: str | Path) -> tuple[bool, list[str]]:
     if gate is not None and gates and gate not in gates:
         fail(f"last_gate_passed {gate!r} is not a gate of this profile ({gates})")
 
+    overrides = snap.get("gate_overrides")
+    if overrides is not None and not isinstance(overrides, dict):
+        fail("gate_overrides must be an object of {gate: reason}")
+
+    # A recorded gate's evidence artifact must still exist on disk. Lenient on the upgrade path:
+    # a snapshot with no gate_evidence map at all simply doesn't track evidence (the norm for
+    # orchestrator-written snapshots) — stay silent; only flag a *partial* map that omits this gate.
+    if gate is not None:
+        evidence_map = snap.get("gate_evidence")
+        if isinstance(evidence_map, dict) and gate in evidence_map:
+            ev = evidence_map[gate]
+            if not (isinstance(ev, str) and Path(ev).expanduser().is_file()):
+                fail(
+                    f"last_gate_passed {gate!r} is recorded passed but its evidence file is "
+                    f"missing: {ev!r}"
+                )
+        elif isinstance(evidence_map, dict):
+            msgs.append(
+                f"WARN  last_gate_passed {gate!r} has no recorded gate_evidence path"
+            )
+        if isinstance(overrides, dict) and gate in overrides:
+            msgs.append(
+                f"WARN  gate {gate!r} was force-closed (override: {overrides[gate]!r}) — review"
+            )
+
     for field in ("task", "stage", "next"):
         if field not in snap or snap[field] is None:
             msgs.append(f"WARN  snapshot has no {field!r} (resume context is weaker)")
@@ -176,13 +221,23 @@ def status(target: str | Path) -> tuple[bool, list[str]]:
 
 
 def close_gate(
-    target: str | Path, gate: str, evidence: str | Path
+    target: str | Path,
+    gate: str,
+    evidence: str | Path,
+    *,
+    force: bool = False,
+    override_reason: str | None = None,
 ) -> tuple[bool, list[str]]:
     """Record ``gate`` as passed (with an evidence artifact) in the snapshot.
 
     Validates that the evidence file exists and that ``gate`` is a real gate for the installed
-    profile, then sets ``last_gate_passed`` and stores the evidence path. Seeds a minimal snapshot
-    (profile/scope from the install snapshot) if no run snapshot exists yet.
+    profile, **refuses to pass a gate while critical/high/medium findings are open** (per
+    ``rules/quality-gates.md``), then sets ``last_gate_passed`` and stores the evidence path. Seeds a
+    minimal snapshot (profile/scope from the install snapshot) if no run snapshot exists yet.
+
+    A forced close (``force=True`` with a non-empty ``override_reason``) bypasses the blocking-findings
+    rule but records the reason under ``gate_overrides[gate]`` so ``validate``/``status`` can surface it
+    for human review.
     """
     msgs: list[str] = []
     evidence_path = Path(evidence).expanduser().resolve()
@@ -212,6 +267,30 @@ def close_gate(
             "stage": gate,
         }
 
+    blocking = _blocking_findings(snap)
+    if blocking:
+        rendered = ", ".join(f"{sev}={count}" for sev, count in blocking.items())
+        if not force:
+            return False, [
+                f"FAIL  cannot close {gate!r}: {rendered} open finding(s) must be resolved first "
+                "(critical/high/medium block a gate per quality-gates.md). "
+                "Re-run with --force --override-reason '<why>' to record a deliberate override."
+            ]
+        if not (override_reason and override_reason.strip()):
+            return False, [
+                "FAIL  --force requires --override-reason '<why>' explaining why the open "
+                f"finding(s) ({rendered}) are being bypassed"
+            ]
+        overrides = snap.get("gate_overrides")
+        if not isinstance(overrides, dict):
+            overrides = {}
+        overrides[gate] = override_reason.strip()
+        snap["gate_overrides"] = overrides
+        msgs.append(
+            f"WARN  gate {gate!r} force-closed with open findings ({rendered}): "
+            f"{override_reason.strip()}"
+        )
+
     snap["last_gate_passed"] = gate
     evidence_map = snap.get("gate_evidence")
     if not isinstance(evidence_map, dict):

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/src/claude_kit/scaffold.py

@@ -36,6 +36,9 @@ GITIGNORE_ENTRIES = (
     "CLAUDE.local.md",
     ".claude/state/",
     ".claude/tmp/",
+    # upgrade/merge artifacts written by `claude-kit upgrade` — never commit these
+    ".claude-kit.bak-*/",
+    "*.claude-kit",
 )
 
 

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/templates/org/skills/prompt-to-safe-task/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: prompt-to-safe-task
-description: Use when anyone — especially a non-engineer — types a free-form request in plain language and wants it turned into a scoped, risk-classified, approval-gated task before anything happens. The safe front door for vibe-coding: goal → scope + out-of-scope → risk tier → success criteria → plan → approval, then route to the right skill/agent.
+description: "Use when anyone — especially a non-engineer — types a free-form request in plain language and wants it turned into a scoped, risk-classified, approval-gated task before anything happens. The safe front door for vibe-coding: goal → scope + out-of-scope → risk tier → success criteria → plan → approval, then route to the right skill/agent."
 ---
 
 # Prompt to Safe Task

{claude_code_kit-0.25.0 → claude_code_kit-0.26.1}/templates/org/skills/repo-onboarding/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: repo-onboarding
-description: Use when someone new to the repo — a new engineer, support, or any newcomer — asks "how does this fit together and where do I start?" Maps the architecture, explains key modules and entry points, surfaces conventions, and produces an ordered onboarding path plus a "where things live" guide. Read-only: explores and explains, never changes code.
+description: 'Use when someone new to the repo — a new engineer, support, or any newcomer — asks "how does this fit together and where do I start?" Maps the architecture, explains key modules and entry points, surfaces conventions, and produces an ordered onboarding path plus a "where things live" guide. Read-only: explores and explains, never changes code.'
 ---
 
 # Repo Onboarding