claude-code-kit 0.23.0__tar.gz → 0.24.0__tar.gz

{claude_code_kit-0.23.0 → claude_code_kit-0.24.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.23.0",
+      "version": "0.24.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.23.0",
+  "version": "0.24.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.23.0 → claude_code_kit-0.24.0}/CHANGELOG.md

@@ -4,6 +4,49 @@ 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.24.0] — 2026-06-24
+
+**PR3 of the phased hardening review: deeper validation, a deterministic pipeline CLI, an MCP
+lockfile, and a CI matrix that brings every distribution channel and quality dimension under test.**
+
+### Added
+
+- **`claude-kit validate --strict`** — beyond the structural checks, strict mode verifies that every
+  `settings.json` hook fires on a known event and runs an **installed, executable** script; that
+  `.mcp.json` has a sane `{mcpServers: {id: {command|url}}}` shape; that the resolved
+  `stack-catalog.snapshot.yaml` agrees with the agents/skills/overlays actually on disk; and that the
+  **bundled catalog is referentially consistent** (`validator.check_catalog`: every profile resolves to
+  existing agents/skills/registered hooks, every stack overlay rule/agent file is present, and the org
+  overlay's new skills/agents/rules/packs exist). `doctor` now runs the strict validate by default.
+- **`claude-kit pipeline` command group** (`src/claude_kit/pipeline.py`) — deterministic,
+  **non-executing** operations on the `/sdlc` state files: `pipeline validate` (snapshot shape +
+  profile/scope/mode/lane/findings coherence, with `last_gate_passed` checked against the installed
+  gate set), `pipeline status` (human-readable run summary), `pipeline close-gate <gate> --evidence
+  <file>` (records a passed gate, requiring the evidence artifact and a gate name the profile defines),
+  and `pipeline abort`. These validate/mutate `.claude/state/pipeline-snapshot.json` — they do **not**
+  run the pipeline.
+- **`.mcp.lock.json`** — when `.mcp.json` is written, a deterministic lockfile captures the resolved
+  package + pinned version (parsed from the `npx -y <pkg>@<ver>` args) or hosted URL per server, so a
+  reviewer can see exactly what would run. It is a kit-owned, derived artifact (refreshed on upgrade,
+  never a user sidecar). **`claude-kit doctor --mcp`** checks each server's command is on PATH, warns on
+  unset `${ENV}` vars, and flags a lockfile that has drifted from `.mcp.json` (warnings only).
+- **Expanded CI** (`.github/workflows/ci.yml`) — new jobs alongside the test matrix: `lint`
+  (`ruff check` + `ruff format --check` + `mypy`), `shell` (`shellcheck -S warning` over all hook + repo
+  scripts), `static` (`gen_hooks.py --check`, the docs-consistency guard, catalog referential
+  integrity, and JSON validity of the plugin manifests + `hooks.json`), and `wheel-smoke` (build → install
+  into a clean venv → `init --defaults` → `validate --strict` → `doctor`). `ruff`/`mypy`/`shellcheck-py`
+  are added to the `dev` extra, with conservative `[tool.ruff.lint]` (no E501) and `[tool.mypy]` config.
+
+### Fixed
+
+- **Latent type/lint bugs surfaced by the new CI** — `upgrader.py` used `ResolvedPlan` in annotations
+  without importing it (harmless under `from __future__ import annotations`, but undefined) and passed
+  `str | Path` to a `Path`-typed `_compare`; `_format_preview` could dereference `None`;
+  `prompts._choose_many` and `__main__` used None-returning calls in value position. All fixed; the
+  codebase is now `ruff` + `mypy --ignore-missing-imports` clean. Two hook scripts had redundant,
+  shellcheck-flagged glob alternatives (`*__tests__*` under `*test*`; `*oauth*`/`*authoriz*` under
+  `*auth*`) — removed with no behavior change.
+
 ## [0.23.0] — 2026-06-23
 
 **PR2 of the phased hardening review: structural single-source-of-truth for hooks, and plugin/CLI

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/CLAUDE.md

@@ -28,7 +28,7 @@ distributed two ways from one source of truth:
 | `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. |
 | `templates/org/` | **Org overlay** content (scope-gated, organization only): `skills/`, `agents/` (personas), `rules/` (policy/vibe), `packs/<pack>/{pack.yaml,README.md}`, `README.md`. Wired via `catalog/org.yaml`. The only place org-specific content lives. |
 | `scripts/init.sh` | Thin no-pip fallback scaffolder (copies the full payload; no catalog resolution) |
-| `src/claude_kit/` | The pip CLI (Typer): `cli.py`, `catalog.py` (resolver), `prompts.py`, `models.py`, `scaffold.py` (installer), `render.py` (Jinja2), `hooks.py`, `validator.py`, `upgrader.py` |
+| `src/claude_kit/` | The pip CLI (Typer): `cli.py`, `catalog.py` (resolver), `prompts.py`, `models.py`, `scaffold.py` (installer), `render.py` (Jinja2), `hooks.py`, `validator.py` (incl. `validate --strict` + `check_catalog`), `upgrader.py`, `pipeline.py` (deterministic `/sdlc` state-file ops) |
 | `tests/` | pytest suite (catalog, render, scaffold, validator, upgrader, CLI; incl. the profile×stack×scope self-test matrix) |
 | `examples/` | Synthetic end-to-end `/sdlc` worked example (repo reference; **not** bundled into the wheel) |
 | `docs/architecture.md` · `docs/agents.md` · `docs/coverage-audit.md` · `docs/eval-harness.md` | Architecture diagrams · agent guide · the GATED-vs-RULE-vs-SKILL enforcement audit · the with/without eval template |

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/CONTRIBUTING.md

@@ -71,6 +71,13 @@ claude-kit diff /tmp/ck-demo
 # Tests:
 pytest
 
+# Lint / type / shell / drift checks (all run in CI — keep them green locally):
+ruff check src scripts tests && ruff format --check src scripts tests
+mypy
+shellcheck -S warning hooks/scripts/*.sh scripts/*.sh
+python scripts/gen_hooks.py --check
+python scripts/check_docs_consistency.py
+
 # Build + validate the package:
 python3 -m build
 python3 -m twine check dist/*
@@ -88,8 +95,9 @@ a specific stack — `pytest` enforces the no-Docker invariant on a scaffolded p
 
 ## Releasing
 
-1. Bump the version in **all four** places: `pyproject.toml`, `.claude-plugin/plugin.json`, the
-   `.claude-plugin/marketplace.json` entry, and `src/claude_kit/__init__.py`.
+1. Bump the version in **all five** places: `pyproject.toml`, `.claude-plugin/plugin.json`, the
+   `.claude-plugin/marketplace.json` entry, `src/claude_kit/__init__.py`, and `SECURITY.md`
+   (`check_docs_consistency.py` enforces parity across all of them + the latest `CHANGELOG.md` heading).
 2. Add a `CHANGELOG.md` entry, including a **"Not adopted (deliberately)"** block stating what you
    chose *not* to add and why — this is a marketed feature of the changelog (the README links to it),
    so keep it. If those blocks ever grow unwieldy they may later split into `docs/decision-log.md`,

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.23.0
+Version: 0.24.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
@@ -21,7 +21,10 @@ Requires-Dist: pyyaml>=6.0
 Requires-Dist: typer>=0.12
 Provides-Extra: dev
 Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: shellcheck-py>=0.10; extra == 'dev'
 Requires-Dist: twine>=5.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
@@ -613,10 +616,11 @@ everything available.
 | Command | Description |
 |---------|-------------|
 | `init [path] [--defaults] [--config FILE] [--force]` | Scaffold `CLAUDE.md` + `.claude/` (interactive or non-interactive) |
-| `validate [path]` | Structurally validate an installed config |
-| `doctor [path]` | Validate + environment/health checks with fix hints |
+| `validate [path] [--strict]` | Structurally validate an installed config; `--strict` adds hooks→script, `.mcp.json`-shape, snapshot, and catalog-integrity checks |
+| `doctor [path] [--mcp]` | Strict validate + environment/health checks; `--mcp` checks MCP commands, `${ENV}` vars, and lockfile drift |
 | `diff [path]` | Preview what an `upgrade` would change (no writes) |
 | `upgrade [path] [--force]` | Refresh kit/overlay files; protect your edits; prune orphans |
+| `pipeline validate · status · close-gate · abort` | Inspect/mutate the `/sdlc` state files (gate/lane/evidence coherence); **does not run** the pipeline |
 | `list-options` | List available frontend/backend/database/profile/MCP options |
 | `status [path]` | Show what's installed, the selection, and working memory |
 | `version` | Print the version |
@@ -625,6 +629,9 @@ everything available.
 Plugin slash commands: `/claude-kit:init`, `/claude-kit:sdlc <task>`, `/claude-kit:status`; and the
 `/sdlc` skill inside any scaffolded project.
 
+> When MCP servers are selected, `init` also writes a derived **`.mcp.lock.json`** pinning each
+> server's resolved package version — inspect it (or run `doctor --mcp`) to see exactly what would run.
+
 </details>
 
 <details>

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/README.md

@@ -586,10 +586,11 @@ everything available.
 | Command | Description |
 |---------|-------------|
 | `init [path] [--defaults] [--config FILE] [--force]` | Scaffold `CLAUDE.md` + `.claude/` (interactive or non-interactive) |
-| `validate [path]` | Structurally validate an installed config |
-| `doctor [path]` | Validate + environment/health checks with fix hints |
+| `validate [path] [--strict]` | Structurally validate an installed config; `--strict` adds hooks→script, `.mcp.json`-shape, snapshot, and catalog-integrity checks |
+| `doctor [path] [--mcp]` | Strict validate + environment/health checks; `--mcp` checks MCP commands, `${ENV}` vars, and lockfile drift |
 | `diff [path]` | Preview what an `upgrade` would change (no writes) |
 | `upgrade [path] [--force]` | Refresh kit/overlay files; protect your edits; prune orphans |
+| `pipeline validate · status · close-gate · abort` | Inspect/mutate the `/sdlc` state files (gate/lane/evidence coherence); **does not run** the pipeline |
 | `list-options` | List available frontend/backend/database/profile/MCP options |
 | `status [path]` | Show what's installed, the selection, and working memory |
 | `version` | Print the version |
@@ -598,6 +599,9 @@ everything available.
 Plugin slash commands: `/claude-kit:init`, `/claude-kit:sdlc <task>`, `/claude-kit:status`; and the
 `/sdlc` skill inside any scaffolded project.
 
+> When MCP servers are selected, `init` also writes a derived **`.mcp.lock.json`** pinning each
+> server's resolved package version — inspect it (or run `doctor --mcp`) to see exactly what would run.
+
 </details>
 
 <details>

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/hooks/scripts/warn-missing-tests.sh

@@ -12,7 +12,7 @@ low="$(printf '%s' "$FILE_PATH" | tr '[:upper:]' '[:lower:]')"
 
 # Skip non-source: tests, docs, config, markdown, and the kit's own config.
 case "$low" in
-  *test*|*spec*|*__tests__*|*.md|*.markdown|*.json|*.ya?ml|*.toml|*.ini|*.cfg|*.txt|*.lock|*/.claude/*)
+  *test*|*spec*|*.md|*.markdown|*.json|*.ya?ml|*.toml|*.ini|*.cfg|*.txt|*.lock|*/.claude/*)
     exit 0 ;;
 esac
 

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/hooks/scripts/warn-sensitive-files.sh

@@ -11,7 +11,7 @@ FILE_PATH="$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_response.file
 low="$(printf '%s' "$FILE_PATH" | tr '[:upper:]' '[:lower:]')"
 
 case "$low" in
-  *auth*|*login*|*session*|*oauth*|*jwt*|*password*|*permission*|*rbac*|*authoriz*)
+  *auth*|*login*|*session*|*jwt*|*password*|*permission*|*rbac*)
     echo "WARN: editing an AUTH / authorization surface ($FILE_PATH). High-risk: get review + security check before completion (.claude/rules/risk-classification.md)." >&2 ;;
 esac
 case "$low" in

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.23.0"
+version = "0.24.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"
@@ -46,6 +46,9 @@ dev = [
   "pytest>=8.0",
   "build>=1.2",
   "twine>=5.0",
+  "ruff>=0.6",
+  "mypy>=1.10",
+  "shellcheck-py>=0.10",
 ]
 
 [project.urls]
@@ -62,6 +65,20 @@ claude-sdlc = "claude_kit.cli:main"
 testpaths = ["tests"]
 pythonpath = ["."]
 
+[tool.ruff]
+target-version = "py39"
+
+[tool.ruff.lint]
+# Deliberately conservative: pyflakes (F) + the actionable pycodestyle subsets (E4/E7/E9, W) +
+# import sorting (I) + bugbear (B). Line length (E501) is intentionally NOT enforced — docstrings and
+# pinned-version comments run long on purpose and `ruff format` owns layout.
+select = ["E4", "E7", "E9", "F", "W", "I", "B"]
+
+[tool.mypy]
+files = ["src/claude_kit"]
+ignore_missing_imports = true
+# typer/yaml ship without type stubs; we check our own code, not third-party signatures.
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/claude_kit"]
 

{claude_code_kit-0.23.0 → claude_code_kit-0.24.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.23.0"
+__version__ = "0.24.0"

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/src/claude_kit/__main__.py

@@ -1,8 +1,6 @@
 """Enable ``python -m claude_kit`` as an alias for the CLI."""
 
-import sys
-
 from claude_kit.cli import main
 
 if __name__ == "__main__":
-    sys.exit(main())
+    main()  # Typer's app() raises SystemExit with the right code itself.

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/src/claude_kit/cli.py

@@ -14,7 +14,15 @@ from typing import Optional
 
 import typer
 
-from claude_kit import __version__, catalog, prompts, scaffold, upgrader, validator
+from claude_kit import (
+    __version__,
+    catalog,
+    pipeline,
+    prompts,
+    scaffold,
+    upgrader,
+    validator,
+)
 
 BANNER = r"""
   ___ _      _   _ ___  ___   _  _____ _____
@@ -32,6 +40,11 @@ research_app = typer.Typer(
     no_args_is_help=True, help="Research helpers (license-respecting)."
 )
 app.add_typer(research_app, name="research")
+pipeline_app = typer.Typer(
+    no_args_is_help=True,
+    help="Inspect/mutate the /sdlc pipeline state files (does not run the pipeline).",
+)
+app.add_typer(pipeline_app, name="pipeline")
 
 
 def _version_callback(value: bool) -> None:
@@ -168,17 +181,27 @@ def init(
 @app.command()
 def validate(
     path: str = typer.Argument(".", help="target project dir (default: .)"),
+    strict: bool = typer.Option(
+        False,
+        "--strict",
+        help="deep checks: hooks→installed scripts, .mcp.json shape, snapshot + catalog integrity",
+    ),
 ) -> None:
     """Structurally validate a scaffolded .claude/ configuration."""
-    _print_report(*validator.validate(path))
+    _print_report(*validator.validate(path, strict=strict))
 
 
 @app.command()
 def doctor(
     path: str = typer.Argument(".", help="target project dir (default: .)"),
+    mcp: bool = typer.Option(
+        False,
+        "--mcp",
+        help="also check MCP servers: command on PATH, ${ENV} vars set, lockfile in sync",
+    ),
 ) -> None:
-    """Run validation plus environment/health checks with fix hints."""
-    _print_report(*validator.doctor(path))
+    """Run strict validation plus environment/health checks with fix hints."""
+    _print_report(*validator.doctor(path, mcp=mcp))
 
 
 @app.command()
@@ -333,6 +356,44 @@ def research_import_sources(
     raise typer.Exit(2)  # not a successful no-op — signal "unimplemented" to scripts/CI
 
 
+@pipeline_app.command("validate")
+def pipeline_validate(
+    path: str = typer.Argument(".", help="target project dir (default: .)"),
+) -> None:
+    """Check the pipeline snapshot's shape and gate/lane coherence (no writes)."""
+    _print_report(*pipeline.validate(path))
+
+
+@pipeline_app.command("status")
+def pipeline_status(
+    path: str = typer.Argument(".", help="target project dir (default: .)"),
+) -> None:
+    """Print a summary of the current pipeline run (stage, lanes, gate, findings, next)."""
+    _print_report(*pipeline.status(path))
+
+
+@pipeline_app.command("close-gate")
+def pipeline_close_gate(
+    gate: str = typer.Argument(
+        ..., help="gate token to mark passed (e.g. code-review)"
+    ),
+    evidence: str = typer.Option(
+        ..., "--evidence", help="path to the evidence artifact for this gate"
+    ),
+    path: str = typer.Argument(".", help="target project dir (default: .)"),
+) -> None:
+    """Record a quality gate as passed, with an evidence file, in the pipeline snapshot."""
+    _print_report(*pipeline.close_gate(path, gate, evidence))
+
+
+@pipeline_app.command("abort")
+def pipeline_abort(
+    path: str = typer.Argument(".", help="target project dir (default: .)"),
+) -> None:
+    """Mark the current pipeline run aborted."""
+    _print_report(*pipeline.abort(path))
+
+
 def main() -> None:
     """Console-script entry point."""
     app()

claude_code_kit-0.24.0/src/claude_kit/pipeline.py

@@ -0,0 +1,240 @@
+"""Deterministic, non-executing operations on the ``/sdlc`` pipeline state files.
+
+The ``/sdlc`` skill drives the actual pipeline; this module only **validates and mutates the state
+files** it leaves behind, so a human or CI can inspect a run, record a passed gate with evidence, or
+abort — without an LLM in the loop. It reads the runtime snapshot ``.claude/state/pipeline-snapshot.json``
+(schema in ``rules/continuity.md``) and cross-checks gate names against the resolved gate set recorded
+in ``.claude/config/stack-catalog.snapshot.yaml``. Every function returns the ``(ok, messages)``
+contract used by :mod:`claude_kit.validator`.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+#: Runtime pipeline snapshot, relative to the project root (gitignored state).
+SNAPSHOT_REL = ".claude/state/pipeline-snapshot.json"
+#: Resolved install snapshot (records the profile's gate set + selection).
+STACK_SNAPSHOT_REL = ".claude/config/stack-catalog.snapshot.yaml"
+
+#: Closed value-sets the snapshot fields must draw from (see rules/continuity.md).
+PROFILES = frozenset({"lean", "standard", "enterprise"})
+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"})
+
+
+def _snapshot_path(target: str | Path) -> Path:
+    return Path(target).expanduser().resolve() / SNAPSHOT_REL
+
+
+def _load_snapshot(target: str | Path) -> tuple[dict[str, Any] | None, str | None]:
+    """Return ``(snapshot, error)`` — ``error`` set if the file exists but won't parse."""
+    path = _snapshot_path(target)
+    if not path.is_file():
+        return None, None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        return None, f"pipeline snapshot is invalid JSON: {exc}"
+    if not isinstance(data, dict):
+        return None, "pipeline snapshot is not a JSON object"
+    return data, None
+
+
+def _installed_gates(target: str | Path) -> list[str]:
+    """Read the resolved gate set from the install snapshot ([] if absent/unreadable)."""
+    path = Path(target).expanduser().resolve() / STACK_SNAPSHOT_REL
+    if not path.is_file():
+        return []
+    try:
+        data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError:
+        return []
+    gates = data.get("gates")
+    return list(gates) if isinstance(gates, list) else []
+
+
+def _selection(target: str | Path) -> dict[str, Any]:
+    """Read the recorded selection from the install snapshot ({} if absent)."""
+    path = Path(target).expanduser().resolve() / STACK_SNAPSHOT_REL
+    if not path.is_file():
+        return {}
+    try:
+        data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError:
+        return {}
+    sel = data.get("selection")
+    return sel if isinstance(sel, dict) else {}
+
+
+def validate(target: str | Path) -> tuple[bool, list[str]]:
+    """Validate the pipeline snapshot's shape and coherence (no writes).
+
+    Absence is not an error — a repo with no active run is valid. When a snapshot is present, every
+    field that *is* set must hold a legal value (the schema lets fields be omitted, not malformed),
+    and ``last_gate_passed`` must name a gate the installed profile actually defines.
+    """
+    msgs: list[str] = []
+    ok = True
+
+    def fail(m: str) -> None:
+        nonlocal ok
+        ok = False
+        msgs.append(f"FAIL  {m}")
+
+    snap, err = _load_snapshot(target)
+    if err:
+        fail(err)
+        return ok, msgs
+    if snap is None:
+        msgs.append("OK    no pipeline snapshot — no run in progress")
+        return ok, msgs
+
+    schema = snap.get("schema")
+    if schema not in (None, 1):
+        msgs.append(f"WARN  unexpected snapshot schema {schema!r} (expected 1)")
+
+    for field, allowed in (
+        ("profile", PROFILES),
+        ("scope", SCOPES),
+        ("mode", MODES),
+    ):
+        val = snap.get(field)
+        if val is not None and val not in allowed:
+            fail(f"{field} {val!r} is not one of {sorted(allowed)}")
+
+    lanes = snap.get("lanes")
+    if lanes is not None:
+        if not isinstance(lanes, dict):
+            fail("lanes must be an object of {lane: state}")
+        else:
+            for lane, state in lanes.items():
+                if state not in LANE_STATES:
+                    fail(
+                        f"lane {lane!r} has invalid state {state!r} ({sorted(LANE_STATES)})"
+                    )
+
+    findings = snap.get("open_findings")
+    if findings is not None:
+        if not isinstance(findings, dict):
+            fail("open_findings must be an object of {severity: count}")
+        else:
+            for sev, count in findings.items():
+                if sev not in FINDING_KEYS:
+                    msgs.append(f"WARN  open_findings has unknown severity {sev!r}")
+                if not isinstance(count, int) or isinstance(count, bool):
+                    fail(f"open_findings[{sev!r}] must be an integer, got {count!r}")
+
+    gate = snap.get("last_gate_passed")
+    gates = _installed_gates(target)
+    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})")
+
+    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)")
+
+    if ok:
+        msgs.append(
+            f"OK    pipeline snapshot is coherent (stage: {snap.get('stage', '?')})"
+        )
+    return ok, msgs
+
+
+def status(target: str | Path) -> tuple[bool, list[str]]:
+    """Print a human-readable summary of the current pipeline snapshot (no writes)."""
+    snap, err = _load_snapshot(target)
+    if err:
+        return False, [f"FAIL  {err}"]
+    if snap is None:
+        return True, ["no pipeline run in progress (no snapshot)"]
+
+    msgs = [f"task:    {snap.get('task', '(none)')}"]
+    profile = snap.get("profile", "?")
+    scope = snap.get("scope", "?")
+    mode = snap.get("mode", "?")
+    msgs.append(f"profile: {profile}   scope: {scope}   mode: {mode}")
+    msgs.append(f"stage:   {snap.get('stage', '(none)')}")
+    lanes = snap.get("lanes") or {}
+    if lanes:
+        msgs.append("lanes:")
+        for lane, state in lanes.items():
+            msgs.append(f"  - {lane}: {state}")
+    msgs.append(f"last gate passed: {snap.get('last_gate_passed', '(none)')}")
+    findings = snap.get("open_findings") or {}
+    if findings:
+        rendered = ", ".join(f"{k}={v}" for k, v in findings.items())
+        msgs.append(f"open findings: {rendered}")
+    msgs.append(f"next:    {snap.get('next', '(none)')}")
+    return True, msgs
+
+
+def close_gate(
+    target: str | Path, gate: str, evidence: str | Path
+) -> 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.
+    """
+    msgs: list[str] = []
+    evidence_path = Path(evidence).expanduser().resolve()
+    if not evidence_path.is_file():
+        return False, [f"FAIL  evidence file not found: {evidence}"]
+
+    gates = _installed_gates(target)
+    if gates and gate not in gates:
+        return False, [
+            f"FAIL  {gate!r} is not a gate of this profile (choices: {', '.join(gates)})"
+        ]
+    if not gates:
+        msgs.append(
+            "WARN  no install snapshot — cannot confirm the gate name against the profile"
+        )
+
+    snap, err = _load_snapshot(target)
+    if err:
+        return False, [f"FAIL  {err}"]
+    if snap is None:
+        sel = _selection(target)
+        snap = {
+            "schema": 1,
+            "task": "(recorded via claude-kit pipeline close-gate)",
+            "profile": sel.get("profile"),
+            "scope": sel.get("scope"),
+            "stage": gate,
+        }
+
+    snap["last_gate_passed"] = gate
+    evidence_map = snap.get("gate_evidence")
+    if not isinstance(evidence_map, dict):
+        evidence_map = {}
+    evidence_map[gate] = str(evidence_path)
+    snap["gate_evidence"] = evidence_map
+
+    path = _snapshot_path(target)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(snap, indent=2) + "\n", encoding="utf-8")
+    msgs.append(f"OK    gate {gate!r} recorded passed (evidence: {evidence_path})")
+    return True, msgs
+
+
+def abort(target: str | Path) -> tuple[bool, list[str]]:
+    """Mark the current pipeline run aborted (stage=aborted); no run is not an error."""
+    snap, err = _load_snapshot(target)
+    if err:
+        return False, [f"FAIL  {err}"]
+    if snap is None:
+        return True, ["OK    no pipeline run in progress — nothing to abort"]
+    snap["stage"] = "aborted"
+    snap["next"] = "(run aborted via claude-kit pipeline abort)"
+    path = _snapshot_path(target)
+    path.write_text(json.dumps(snap, indent=2) + "\n", encoding="utf-8")
+    return True, ["OK    pipeline run marked aborted"]

{claude_code_kit-0.23.0 → claude_code_kit-0.24.0}/src/claude_kit/prompts.py

@@ -132,7 +132,12 @@ def _choose_many(title: str, options: list[dict[str, Any]]) -> list[str]:
             print(f"  (ignoring unknown selection: {tok})")
     # de-dup, preserve order
     seen: set[str] = set()
-    return [c for c in chosen if not (c in seen or seen.add(c))]
+    deduped: list[str] = []
+    for c in chosen:
+        if c not in seen:
+            seen.add(c)
+            deduped.append(c)
+    return deduped
 
 
 def interactive(payload_root: str | Path) -> Selection: