claude-code-kit 0.75.0__tar.gz → 0.77.0__tar.gz

claude_code_kit-0.77.0/.claude-plugin/marketplace.json

@@ -0,0 +1,19 @@
+{
+  "name": "claude-kit",
+  "description": "claude-kit — an autonomous, stack-agnostic SDLC for Claude Code, delivered as a plugin.",
+  "owner": {
+    "name": "Arjunsingh Yadav",
+    "url": "https://github.com/ajyadav013"
+  },
+  "plugins": [
+    {
+      "name": "claude-kit",
+      "displayName": "Claude Kit SDLC",
+      "source": "./",
+      "description": "Evidence-gated SDLC for Claude Code, installed as configuration (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 with a tamper-evident gate ledger, working memory, and a self-improving learnings loop.",
+      "version": "0.77.0",
+      "license": "MIT",
+      "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
+    }
+  ]
+}

claude_code_kit-0.77.0/.claude-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "name": "claude-kit",
+  "displayName": "Claude Kit SDLC",
+  "version": "0.77.0",
+  "description": "Evidence-gated SDLC for Claude Code, installed as configuration (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 a tamper-evident gate ledger, working memory, and a self-improving learnings loop.",
+  "author": {
+    "name": "Arjunsingh Yadav",
+    "url": "https://github.com/ajyadav013"
+  },
+  "homepage": "https://github.com/ajyadav013/claude-kit",
+  "repository": "https://github.com/ajyadav013/claude-kit",
+  "license": "MIT",
+  "keywords": [
+    "sdlc",
+    "agents",
+    "orchestration",
+    "code-review",
+    "testing",
+    "quality-gates",
+    "workflow",
+    "automation",
+    "scaffold",
+    "cookiecutter"
+  ]
+}

{claude_code_kit-0.75.0 → claude_code_kit-0.77.0}/CHANGELOG.md

@@ -4,6 +4,311 @@ 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.77.0] — 2026-08-04
+
+**The kit stopped fitting in the window it ships into.** Every rule in `.claude/rules/` loaded at
+launch, on every session, whether or not it applied. Measured on a default install: **101,255 tokens
+of rules, 173,750 tokens of standing context — 87% of a 200k window consumed before a single word of
+work.** On the flagship path this was not a slow session, it was a dead one: a `/sdlc` run on the
+shipped default was killed by autocompact thrashing having dispatched *zero* agents.
+
+### Fixed
+
+- **Rules are now split into a covenant and a scoped set.** Seven rules whose trigger is *temporal*
+  — `rarv-cycle`, `risk-classification`, `autonomy-levels`, `quality-gates`, `mandatory-workflow`,
+  `human-in-the-loop`, `continuity` — still load at launch, because "every turn" and "every change"
+  cannot be expressed as a file glob. The other eighteen carry `paths:` frontmatter and load when you
+  touch matching files.
+
+  | | standing context | attributable to rules | % of a 200k window |
+  |---|---:|---:|---:|
+  | before | 173,750 | 101,255 | 87% |
+  | after | 91,511 | 19,016 | 46% |
+
+  **Nothing was moved, renamed, shortened or deleted.** Every rule keeps its full text at its
+  existing path, so all ~668 `.claude/rules/<name>.md` citations across agents, skills and docs still
+  resolve, and any rule remains readable by name at any time.
+
+- **`CLAUDE.md` gained a rule index** — the seven always-on rules and the eighteen on-demand ones,
+  each with a "read it when" trigger, so a scoped rule stays discoverable rather than merely absent.
+
+- **`documentation.md` is scoped to source files, not only markdown.** It mandates headers and
+  docstrings on *source*; scoping it to `**/*.md` would have inverted it, loading the rule when
+  editing docs and hiding it when editing the code it governs.
+
+- **Security- and observability-sensitive work now reaches a specialist regardless of which
+  workflow it routed to.** Across fifteen shipped-default scenario runs, `agents_spawned` and
+  `skills_invoked` were both empty — the entire agent and skill layer was dormant. Two structural
+  causes: pipeline stages are written as bracketed role *labels* (`[Developer]`), which read as a
+  hat the main session puts on rather than an agent to spawn; and anything that is not a new feature
+  routes to a six-step bug-fix flow with no specialist step, so a SQL-injection fix bypassed the
+  security stage by construction. `mandatory-workflow.md` gained a **Specialist routing** block keyed
+  on the *surface the change touches*, an explicit statement that a bracketed label names an agent,
+  and a proportionality clause. Measured: baseline 0 spawns; with the block, `security-reviewer` in
+  2/2 runs (one fanning out to all four sub-scanners), while a docs-only task still spawns nothing
+  and passes.
+
+- **The learnings hook no longer tells every session that capture is automatic.**
+  `load-learnings.sh` injected "New learnings are captured automatically" unconditionally, but
+  0.76.0 consent-gated the capture hooks *off* by default — so in a default install the kit asserted
+  a falsehood into context on every session, and a self-defeating one: an agent told its learnings
+  are already recorded has no reason to record them. It now reads the installed `settings.json` and
+  states which of the two worlds the project is in.
+
+- **Reference solutions, fixtures and holdouts are excluded from `ruff`.** They are data, not this
+  project's code — spec behaviours match against their source *text*, so import-sorting or
+  reformatting them could silently change what a check matches. Mirrors the existing
+  `collect_ignore_glob` in the eval conftest.
+
+- **The commit secret-guard now catches URI-embedded credentials and AWS secret access keys.**
+  `hooks/scripts/guard-secrets.sh` matched only vendor-*prefixed* tokens (`AKIA…`, `sk_live_…`,
+  `ghp_…`) and PEM headers, so `postgresql://svc:<real-password>@db/warehouse` and
+  `AWS_SECRET_ACCESS_KEY=<40 chars>` — neither of which carries a distinguishing prefix — committed
+  cleanly. Both are detected now, and the hook's values-not-names rule is preserved: the AWS key
+  matches only when the variable name sits *adjacent to* a 40-character value, so a CI binding or a
+  prose mention still passes. URI credentials require a high-entropy password (≥16 characters,
+  excluding placeholder shapes such as `user:pass`, `<REDACTED>`, `${VAR}` and `YOUR_*`) — this repo
+  alone ships 30+ documentation placeholders of that shape, and a guard that blocks a compose-file
+  example teaches people to work around the guard.
+
+- **Skills that were losing selection now win it.** Ten skills either lost to a plausible neighbour
+  on a restatement of their own description (`api-integration` → `tanstack-react-query-patterns`,
+  `component-design` → `frontend-ui-engineering`, `performance-optimization` →
+  `frontend-ui-engineering`, `smoke-test` → `run`) or fired nothing at all (`load-testing`,
+  `manual-test`, `sprint`, `security-and-hardening`, `security-verification`,
+  `modernization-and-migration`). `CLAUDE.md` gained a **Skill routing** section stating each
+  boundary — what the skill is *not* — plus the four that were simply silent. Measured over 20 runs
+  (10 skills × 2 replicates, serial, prompts fixed up front): **19/20 invoked the target skill by
+  name, against a recorded baseline of 0/10.**
+
+  The section also explains *why* these particular skills need naming: sixteen of them carry
+  `disable-model-invocation: true`, so the picker never volunteers them. That is a deliberate design
+  choice and **not** a prohibition — 13 of the 14 slash-only runs invoked their skill normally once
+  it was named. A drift test pins the list in both directions, so a skill that gains the flag cannot
+  go quietly unroutable and one that loses it cannot keep a rationale that no longer applies.
+
+- **Two repo validators can now fail.** `check_skill_descriptions.py` and
+  `check_cross_references.py` both detected their planted defects but exited 0 by design, so a
+  regression in either shipped silently — and two over-long descriptions had persisted precisely
+  because nothing failed. Both offenders are long since fixed and both checkers are clean, so CI now
+  runs them with `--strict`. Verified two-sided rather than assumed: each exits 1 on a planted
+  defect and 0 on the shipped payload.
+
+- **The release docs no longer describe a manual step that has been automated since 0.57.0.**
+  `CONTRIBUTING.md` and `CLAUDE.md` both told the releaser to "tag the release and push", which
+  `publish.yml`'s `github-release` job has done automatically for eighteen releases. That stale
+  instruction is also why `scripts/backfill-releases.sh` looked like dead code: nothing told anyone
+  to run it. Both sections now state that tagging is automatic and name the script as the recovery
+  path for a published version missing its tag.
+
+### Added
+
+- **`verify-continuity-writeback.sh`** — a Stop hook that reports when a session changed files but
+  never wrote back to `CONTINUITY.md`. `rarv-cycle.md` step 4 ("update `CONTINUITY.md` with what
+  passed") was observed 0/12 across every measured arm *including the arm where `rarv-cycle` was the
+  only rule loaded*: a rule that cannot cause its behaviour even alone is not weak prose but an
+  unkept contract, so it gets a mechanism — the Stop-hook mirror of the SessionStart hook that
+  already carries the read half. The signal is mtime ordering rather than "was the file touched",
+  because the rule asks for a write-back *after* the work and a stale file must not be credited.
+  Whether the content is any good is deliberately not graded: that is an LLM judgement, and this
+  kit's own rules forbid substituting one for a deterministic oracle. Never blocks; every unknown
+  (no git, no jq, unreadable mtime) degrades to silence.
+- `scripts/evals/grade_covenant.py` — grades the covenant dilution sweep, refuses to score a run
+  that produced no oracle verdict, and prints the specificity control beside the result so a
+  prompt-length effect cannot be read as a rule effect.
+- Nine hook-script tests: six two-sided ones for the write-back hook (it must *fire* on a planted
+  defect and stay *silent* on the compliant control, a clean tree, its own `.claude/` output, a stop
+  chain, and outside a git repo) and three pinning both arms of the capture-state wording.
+- `scripts/evals/measure-standing-context.sh` — reproducible standing-context measurement
+  (`input + cache_creation + cache_read`), with an empty-directory control so the kit's cost is
+  reported as a *difference* and never as a raw session total.
+- Four new payload pins in `tests/test_rule_frontmatter.py`: the covenant is frontmatter-free, every
+  other core rule carries valid globs, covenant membership is exhaustive (a new rule must make a
+  deliberate covenant-or-scoped choice rather than joining the always-on set by omission), and
+  `documentation.md` matches source.
+- Eight `guard-secrets.sh` scenarios in `tests/evals/hooks/hook-scenarios.json` — three proving the
+  new detections fire, five as false-positive controls. All five controls also pass against the
+  *pre-fix* hook, so the change is measured to add catches without adding noise.
+- A `pentest-scanner` entry in `docs/KNOWN_LIMITATIONS.md`. The agent is enterprise-only, opt-in and
+  preflight-gated, so a default install correctly reports `SKIPPED`; separately, a request phrased as
+  a general "run a penetration test" can be refused by the model platform under its cyber-content
+  policy before the agent's own gate is reached. That is a platform response the kit cannot suppress,
+  and users should know it rather than meet it as a surprise.
+
+### Not adopted (deliberately)
+
+- **A "Persona routing" section in `templates/org/rules/ai-working-agreement.md`.** It was written,
+  and then measurement removed the reason for it. The finding behind it (F-044) reported that three
+  org personas — `founder-prototype-agent`, `internal-tools-builder`, `staff-pm-reviewer` — are
+  never selected for work their own descriptions advertise, and that a generic `Explore` or
+  `general-purpose` agent takes it instead. That was measured 0/6, with the probe's standing
+  deviation of moving `.claude/rules` out of the workspace. Re-run with the rules left in place and
+  **no routing prose at all**, the same personas are selected 5/6. Persona routing is delivered *by*
+  the org rules, so the probe had been deleting the mechanism and then reporting the mechanism
+  missing. The prose was reverted: it addressed a defect that does not exist in a shipped install,
+  and adding payload to close a measurement artefact is the churn this work is supposed to prevent.
+  The harness bugs the exercise surfaced were kept and fixed (F-106 through F-108).
+
+- **Slimming the covenant rules and relocating their detail (Phase 2 of the design spec).** Would
+  reach ~78,700 standing context (rules ~8,000) — a further ~14k tokens. It requires rewriting four
+  large rules into contracts plus a new `references/` home, with scaffolder, validator and
+  upgrade-path work. Phase 1 already captures ~90% of the available reduction and is the difference
+  between exceeding a 200k window and fitting inside it; the rest is a separate release. The plan
+  stands in `docs/rules-context-budget.md`. **Update:** Phase 2's premise has since been measured
+  and does not hold. It rested on the covenant rules diluting each other (F-073) — but that
+  hypothesis was formed when 25 rules loaded and the prompt ran ~163k tokens. Re-taken at 7 rules,
+  the shipped arm is indistinguishable from the isolated one (severity labelled 5/5 vs 5/5; blocking
+  verdict 3/5 vs 4/5, Fisher one-sided p=0.50). The specificity control also showed
+  `severity_classified` never discriminated at all — 3/3 for a rule with no severity ladder — so
+  part of F-073's original evidence rested on a check that could not fail. Phase 2 is now a
+  token-cost optimisation with no measured behavioural defect behind it.
+
+- **Splitting `mandatory-workflow.md`.** At 25,307 B it is a third of the always-on budget and the
+  obvious first cut. It is not being cut: Phase 1 already removed the failure it would have
+  addressed (three scenarios that died with "Prompt is too long" now complete), and with no live
+  defect the split is churn against a 668-citation surface.
+
+- **Fixing the two SC-22 oracle defects found while measuring the specialist routing.** One check
+  flags an f-string in an *error message* as SQL injection, penalising a session for adding input
+  validation; the other demands a parameterised rewrite while also requiring the pristine tests —
+  which assert the un-parameterised return type — to keep passing, so no correct implementation can
+  pass the scenario. Both are recorded (F-096, F-097) and neither is touched here: SC-22 is sealed
+  by `task-bank-lock.json` and both were found *after* seeing candidate output. Editing a locked
+  oracle to fit the implementation is the one move the evaluation contract forbids outright; they
+  belong in a fresh pre-registered lock. **Update:** that fresh lock was authorised and taken, so
+  one of the two is now fixed and the other turned out not to exist. F-096's regex is replaced by
+  `caller_values_never_reach_the_sql_text`, which calls each helper twice with different caller
+  values (including `x' OR '1'='1`) and asserts the SQL *text* is identical across both and free of
+  the injected fragment — shape-agnostic, so it measures the security property however the solution
+  returns its query. F-097's premise was **wrong** and its proposed fix was reverted: both reference
+  solutions return `str` and satisfy the pristine tests, so the scenario was always passable and the
+  exclusions would have been unjustified holes. Re-locked with the two-sided proof re-run. Both
+  replicates now agree — injection check **passes**, contract check **fails** — because the
+  candidate's `(sql, params)` rewrite closes the injection but changes the return type, which
+  silently turns `assert "FROM orders" in orders_for_customer(7)` from a substring search into
+  element equality. A real regression, now legible instead of masked by a broken check.
+- **Scoping the covenant rules too.** Tried, measured, reverted. A path glob is a claim about *when*
+  a rule applies; for these seven the honest answer is "always", and globbing them silently exempts
+  docs-only, YAML-only and migration-only changes from gate and workflow discipline.
+- **Moving rule text out of `.claude/rules/` (Direction B).** Byte-identical moves look clean, but
+  they break ~668 citations and leave two homes for "rules" permanently.
+- **Putting every agent on `opus`.** The three-tier policy in `rules/model-tiers.md` is a cost
+  control, not an oversight; collapsing it would also leave that rule contradicting the payload.
+- **Rewording `pentest-scanner` so the platform stops refusing it.** Tuning wording until a safety
+  control stops firing is evading it, not fixing anything. The refusal is documented as the platform
+  behaviour it is; the agent's preflight gate, which is strict and correct, is left alone.
+- **Blocking low-entropy passwords in connection URIs** (`://svc:hunter2@db`). They are not
+  distinguishable from the `user:pass` placeholders that fill real compose files, CI configs and
+  docs; the false positives would cost more than the catch, and a guard people route around protects
+  nothing. The `secret-scanner` agent remains the deeper, non-blocking net for those.
+
+## [0.76.0] — 2026-08-01
+
+**The Trust Release — enforcement catches up with the promise.** The kit has always *claimed* that
+no gate passes without evidence; this release makes the deterministic state layer actually refuse
+the ways that claim could be quietly violated: gates closed out of order, evidence files swapped
+after the fact, snapshots corrupted mid-write, Mode E runs rejected by the very validator meant to
+protect them, and a learning-capture job that ran before anyone consented to it.
+
+### Added
+
+- **Gate ledger** (`claude-kit pipeline`): every `close-gate` now appends an entry to an append-only
+  `gate_history` in the pipeline snapshot — gate, status (`passed` / `skipped` / `overridden`),
+  evidence path **and its sha256**, a `verification` level (`agent` today; `mechanical` / `human`
+  reserved for the parser ladder in #74), and a UTC timestamp. `validate` re-hashes **every** ledger
+  entry, so tampering with an already-cited evidence file turns the run red.
+- **Gate-order enforcement.** `close-gate` derives the expected next gate from the profile's ordered
+  gate list and refuses out-of-order or already-recorded closes; `--force --override-reason` records
+  an honest `overridden` entry instead of a silent pass. The first recorded gate anchors anywhere in
+  the sequence, so adopting the ledger mid-run works.
+- **`pipeline skip-gate <gate> --reason`** — the honest path for conditional gates (e.g.
+  `contract-clear` on a stack with no API surface): recorded as `skipped` with the reason, never as
+  a fake pass.
+- **`--strict` for `pipeline validate` / `close-gate`** — a missing or unreadable install snapshot
+  fails closed instead of warning (for CI); the default stays lenient for back-compat.
+- **`claude-kit privacy-report`** — one line per installed hook: what it reads, what it writes,
+  whether it spawns a background job, whether learning capture is on, and how to turn it off.
+  Non-kit hook commands found in `settings.json` are flagged for the user's own review.
+- **Mode E** (`"mode": "E"`) is now accepted by the pipeline validator — it shipped in the
+  orchestrator in 0.58 but `pipeline.py` still rejected it. A drift-guard test now parses the mode
+  line out of `rules/continuity.md` and asserts it equals `pipeline.MODES`, so the two can't
+  diverge again.
+
+### Changed
+
+- **Learning capture is now opt-in** on every non-interactive path: the plugin manifest, the no-pip
+  starter `settings.json`, and `init --defaults` all install **no capture hooks**; `capture_mode`
+  defaults to `off`. The interactive `init` question *is* the consent — it still recommends
+  `session-end-catchup`. Recall (`load-learnings`, reading your own committed `agent-memory/`) is
+  unaffected and stays on. Documented in `SECURITY.md`.
+- **Snapshot writes are atomic and locked** — temp file + `os.replace` under an `O_EXCL` lockfile,
+  so a crash mid-`close-gate` can no longer leave a torn state file.
+- **Gates now resolve in execution order.** Fixed a real resolver bug the new order enforcement
+  uncovered: child profiles' gate lists were being union-merged behind the parent's, contradicting
+  the documented "execution-ordered" contract. `catalog/profiles.yaml` now documents the ordering
+  convention and the resolver preserves the child's declared order.
+- **Truth-in-advertising pass across every advertised surface.** The README headline now claims
+  exactly what ships ("every gate verdict must cite real command output, and the deterministic
+  state layer refuses to close a gate out of order or with unresolved findings"); "configuration
+  only" is spelled out (no app code in your repo, no daemon); the category line is now
+  **"Evidence-gated SDLC for Claude Code"** (plugin `displayName`: **Claude Kit SDLC**) across
+  plugin/marketplace manifests, PyPI metadata, `llms.txt`, and the CLI docstrings — the
+  `cookiecutter` search keywords stay. README hero restructured: proof (`examples/real-run/`)
+  before pitch, qualified install (`/plugin install claude-kit@claude-kit`), non-affiliation note
+  in the footer.
+- **Count drift fixed and pinned**: "28-agent roster" → 29 (README, `docs/agentic-patterns.md`),
+  both now anchored in `scripts/check_docs_consistency.py`; `docs/rules-context-budget.md`'s
+  numbers are annotated as the 2026-07-07 measurement snapshot; `docs/launch/posts.md` gains a
+  historical-snapshot banner.
+
+### Fixed (adversarial review of this release, pre-merge)
+
+A 6-lens adversarial review of the release branch (37 findings, every one reproduced live before
+being accepted) hardened the new surfaces before they shipped:
+
+- **Ledger integrity:** a `--force` re-record no longer poisons later `validate` runs (an
+  `overridden` entry is exempt from the monotonic-order check — it is the *documented* exception,
+  not tampering); the resume position is anchored at the **max** of all recorded gates so a forced
+  backfill can never rewind it; the snapshot lock now covers the whole read-modify-write (two
+  concurrent closes: one wins, one gets a clean refusal instead of silently overwriting), with a
+  60 s stale-lock steal so a crashed run can't wedge the pipeline; `close-gate` / `skip-gate`
+  refuse to record onto an **aborted** run; a skip records `verification: "agent"` (running the
+  CLI is not human attestation — `human` stays reserved for #74's explicit sign-off).
+- **Evidence portability:** evidence paths are resolved against the **project root** (never the
+  caller's CWD) and stored project-relative, so a different checkout location or a CI runner can
+  still re-hash the ledger; `validate` warns (not fails) on history entries from a different
+  profile's gate set.
+- **Gate order corrected:** `contract-clear` closes at the merge-review join (MR2) — **before**
+  test-coverage and security-clear, matching the orchestrator's Gate ↔ Stage map; the profile gate
+  lists and the ordered-resolution tests now pin the execution order exactly.
+- **Consent edges:** a non-TTY `init` (piped stdin / EOF) can never self-answer the capture
+  question into "on"; `capture_mode: on`/`true` in a config file is a hard error naming the real
+  modes (YAML 1.1 parses bare `on` as a boolean — a silent no-op before); `upgrade` prints a
+  notice when it preserves a pre-0.76 install's enabled capture; `privacy-report` matches hook
+  commands by exact basename (a look-alike script can no longer spoof an "OK" line).
+- **Wiring:** the orchestrator, the `/sdlc` skill, `rules/quality-gates.md` §2.5, and
+  `rules/continuity.md` now instruct agents to record verdicts **through the CLI ledger** when
+  `claude-kit` is on PATH — the enforcement layer is reachable from the pipeline that needs it,
+  not just from a human at a terminal.
+
+**Migration note (pre-0.76 installs):** upgrades never change your recorded `capture_mode` — a
+mode chosen (or defaulted) before 0.76.0 stays active and the upgrade says so; audit with
+`claude-kit privacy-report`, disable via `CLAUDE_KIT_NO_AUTOCAPTURE=1` or re-init. Existing
+pipeline snapshots without `gate_history` remain valid; the ledger starts recording from the next
+`close-gate`, anchoring wherever the run currently stands.
+
+### Not adopted (deliberately)
+
+- **Splitting the plugin into core/standard/enterprise packages.** Profiles already gate what a
+  given install receives; a package split would break the one-source-of-truth layout for a
+  distribution problem no user has reported. Revisit with adoption data.
+- **A config-file source of truth for pipeline modes.** A drift-guard test asserting
+  `rules/continuity.md` ≡ `pipeline.MODES` is cheaper than a third artifact both would then have to
+  agree with.
+- **Mechanical evidence parsing in this release** (JUnit/coverage/SARIF verdicts refusing a close).
+  Deliberately sequenced as the next release so this one stays reviewable; the ledger's
+  `verification` enum already reserves `mechanical` / `human` for it (issue #74).
+
 ## [0.75.0] — 2026-07-31
 
 **The Devil's Advocate learns to weigh, not only to prosecute — a premortem, a merits-and-costs

{claude_code_kit-0.75.0 → claude_code_kit-0.77.0}/CLAUDE.md

@@ -4,8 +4,9 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 # Developing claude-kit
 
-This repository **is** claude-kit — a Cookiecutter-style scaffolder that installs a stack-agnostic,
-autonomous-SDLC **configuration** (no application code, no Docker) into a Claude Code project. It is
+This repository **is** claude-kit — an evidence-gated SDLC for Claude Code: a scaffolder that
+installs a stack-agnostic, autonomous-SDLC **configuration** (no application code, no Docker) into
+a Claude Code project. It is
 distributed two ways from one source of truth:
 
 1. **As a Claude Code plugin** — components are auto-discovered from the repo root.
@@ -41,7 +42,7 @@ The kit's central data flow is **Selection → catalog.resolve() → ResolvedPla
 
 | Module | Role |
 |--------|------|
-| `cli.py` | Typer app — all CLI commands (`init`, `validate`, `doctor`, `diff`, `export`, `upgrade`, `pipeline`, `list-options`, `status`). Experimental/planned commands are hidden unless `CLAUDE_KIT_EXPERIMENTAL=1`. |
+| `cli.py` | Typer app — all CLI commands (`init`, `validate`, `doctor`, `diff`, `export`, `upgrade`, `pipeline`, `list-options`, `status`, `privacy-report`). Experimental/planned commands are hidden unless `CLAUDE_KIT_EXPERIMENTAL=1`. |
 | `models.py` | Dataclass contracts: `Selection`, `ResolvedPlan`, `OrgPlan`, `InitOptions`, `FileRecord`, `UpgradeJournal`. The typed seam between prompts → resolver → installer → upgrader. |
 | `catalog.py` | The resolver — converts a `Selection` into a `ResolvedPlan` by reading the catalog YAML files. Must stay branch-free. |
 | `prompts.py` | Interactive `init` question flow (stack, profile, MCP, org scope, …). |
@@ -51,7 +52,7 @@ The kit's central data flow is **Selection → catalog.resolve() → ResolvedPla
 | `upgrader.py` | Safe, edit-preserving upgrade: checksum comparison, transactional journal, sidecar fallback for user-edited files. |
 | `validator.py` | Structural validation of an installed config (`validate` + `--strict` mode). |
 | `schemas.py` | JSON Schema definitions for catalog integrity checks (`validate --strict`). |
-| `pipeline.py` | Deterministic `/sdlc` state-file ops (validate, status, close-gate, abort) — inspects the state files, does **not** run the pipeline. |
+| `pipeline.py` | Deterministic `/sdlc` state-file ops (validate, status, close-gate, skip-gate, abort) — owns the append-only `gate_history` ledger (order enforcement, evidence sha256, atomic locked writes); inspects/records state, does **not** run the pipeline. |
 | `export.py` | Projection into Cursor / AGENTS.md / Copilot formats. |
 | `detect.py` | Stack detection from a target repo (heuristic-based; non-blocking). |
 | `report.py` | Human-readable reporting for `doctor` and `status` commands. |
@@ -122,7 +123,7 @@ root are read directly by the plugin **and** bundled into the wheel (mapped to
 
 ## Dogfooding / local testing
 
-- **Plugin:** `claude` → `/plugin marketplace add .` → `/plugin install claude-kit` (loads the
+- **Plugin:** `claude` → `/plugin marketplace add .` → `/plugin install claude-kit@claude-kit` (loads the
   agents/skills/commands/hooks from this checkout).
 - **CLI:** `pip install -e '.[dev]'` then `claude-kit init /tmp/demo --defaults` (or interactive),
   `claude-kit validate /tmp/demo`, `claude-kit diff /tmp/demo`, and inspect the result.
@@ -137,7 +138,8 @@ root are read directly by the plugin **and** bundled into the wheel (mapped to
   shellcheck -S warning hooks/scripts/*.sh scripts/*.sh
   python scripts/gen_hooks.py --check          # hooks.json + settings.json drift
   python scripts/check_docs_consistency.py     # version parity + CHANGELOG heading
-  python scripts/check_cross_references.py     # rule/skill/agent refs in prose exist (warn-only)
+  python scripts/check_cross_references.py --strict    # rule/skill/agent refs in prose exist
+  python scripts/check_skill_descriptions.py --strict  # descriptions within the 250-char picker cap
   ```
 - **Stack-leakage guard:** `grep -rInE 'fastapi|sqlalchemy|alembic|docker' rules agents skills` — should
   be clean (balanced multi-framework *example* lists are acceptable; a real leak is agnostic logic
@@ -162,6 +164,8 @@ root are read directly by the plugin **and** bundled into the wheel (mapped to
 4. Build: `python3 -m build && python3 -m twine check dist/*`.
 5. Merge to `main` — CI auto-publishes to PyPI (OIDC trusted publishing). Manual `twine upload` is
    the fallback.
-6. Tag the release and push so plugin users get the update.
+6. Nothing to tag by hand — `publish.yml`'s `github-release` job creates the `vX.Y.Z` tag and the
+   GitHub Release on every successful publish (since 0.57.0). `scripts/backfill-releases.sh
+   --dry-run` is the recovery path if a published version is ever missing its tag.
 
 See `CONTRIBUTING.md` for the full contributor workflow.

{claude_code_kit-0.75.0 → claude_code_kit-0.77.0}/CONTRIBUTING.md

@@ -1,7 +1,8 @@
 # Contributing to claude-kit
 
 Thanks for helping improve claude-kit! This guide covers the repo conventions, how to test
-locally, and how to release.
+locally, and how to release. Participation is governed by our [Code of Conduct](CODE_OF_CONDUCT.md);
+security issues go through [SECURITY.md](SECURITY.md) rather than a public issue.
 
 ## Mental model
 
@@ -59,7 +60,7 @@ locally, and how to release.
 
 ```bash
 # Plugin (dogfood this checkout):
-#   in Claude Code:  /plugin marketplace add .   then   /plugin install claude-kit
+#   in Claude Code:  /plugin marketplace add .   then   /plugin install claude-kit@claude-kit
 
 # CLI:
 pip install -e '.[dev]'
@@ -77,6 +78,10 @@ mypy
 shellcheck -S warning hooks/scripts/*.sh scripts/*.sh
 python scripts/gen_hooks.py --check
 python scripts/check_docs_consistency.py
+python scripts/check_cross_references.py --strict
+python scripts/check_skill_descriptions.py --strict
+python scripts/check_rule_sizes.py
+python scripts/check_mcp_pins.py
 
 # Build + validate the package:
 python3 -m build
@@ -106,7 +111,13 @@ a specific stack — `pytest` enforces the no-Docker invariant on a scaffolded p
 3. `pytest` green, then `python3 -m build && python3 -m twine check dist/*`.
 4. CI auto-publishes to PyPI on merge to `main` when the version is new (`.github/workflows/publish.yml`,
    OIDC trusted publishing). Manual `python3 -m twine upload dist/*` is the fallback.
-5. Tag the release and push so plugin users get the update.
+5. The tag and GitHub Release are created for you — `publish.yml`'s `github-release` job does both on
+   every successful publish (since 0.57.0), so there is nothing to tag by hand. If a release ever
+   lands on PyPI without its tag, `scripts/backfill-releases.sh --dry-run` shows what is missing and
+   the same script without the flag creates it; it is idempotent, so re-running is safe.
+6. Publish the context-cost report for the release: run `claude plugin details claude-kit@claude-kit`
+   in Claude Code and paste the token/context figures into the release notes, so users can see what
+   the plugin costs their context window before installing.
 
 ## License
 

{claude_code_kit-0.75.0 → claude_code_kit-0.77.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.75.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.
+Version: 0.77.0
+Summary: Evidence-gated SDLC for Claude Code, installed as 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 with a tamper-evident gate ledger, 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
 Project-URL: Issues, https://github.com/ajyadav013/claude-kit/issues
@@ -35,13 +35,29 @@ Description-Content-Type: text/markdown
 
 # claude-kit
 
+### Evidence-gated SDLC for Claude Code
+
 **Turn Claude Code into a disciplined engineering team: one command — `/sdlc <task>` — runs your
 request through spec → review → code → test → security → PR, with a quality gate between every
 phase.**
 
-The differentiator is trust: **no gate passes without real, cited command output**, so a green
-result means the checks actually ran. It installs as **configuration only** — no runtime, no
-application code, no Docker.
+The differentiator is trust: **every gate verdict must cite real command output, and the
+deterministic state layer refuses to close a gate out of order or with unresolved
+Critical/High/Medium findings.** It installs as **configuration, not a runtime** — no application
+code in your repo and no daemon: Claude Code configuration, local hooks, and an optional CLI.
+
+</div>
+
+**Proof over pitch:** in the captured run in [`examples/real-run/`](examples/real-run/), a unanimous
+review PASS triggered the adversarial `devils-advocate` — it caught a Medium bug every reviewer had
+missed, and the gate refused to advance until the fix landed. The run is checked in verbatim: state
+file, agent verdicts, diff, asciicast.
+
+```text
+/plugin marketplace add ajyadav013/claude-kit
+/plugin install claude-kit@claude-kit
+/claude-kit:sdlc Add a /health endpoint that returns the build version
+```
 
 <!-- DEMO PLACEHOLDER — a 60–90s terminal capture of a gated `/sdlc` run belongs here once recorded.
      Shot list, timing, and which real assets to show: docs/launch/demo-script.md.
@@ -49,6 +65,8 @@ application code, no Docker.
      Medium bug a unanimous review missed, and the gate refusing to advance until it was fixed).
      Until the GIF exists, that folder IS the evidence — linked from "How it works" and "The pipeline" below. -->
 
+<div align="center">
+
 [![PyPI](https://img.shields.io/pypi/v/claude-code-kit.svg)](https://pypi.org/project/claude-code-kit/)
 [![Python](https://img.shields.io/pypi/pyversions/claude-code-kit.svg)](https://pypi.org/project/claude-code-kit/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
@@ -89,16 +107,13 @@ The fastest path to a gated run — **no CLI install, no `init`, no restart:**
 
 ```text
 /plugin marketplace add ajyadav013/claude-kit
-/plugin install claude-kit
+/plugin install claude-kit@claude-kit        # qualified name: the claude-kit plugin from the claude-kit marketplace
 /claude-kit:sdlc Add a /health endpoint that returns the build version
 ```
 
 That's the whole loop in three lines: the standard pipeline runs immediately — spec → review →
-build → test, gate by gate — with every verdict backed by real output.
-
-**Proof it works:** [`examples/real-run/`](examples/real-run/) is a genuine captured run where the
-`devils-advocate` caught a Medium bug a unanimous review missed, and the gate refused to advance
-until it was fixed.
+build → test, gate by gate — with every verdict backed by real output. (The proof run lives in
+[`examples/real-run/`](examples/real-run/) — see the top of this page.)
 
 When you want the pipeline tuned to *your* repo — your stack, commands, rigor profile, and the
 safety hooks — run `init`:
@@ -148,7 +163,7 @@ claude-kit init --defaults      # non-interactive: React + Python/FastAPI + Post
 | 🤖 **Agent roster** | **29** tiered agents led by an Orchestrator that never writes code, plus per-database overlay agents and 6 org personas ([full roster](docs/agents.md)) |
 | 📐 **Rules & skills** | **25** stack-agnostic core rules + **115** context-activated skills (58 core + 57 stack-collection), pulled into context on demand |
 | 🧱 **Stacks & overlays** | A stack-agnostic core + **13** overlay rule files (React · FastAPI · Go · Postgres · Mongo) wired to your exact commands and path-scoped to load only when you touch matching files |
-| 🛠️ **Hooks & guards** | **19** event hooks — deterministic safety guards and advisory warnings — that no-op gracefully without `jq` |
+| 🛠️ **Hooks & guards** | **20** event hooks — deterministic safety guards and advisory warnings — that no-op gracefully without `jq` |
 | 📊 **Traceability & live board** | A git-native ticket per story with a work-log and commit linkage, plus `claude-kit tickets` — a terminal chart and a browser Kanban board showing each lane's status, agent, model, tokens and elapsed time ([below](#parallel-lanes-and-the-live-ticket-board)) |
 | 📦 **Distribution & lifecycle** | Plugin **and** pip from one source, **24** ready MCP fragments (version-pinned), edit-preserving `upgrade`, and a root `AGENTS.md` at init so non-Claude agents share the same standards |
 
@@ -203,7 +218,7 @@ flowchart TD
 | Profile | Gates that run |
 |---|---|
 | **lean** | code-review · build-green |
-| **standard** | spec-complete · em-approved · code-review · build-green · test-coverage · security-clear · contract-clear\* |
+| **standard** | spec-complete · em-approved · code-review · build-green · contract-clear\* · test-coverage · security-clear |
 | **enterprise** | standard + pipeline-green · observability-ready · acceptance |
 
 \* `contract-clear` (API breaking-change diff) self-skips when the stack exposes no API surface.
@@ -373,7 +388,7 @@ Report vulnerabilities privately — see [`SECURITY.md`](SECURITY.md).
 |---|---|
 | [`docs/install.md`](docs/install.md) | Every install detail: prerequisites, Windows, plugin updates, all `init` questions, `init.yaml`, what lands on disk |
 | [`docs/cli.md`](docs/cli.md) | Full CLI command reference, safe-upgrade mechanics, troubleshooting |
-| [`docs/agents.md`](docs/agents.md) | How to drive the agents + the full 28-agent roster and per-run cost |
+| [`docs/agents.md`](docs/agents.md) | How to drive the agents + the full 29-agent roster and per-run cost |
 | [`docs/architecture.md`](docs/architecture.md) | Diagrams: distribution, catalog resolution, the state machine — and how to extend via the catalog |
 | [`docs/influences.md`](docs/influences.md) | The reuse-first adoption history: what we learned, shipped, and deliberately skipped |
 | [`docs/autonomous-operation.md`](docs/autonomous-operation.md) | Unattended runs: permission modes × autonomy levels, headless mode, the bounded loop script, CI-trigger design |
@@ -391,10 +406,12 @@ Report vulnerabilities privately — see [`SECURITY.md`](SECURITY.md).
 Issues and PRs welcome — see [`CONTRIBUTING.md`](CONTRIBUTING.md). To dogfood a local checkout:
 
 ```bash
-# As a plugin:  /plugin marketplace add .   then   /plugin install claude-kit
+# As a plugin:  /plugin marketplace add .   then   /plugin install claude-kit@claude-kit
 # As the CLI:   pip install -e '.[dev]'   then   claude-kit init /tmp/demo --defaults   &&   pytest
 ```
 
 ## License
 
 [MIT](LICENSE) © Arjunsingh Yadav
+
+claude-kit is an independent open-source project — not affiliated with or endorsed by Anthropic.