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

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

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

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

@@ -4,6 +4,41 @@ 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.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.0}/PKG-INFO

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

{claude_code_kit-0.25.0 → claude_code_kit-0.26.0}/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 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"
           },
           {
             "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.0}/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.0}/pyproject.toml

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

{claude_code_kit-0.25.0 → claude_code_kit-0.26.0}/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.0}/src/claude_kit/hooks.py

@@ -19,7 +19,7 @@ from typing import Any
 
 _RM_RF_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 '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"
@@ -30,7 +30,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 +38,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 +244,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.0}/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.0}/templates/settings.json

@@ -26,11 +26,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 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"
           },
           {
             "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"
           }
         ]
       },