claude-code-kit 0.65.0__tar.gz → 0.66.0__tar.gz

{claude_code_kit-0.65.0 → claude_code_kit-0.66.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.65.0",
+      "version": "0.66.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.65.0",
+  "version": "0.66.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.65.0 → claude_code_kit-0.66.0}/CHANGELOG.md

@@ -4,6 +4,80 @@ 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.66.0] — 2026-07-23
+
+**Memory-subsystem absorption pass from [basic-memory](https://github.com/basicmachines-co/basic-memory)
+(user-named source; AGPL-3.0 — ideas absorbed in our own words, zero code or prose copied).** A
+118-agent extract→verify→refute workflow mapped 36 candidate disciplines against the kit's live
+memory subsystem (10 already covered, 18 killed adversarially, 8 survived) and a final by-hand
+re-verification adopted **five** — all enrichments of existing files: **0 new agents, skills,
+rules, or hooks; component counts unchanged.**
+
+### Fixed
+- **Canonical learning shape — `rules/agent-memory.md` format drift.** The rule's file-format block
+  had drifted from the shape the other three capture paths write and expect (`skills/remember`,
+  `skills/consolidate-learnings`, `hooks/scripts/capture-learnings.sh`): it omitted the `trigger:`
+  frontmatter field and ended with `## Recommendation` instead of `## Apply when`. All four
+  artifacts now agree on `{title, category, date, trigger}` + `Context / Learning / Evidence /
+  Apply when`, so retrieval hooks are never silently missing from rule-guided captures.
+
+### Added
+- **Repo-identity anchors in the resume snapshot** (`rules/continuity.md`,
+  `schemas/pipeline-snapshot.schema.json`, `templates/CONTINUITY.template.md`,
+  `agents/orchestrator.md`, `commands/abort.md`): optional `git` (branch / sha / per-lane
+  worktrees) and `pr` (number / url / state / base / head) objects in
+  `.claude/state/pipeline-snapshot.json`, populated **from commands, never from conversation
+  memory**, plus a `## Repo State` CONTINUITY section. On resume, the checkout's identity is
+  verified with a fresh `git rev-parse` **before** acting on snapshot state, and `/claude-kit:abort`
+  now treats `git.worktrees` as the authoritative list of what a run created instead of parsing
+  freeform CONTINUITY prose.
+- **`## Attempted & Ruled Out (this session)`** in the CONTINUITY template and protocol: dead-ends
+  (approach → why ruled out) are checkpoint content, read at turn start so a resumed session does
+  not re-propose an approach that already failed without new evidence.
+- **Optional reciprocal `## Related` links between memory entries** (`skills/remember`,
+  `rules/agent-memory.md`, `skills/consolidate-learnings`): when a capture touches, extends, or
+  contradicts a distinct existing entry, both files gain a one-line pointer; consolidation unions
+  Related lines into the canonical file and repoints links to merged-away siblings; editing or
+  removing an entry updates its inbound links. Entries stop being islands without any graph
+  runtime — the reader is the traversal engine.
+- **Advisory shape-check in `consolidate-learnings`**: the merge pass flags entries missing
+  `trigger:` or a body section, repairs them from the entry's own content where obvious, and
+  reports the rest — **never** deleting or skipping an entry for non-conformance (a lossy learning
+  beats no learning).
+
+### Changed
+- **The Promote step now proposes before writing** (`skills/consolidate-learnings`): graduating
+  learnings into `.claude/skills/` or `.claude/rules/` is a scope expansion under
+  `rules/human-in-the-loop.md` (project-wide files), so the cluster, target path, and
+  update-vs-create choice are presented for confirmation first, and the promoted artifact carries
+  provenance (source entry filenames + dates). Aligns the skill with the kit's own HITL rule.
+- `docs/influences.md`: added the basic-memory adoption row.
+
+### Not adopted (deliberately)
+- **A PreCompact checkpoint hook** — the discipline's real payload (the model flushing a semantic
+  resume checkpoint at the compaction boundary) is architecturally impossible for a shell hook: the
+  PreCompact event has no model turn and cannot inject context, so a port hollows out to a file
+  copy of state that is already on disk. The kit's existing coverage is the achievable part:
+  `rules/continuity.md` mandates write-early / pre-compaction insurance and the dual-probe
+  checkpoint standard, and `load-continuity.sh` reloads on `SessionStart:compact`.
+- **Typed relation graphs, forward references, permalinks, and `memory://` addressing** — load-bearing
+  only with basic-memory's runtime (SQLite index + MCP traversal tools); the kit has no consumer for
+  a relation *type*, and `supersedes` chains contradict the kit's edit-in-place doctrine (stale
+  entries are corrected or removed, not superseded-and-kept). The untyped reciprocal `## Related`
+  pointer is the fit-for-purpose subset (the reader is the consumer).
+- **Picoschema note validation, schema inference, and drift detection** — runtime CLI features; the
+  advisory shape-check absorbs the warn-only conformance idea without the machinery.
+- **A `basic_memory` MCP catalog entry** — the memory tool-job already has a fully wired native
+  provider (`rules/agent-memory.md` + `remember`/`consolidate-learnings` + the capture/load hooks,
+  all file-based by design); an MCP memory server would be a competing duplicate, and the catalog
+  doctrine rejects consumer-less servers (the Figma precedent).
+- **Per-section regeneration-ownership markers for mixed-authorship docs** — off-theme for this
+  pass and the kit's generated files are wholly generated (never mixed); the docs skills already
+  teach "edit the source, regenerate the output."
+- **Categorized inline observations, orientation briefs, recency-windowed recall, depth-limited
+  traversal, files-are-truth index rebuilds** — verified as already covered by the kit's category
+  folders, CONTINUITY protocol, MEMORY.md index injection, and trigger-based selective attachment.
+
 ## [0.65.0] — 2026-07-17
 
 **Catalog-additive OSS-adoption pass — one new MCP server that fills a documented, agent-mapped

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.65.0
+Version: 0.66.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.65.0 → claude_code_kit-0.66.0}/agents/orchestrator.md

@@ -48,7 +48,7 @@ subsets, so at Stage 0 derive this run's **active gate set** before dispatching
 
 **Read `.claude/CONTINUITY.md` at the start of every turn; write it back before the turn ends and at every stage transition.** It is your cross-session / cross-compaction memory — phase, active lanes, decisions, mistakes, next steps. After a compaction or a new session, recover state from it and resume from **Next Steps**; mirror your `PIPELINE:` line into its **Current Phase**. Durable lessons still go to `agent-memory/` via `remember`. See `.claude/rules/continuity.md`.
 
-Alongside the freeform file, maintain the **structured resume snapshot** `.claude/state/pipeline-snapshot.json` (schema in `.claude/rules/continuity.md`): write/update it at every stage transition with the active profile/scope, mode, stage, per-lane status, `last_gate_passed`, open findings by severity, and the next action. On resume, **reload it as context** — re-enter at the first gate *after* `last_gate_passed`, re-running only un-passed or defect-affected lanes; never re-run setup or re-apply edits already committed. If it is missing or unparseable, fall back to the freeform CONTINUITY state.
+Alongside the freeform file, maintain the **structured resume snapshot** `.claude/state/pipeline-snapshot.json` (schema in `.claude/rules/continuity.md`): write/update it at every stage transition with the active profile/scope, mode, stage, per-lane status, `last_gate_passed`, open findings by severity, the machine-derived repo identity (`git` branch/sha/worktrees and `pr` when one exists — from commands, never from conversation memory), and the next action. On resume, **reload it as context** — re-enter at the first gate *after* `last_gate_passed`, re-running only un-passed or defect-affected lanes; never re-run setup or re-apply edits already committed. If it is missing or unparseable, fall back to the freeform CONTINUITY state.
 
 Every agent you dispatch runs the **RARV** cycle (Reason → Act → Reflect → Verify) and must show a green Verify before its gate may pass (`.claude/rules/rarv-cycle.md`). Classify every finding by the **severity model** in `.claude/rules/quality-gates.md` — a gate is PASS only with zero Critical/High/Medium open.
 

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/commands/abort.md

@@ -12,7 +12,10 @@ did not create.
    **Active Tasks** and the orchestrator's `PIPELINE:` line to see which lanes/worktrees this run
    created. If no run is in progress, say so and stop.
 2. **List worktrees:** `git worktree list`. Identify **only** the worktrees this run created for its
-   lanes (the `developer` lanes use the Agent tool's `isolation: "worktree"`). **Never** remove a
+   lanes (the `developer` lanes use the Agent tool's `isolation: "worktree"`). When
+   `.claude/state/pipeline-snapshot.json` records a `git.worktrees` map, treat it as the
+   authoritative list of what this run created (cross-check each path against `git worktree list`);
+   fall back to the CONTINUITY prose only when the snapshot lacks it. **Never** remove a
    worktree this run did not create, and never the primary checkout.
 3. **Remove them:** `git worktree remove <path>` for each identified worktree. Unchanged worktrees are
    auto-cleaned by the Agent tool; this handles any that remain. Add `--force` **only** after telling

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/docs/influences.md

@@ -34,6 +34,7 @@ non-duplicative gaps**, minimally and catalog-wired.
 | **1,345-repo OSS adoption scan** (39 provenance-tagged searches across the AI/Claude/MCP/context ecosystem; 76 verified adoption ideas → 30-item backlog) | Agent-config supply-chain vetting + toxic-flow legs taxonomy; hidden-Unicode detection; content-type-aware **reversible** output compression (~200-token floor) + "think in code" (from Apache-2.0 `headroomlabs-ai/headroom` · `gsd-build/get-shit-done`; deterministic shell-side companion `rtk-ai/rtk`, referenced); symbol-first retrieval ladder (from MIT `oraios/serena` · `MinishLab/semble`); budget-visible statusline HUDs (`jarrodwatts/claude-hud`, referenced); tribal-standards elicitation (from `buildermethods/agent-os`); evidence-based test nagging + falsifiability eval discipline (from `maxritter/pilot-shell`); colocated skill evals (from `darkrishabh/agent-skills-eval`) | Waves across `dependency-verification` (vetting canon), `catalog/mcp.yaml` (+5 fragments → 22, all leg-annotated), `validator.py` (Unicode scan + INFO channel), **new `check_cross_references.py` CI gardener**, `context-engineering` (compression recipes · 5th primitive · retrieval ladder · budget visibility · pressure symptoms · tribal test), `tool-design`, `evals` §9–10 + `eval-harness`, `agent-guardrails` §3/§4, orchestrator VALIDATE, consolidate-learnings Promote, and ~10 more files — **0 new agents/skills, 1 new CI script** | `0.60.0`–`0.62.0` |
 | **Curated engineering-writing sweep** (a Medium "senior-engineer patterns" prompt → the freely-readable canon: Google SRE Book · AWS Builders' Library · Google API Design Guide & Eng Practices · Martin Fowler · Brendan Gregg · Dan McKinley · Sandi Metz · Stripe/Google idempotency & LRO · Dean/Norvig latency numbers) | Design-time CAP/PACELC + static-stability fallback sizing; error budgets as a release throttle; order-of-magnitude latency table; off-CPU/Amdahl/USL scalability; innovation-token budgeting; the wrong-abstraction cost; Parallel Change (expand→migrate→contract); cursor vs offset pagination; cache-stampede (single-flight + XFetch); DTO/storage decoupling + Idempotency-Key + long-running-operation API shapes; consumer-driven contract testing; "if you can't understand it, that's the finding" | Prose extensions to `resilience-engineering` & `devops-observability` rules + 9 skills (`_references/performance-checklist`, `load-testing`, `library-review`, `over-engineering-review`, `deprecation-and-migration`, `api-pagination-filtering-sorting`, `redis-caching-patterns`, `api-and-interface-design`, `testing-conventions`, `code-review-and-quality`, `notifications-and-messaging`) — **0 new agents/skills/rules; component counts unchanged** | `0.64.0` |
 | **866-repo AI/Claude/MCP scan** (catalog-additive angle — after five null *prose* passes, targeting the one adoption path with zero always-loaded-context cost: an opt-in `catalog/mcp.yaml` entry) | The metrics/dashboards/alerts side of observability the catalog lacked (`sentry` covers errors only) — maps to the `observability-engineer` + `incident-responder` agents' documented jobs, mirroring the `sentry`/`chrome-devtools` precedent | The **`grafana` MCP fragment** (official [grafana/mcp-grafana](https://github.com/grafana/mcp-grafana), Apache-2.0, read-only via `--disable-write`, pinned, referenced-not-bundled) — **0 new agents/skills/rules; 1 new catalog entry** (deliberately skipped: Figma — no agent consumer; the maintained Go `github-mcp-server` — deferred to its own change; Notion/Cloudflare — no agent / vendor sprawl; code-intel servers — already covered by serena+semble+repowise) | `0.65.0` |
+| **[basic-memory](https://github.com/basicmachines-co/basic-memory)** (AGPL-3.0 — *ideas absorbed in our own words, zero code/prose copied*; 36 candidate disciplines → 8 survived a 118-agent verify/refute pass → 5 adopted) | A checkpoint is a **resume cursor**: repo/PR identity proven by commands (never conversation memory) and dead-ends recorded so the next session doesn't re-suggest them; memory entries as a **connected store**, not islands; shape conformance as **advisory, never capture-blocking**; promotion to shared config as a **deliberate, confirmed gesture** | The canonical learning shape (fixed the `rules/agent-memory.md` format drift; all four capture paths now agree) + optional reciprocal `## Related` links (union/repoint on consolidation); `git`/`pr` **identity anchors** in `pipeline-snapshot` + a `Repo State` CONTINUITY section + verify-identity-on-resume; the `Attempted & Ruled Out` CONTINUITY section; an advisory shape-check in `consolidate-learnings`; the Promote step now **proposes before writing** (HITL scope-expansion row) with provenance — **0 new agents/skills/rules/hooks** | `0.66.0` |
 
 > Each adoption is detailed in the [CHANGELOG](../CHANGELOG.md) — including, for every review, what we
 > deliberately **did not** add because the kit already covered it.

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.65.0"
+version = "0.66.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.65.0 → claude_code_kit-0.66.0}/rules/agent-memory.md

@@ -58,27 +58,35 @@ Write to the appropriate category folder:
 | Performance | `performance/` | Optimization discoveries, bottleneck insights |
 | Gotchas & Pitfalls | `gotchas/` | Things that look right but aren't, common mistakes |
 
-File format:
+File format (canonical — the `remember` skill, the `capture-learnings` hook, and the
+`consolidate-learnings` skill all write/expect exactly this shape):
 ```markdown
 ---
 title: {{descriptive title}}
 category: {{category name}}
 date: {{YYYY-MM-DD}}
+trigger: {{when this applies — e.g. "designing any UI", "writing an HTTP endpoint"}}
 ---
 
 ## Context
 {{What situation led to this learning}}
 
 ## Learning
-{{The key insight — clear, specific, actionable}}
+{{The key insight — a clear, actionable directive: what to do (or avoid) and why}}
 
 ## Evidence
 {{How this was discovered — error messages, debugging steps, etc.}}
 
-## Recommendation
-{{What to do (or avoid) based on this learning}}
+## Apply when
+{{Concrete signal that this learning is relevant to the current task}}
+
+## Related   <!-- optional -->
+- [other entry](../category/file.md) — why it's connected
 ```
 
+Writing style: plain factual voice; state only what the evidence supports (and say how you know);
+match depth to the subject — a small remembered fact stays a few lines.
+
 ### Step 2: Update the index
 
 Add a one-line entry to `.claude/agent-memory/MEMORY.md` under the appropriate category:
@@ -97,8 +105,8 @@ you write to `architecture/` or `patterns/`, capture the **decision trace**, not
 - A memory that says *"we use X"* is weak; *"we chose X over Y because Z, see PR #123"* lets a future
   agent inherit the **judgment**, defend the decision, and know when it no longer applies.
 
-This is why the file template above leads with **Context** and ends with **Recommendation** — fill them
-with reasoning, not a restatement of the title.
+This is why the file template above leads with **Context** — fill it and **Learning** with reasoning,
+not a restatement of the title.
 
 > Source: "Context Graphs — building persistent memory for the agentic enterprise" (decision traces as
 > the system of record). Paraphrased for this kit.
@@ -111,4 +119,5 @@ Use lowercase kebab-case: `state-selector-infinite-loop.md`, `auth-token-refresh
 
 - Before writing, check if a similar memory already exists — update it instead of duplicating
 - If a memory becomes outdated (code changed, pattern no longer applies), remove or update it
+- When editing or removing an entry, update any entries whose `## Related` lines point to it
 - Keep MEMORY.md index concise — one line per entry, under 150 characters

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/rules/continuity.md

@@ -41,10 +41,19 @@ Schema (keep it small and truthful — omit a field rather than guess it):
   "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>" },
+  "git": { "branch": "<branch>", "sha": "<HEAD sha>", "worktrees": { "<lane>": "<path>" } },
+  "pr": { "number": "<n>", "url": "<url>", "state": "<open|merged|closed>", "base": "<base>", "head": "<head>" },
   "next": "<the immediate next action>"
 }
 ```
 
+The optional `git` / `pr` objects are the run's **machine-derived identity anchors** — populate them
+from commands (`git rev-parse --abbrev-ref HEAD`, `git rev-parse HEAD`, `git worktree list`, a
+read-only `gh pr view`), **never from conversation memory**; omit any field you cannot prove. On
+resume, compare `git.branch`/`git.sha` against a fresh `git rev-parse` **before touching anything** —
+a mismatch means the checkout moved since the snapshot; stop and verify rather than acting on stale
+state. (`abort` likewise treats `git.worktrees` as the authoritative list of what this run created.)
+
 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.
@@ -59,16 +68,20 @@ A gate is PASS only when zero **critical/high/medium** findings remain open (low
 
 **At the start of every turn / session / after compaction:**
 1. Read `.claude/CONTINUITY.md`.
-2. Read **Mistakes & Learnings** first — do not repeat past errors this session.
+2. Read **Mistakes & Learnings** and **Attempted & Ruled Out** first — do not repeat past errors,
+   and do not re-propose a ruled-out approach without new evidence.
 3. Check **Current Phase** and **Active Tasks**; resume from **Next Steps**.
 4. Treat every entry as *last-known* state, not current truth: before acting on a note that names a file, command, or gate result, confirm it still holds (the verify-before-trust checks in `.claude/rules/agent-memory.md`).
 
 **At the end of every turn, and at every pipeline stage transition:**
 1. Update **Current Phase** and **Active Tasks**.
 2. Move finished work to **Completed (this session)**.
-3. Append any new **Decisions Made** and **Mistakes & Learnings**.
+3. Append any new **Decisions Made** and **Mistakes & Learnings** — and record dead-ends in
+   **Attempted & Ruled Out** (approach → why ruled out): an approach that failed *this session* is
+   exactly what the next session will otherwise re-suggest.
 4. Rewrite **Next Steps** so the next turn can act with zero re-derivation.
-5. Update **Modified Files** and **Test/Build Status**.
+5. Update **Modified Files**, **Repo State** (from commands — `git rev-parse`, `git status` — never
+   from memory), and **Test/Build Status**.
 
 **Write CONTINUITY before** spawning or awaiting subagents, before a risky operation, and whenever context is getting long (pre-compaction insurance).
 
@@ -92,6 +105,9 @@ A gate is PASS only when zero **critical/high/medium** findings remain open (low
 ## Mistakes & Learnings
 - [what went wrong] -> [what we learned]  (promote durable ones to agent-memory)
 
+## Attempted & Ruled Out (this session)
+- [approach] — [why ruled out; do not re-propose without new evidence]
+
 ## Next Steps
 1. [immediate next action]
 2. [following action]
@@ -105,6 +121,10 @@ A gate is PASS only when zero **critical/high/medium** findings remain open (low
 ## Modified Files
 - [path] — [what changed]
 
+## Repo State (from commands, never from memory)
+- branch: [git rev-parse --abbrev-ref HEAD]   HEAD: [short sha]   dirty: [n files]
+- PR: [number/url/state, when one exists]
+
 ## Test/Build Status
 - [linter/formatter status]   [type checker status]   [test runner status]   [build status]
 ```

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/schemas/pipeline-snapshot.schema.json

@@ -46,6 +46,45 @@
         "string",
         "null"
       ]
+    },
+    "git": {
+      "type": "object",
+      "properties": {
+        "branch": {
+          "type": "string"
+        },
+        "sha": {
+          "type": "string"
+        },
+        "worktrees": {
+          "type": "object"
+        }
+      },
+      "additionalProperties": true
+    },
+    "pr": {
+      "type": "object",
+      "properties": {
+        "number": {
+          "type": [
+            "string",
+            "integer"
+          ]
+        },
+        "url": {
+          "type": "string"
+        },
+        "state": {
+          "type": "string"
+        },
+        "base": {
+          "type": "string"
+        },
+        "head": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": true
     }
   },
   "additionalProperties": true

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/skills/consolidate-learnings/SKILL.md

@@ -16,6 +16,11 @@ Keep the agent-memory knowledge base lean and non-redundant. This runs **periodi
 ### 1. Read the current state
 - Read `.claude/agent-memory/MEMORY.md`.
 - For each category folder (`ux/`, `architecture/`, `debugging/`, `patterns/`, `api/`, `performance/`, `gotchas/`), read every `*.md` learning file.
+- **Advisory shape check** (while reading): flag any entry missing the `trigger:` frontmatter or a
+  body section (`Context` / `Learning` / `Evidence` / `Apply when`). Repair from the entry's own
+  content where the fix is obvious (e.g. derive `trigger` from an existing `Apply when`); otherwise
+  list it in the step-7 report. **Never delete or skip an entry for non-conformance** — a lossy
+  learning beats no learning; the shape exists to make retrieval reliable, not to gate capture.
 
 ### 2. Group within each category
 Compare entries **within the same category** (cross-category merges are rare — only do them if a learning is clearly filed in the wrong category; then move it). Identify:
@@ -29,6 +34,8 @@ For each group of 2+ redundant entries, produce ONE canonical file:
 - Combine the `Learning` text so no nuance from any member is lost — union of the directives, deduplicated.
 - Keep the **earliest** `date` as the origin; optionally note "(consolidated YYYY-MM-DD)".
 - Concatenate distinct `Evidence` if it adds value; otherwise keep the strongest.
+- Union the members' `## Related` lines into the canonical file (dedup), and **repoint** any other
+  entry whose `## Related` line targets a merged-away sibling to the canonical file instead.
 - Write the merged content into the best-named existing file, then delete the now-redundant sibling files in that group.
 
 Preserve the standard entry format (frontmatter: `title`, `category`, `date`, `trigger`; body: `Context`, `Learning`, `Evidence`, `Apply when`).
@@ -56,6 +63,12 @@ After the merge pass, check each category for learnings that have outgrown the m
   `.claude/rules/` (for always-on constraints). Both are non-kit files, so `claude-kit upgrade`
   never touches them. Replace the graduated entries with ONE pointer line in `MEMORY.md`
   (`- promoted to .claude/skills/<domain>/ — <date>`), so the history of where they went survives.
+- **Propose before writing.** Promotion turns quietly-accumulated memory into always-on shared
+  config — a scope expansion under `.claude/rules/human-in-the-loop.md` (rules/skills are
+  project-wide files). Before creating or updating the artifact, present the cluster, the target
+  path, and the update-vs-create choice to the user, and proceed only on confirmation. Carry
+  provenance into the promoted artifact: name the source entries (filenames + dates) it was
+  distilled from, so its authority is traceable back to the evidence.
 - **Update-vs-create decision tree** (apply in order):
   1. An existing skill already covers the domain → **update it, never fork** a sibling.
   2. Partial overlap → **broaden the existing skill** to absorb the new procedure.

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/skills/remember/SKILL.md

@@ -43,7 +43,7 @@ If unsure, pick the closest fit; UX preferences go in `ux/`.
 
 ### 2. Check for an existing entry
 
-Read `.claude/agent-memory/MEMORY.md` and skim the relevant category folder. If a similar learning exists, **edit that file** (refine, add nuance, correct it) rather than creating a duplicate. While you're there, sanity-check that the existing entry is still accurate against the current code — if it has gone stale (a renamed file, a changed flag, behavior that no longer holds), fix or remove it rather than stacking a contradicting entry beside it (the verify-before-trust checks in `.claude/rules/agent-memory.md`).
+Read `.claude/agent-memory/MEMORY.md` and skim the relevant category folder. If a similar learning exists, **edit that file** (refine, add nuance, correct it) rather than creating a duplicate. While you're there, sanity-check that the existing entry is still accurate against the current code — if it has gone stale (a renamed file, a changed flag, behavior that no longer holds), fix or remove it rather than stacking a contradicting entry beside it (the verify-before-trust checks in `.claude/rules/agent-memory.md`). When the new learning **touches, extends, or contradicts** a distinct existing entry (rather than duplicating it), keep both — and add a reciprocal `## Related` line in each file so a future reader of either entry finds the other.
 
 ### 3. Write the learning file
 
@@ -68,9 +68,12 @@ trigger: {when this applies — e.g. "designing any UI", "writing an HTTP endpoi
 
 ## Apply when
 {Concrete signal that this learning is relevant to the current task}
+
+## Related   <!-- optional — only when a genuinely connected entry exists -->
+- [other entry](../category/filename.md) — why it's connected
 ```
 
-The `trigger` and `Apply when` fields matter most — they are how a future session knows to pull this learning before acting.
+The `trigger` and `Apply when` fields matter most — they are how a future session knows to pull this learning before acting. `## Related` is optional: link only entries that genuinely connect (extends, contradicts-then-resolved, same subsystem), so a reader of one finds the other without scanning the whole store.
 
 ### 4. Update the index
 

{claude_code_kit-0.65.0 → claude_code_kit-0.66.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.65.0"
+__version__ = "0.66.0"

{claude_code_kit-0.65.0 → claude_code_kit-0.66.0}/templates/CONTINUITY.template.md

@@ -19,6 +19,9 @@
 ## Mistakes & Learnings
 - [none]  (promote durable ones to agent-memory via the remember skill)
 
+## Attempted & Ruled Out (this session)
+- [none]  (approach — why ruled out; do not re-propose without new evidence)
+
 ## Next Steps
 1. [await next requirement]
 
@@ -31,5 +34,9 @@
 ## Modified Files
 - [none]
 
+## Repo State (from commands, never from memory)
+- branch: [unknown — run git to derive]   HEAD: [unknown]   dirty: [unknown]
+- PR: [none]
+
 ## Test/Build Status
 - backend: [unknown]   frontend: [unknown]