claude-code-kit 0.68.0__tar.gz → 0.69.0__tar.gz

{claude_code_kit-0.68.0 → claude_code_kit-0.69.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.68.0",
+      "version": "0.69.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.68.0 → claude_code_kit-0.69.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.68.0",
+  "version": "0.69.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.68.0 → claude_code_kit-0.69.0}/CHANGELOG.md

@@ -4,6 +4,74 @@ 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.69.0] — 2026-07-26
+
+**Absorption pass over [pborenstein/handoff](https://github.com/pborenstein/handoff) (user-named
+source; MIT, © 2026 Philip Borenstein) — session-continuity skills built around a hot-state /
+cold-storage split.** Ideas absorbed in the kit's own words with attribution; zero prose copied.
+All 18 repo files read; 7 candidate disciplines extracted and adversarially verified against the
+live kit (one verify agent per candidate, every verdict with file:line citations); 4 adopted,
+3 deliberately not. **0 new agents/skills/rules/hooks — every adoption is a prose/script extension
+of an existing surface.**
+
+### Added
+- **Size budget & rotation for working memory** (`rules/continuity.md` §"Size budget & rotation",
+  the CONTINUITY template header, and the `load-continuity.sh` messages): the live
+  `.claude/CONTINUITY.md` now carries a **write-side budget — ~8,000 bytes / ~150 lines, the size
+  the SessionStart hook injects uncut** — and a rotation protocol: when a phase completes (or the
+  file nears the budget), compress it to 3–5 lines and move the displaced detail to
+  `.claude/state/continuity-archive.md`, an append-only cold file in the already-gitignored
+  runtime-state dir that is never auto-injected. Previously the only size control was the hook's
+  read-side middle-trim, which silently cuts exactly the sections resume depends on (Decisions
+  Made, Mistakes & Learnings); this repo's own live file had reached ~94 KB (11.7× the cap) —
+  empirical proof the soft "keep it short" rule doesn't hold without a number and a destination.
+  The trim notice and the hook's closing instruction now point at the rotation protocol.
+- **Upstream-currency check on resume** (`rules/continuity.md`, resume-snapshot section): the
+  existing `git.sha` comparison catches a checkout that *moved*; the new check catches one that is
+  **behind** — `git fetch`, then `git rev-list --left-right --count @{upstream}...HEAD`. Behind →
+  reconcile (usually `git pull --rebase`) before trusting the snapshot; diverged → stop and
+  reconcile before planning new work; no upstream / offline → advisory note, never a hard stop.
+  Rationale: snapshot and CONTINUITY timestamps are self-reported and can look fresh while commits
+  landed out-of-band (another worktree, a teammate, CI).
+- **7-day staleness warning** (`hooks/scripts/load-continuity.sh` + a Protocol note in
+  `rules/continuity.md`): the SessionStart hook now checks the live file's mtime (GNU/BSD-portable
+  `stat`, degrading to a silent no-op on any failure) and prepends a warning when the file hasn't
+  been written in 7+ days — stale working memory is historical context to verify against
+  `git log`/`git status`, not a plan to resume. Two new behavioral tests pin the warning and its
+  absence on fresh files.
+- **Retroactive ADR backfill** (`skills/documentation-and-adrs` §"Retroactive Backfill", plus a
+  Guidelines pointer in `skills/decision`): the process half of what the kit's ADR template
+  already anticipated with its "Reconstructed from `<source>`" provenance line — mine git history
+  for decision points (`git log --grep` on decide/choose/instead/switch/migrate/refactor), group
+  the history into 3–6 eras, write only the 5–10 decisions that **still constrain the code**,
+  time-box the exercise to hours, and stop: no ADR-per-commit, and no invented rationale — a
+  back-filled ADR that guesses at *why* is worse than no ADR.
+
+### Not adopted (deliberately)
+- **Uninitialized-directory guard** (handoff's report → suggest-init → STOP before wrapup/pickup
+  work) — the kit prevents this failure mode *by construction* rather than by detection:
+  `load-continuity.sh` seeds the live file from the (plugin-bundled) template and no-ops when
+  none exists, and the CLI already fails with "run `claude-kit init`" in `validate`, `upgrade`,
+  and `status`. A prose detection guard would duplicate the seeding subsystem.
+- **Per-phase chronicle files** (`docs/chronicles/phase-N.md` with slim numbered entries) — every
+  chronicle field already has a typed home in the kit (gate-evidence artifacts, the sprint
+  archive, ADRs, the CHANGELOG discipline, agent-memory decision traces), and `doc-consolidation`'s
+  posture is the inverse: harvest run-generated markdown *into* canonical stores, then delete. A
+  chronicles tree would be a fifth, competing history store; its one legitimate fragment —
+  spillover run history — is absorbed by the new CONTINUITY cold archive instead.
+- **Meta-repo pattern** (`project-repo`: a coordinating repo with explicitly-gitignored member
+  dirs and shared meta-level docs) — the kit is a per-project scaffolder and explicitly treats
+  repo layout as an organizational choice outside its prescription surface
+  (`system-design-patterns`); multi-repo *changes* and *comprehension* already have homes
+  (`planning-and-task-breakdown` §cross-service, `context-engineering`), and org scope distributes
+  packs into each repo's own install. Different axis; not adopted.
+- **Committed tracking files** (handoff commits its CONTEXT/IMPLEMENTATION/DECISIONS files) — the
+  kit deliberately keeps CONTINUITY gitignored (high diff churn) and routes durable content to
+  committed `agent-memory/` and ADRs; adopting committed hot state would reverse a documented
+  design decision (`rules/continuity.md` §CONTINUITY vs. agent-memory).
+- **The 50-line figure itself** — the kit's budget derives from its own hook's 8,000-byte
+  injection cap, not an imported constant.
+
 ## [0.68.0] — 2026-07-24
 
 **Absorption pass over the [ashishps1](https://github.com/ashishps1) trilogy (user-named sources):

{claude_code_kit-0.68.0 → claude_code_kit-0.69.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.68.0
+Version: 0.69.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.68.0 → claude_code_kit-0.69.0}/docs/influences.md

@@ -37,6 +37,7 @@ non-duplicative gaps**, minimally and catalog-wired.
 | **[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` |
 | **[Technical-Engineering-Articles](https://github.com/harshit3011/Technical-Engineering-Articles)** (MIT list-repo indexing **46 public X threads by [@Harry_The_Nerd](https://x.com/Harry_The_Nerd)** — thread content © the author, *ideas absorbed in our own words, zero verbatim text*; 46/46 fetched → 614 candidate patterns through a 92-agent digest+verify pass with 3/3 fidelity spot-checks on every digest → global adversarial refute enforced the caps) | System-scale building blocks the kit never taught — rate-limiting algorithms, load balancing, fan-out, unique-ID generation, back-of-envelope estimation, microservice boundary criteria — and state-distribution mechanics (consistent hashing, quorum N/W/R, KV-store anatomy, storage engines); plus six confirmed gaps in existing skills, most notably that upload guidance routed bytes **through the API tier** while seven independent designs converge on presigned direct-to-storage | **2 new collection skills** (`system-design-patterns` · `distributed-systems-patterns`) + **6 capped SKILL.md extensions** (presigned uploads · beyond-cache Redis · event-backbone Kafka · DB concurrency control · HTTP caching & payload efficiency · authz models + OAuth delegation), 43 attributed `htn-` digests in owning skills' `references/`, and the 46-row [`docs/system-design-threads.md`](system-design-threads.md) coverage map (3 threads deliberately not absorbed) | `0.67.0` |
 | **The [ashishps1](https://github.com/ashishps1) trilogy** — [awesome-low-level-design](https://github.com/ashishps1/awesome-low-level-design) (GPL-3.0) · [awesome-system-design-resources](https://github.com/ashishps1/awesome-system-design-resources) (GPL-3.0) · [awesome-engineering-articles](https://github.com/ashishps1/awesome-engineering-articles) (MIT) by Ashish Pratap Singh (linked lessons © AlgoMaster.io, articles © their companies — *ideas absorbed in our own words, zero code and zero prose copied*; 596 items noted → 248 triaged deep → 221 fetched captures → **1,547 candidate patterns** through a 112-agent digest+verify pass → global refute in the main loop enforced the caps) | The class-level design layer the kit lacked entirely (OOP pillars as decisions, class relationships, SOLID-as-heuristics, GoF selection pressure, UML-as-communication, concurrency-primitive vocabulary); system-level gaps around the request path (proxy/gateway/DNS/service discovery), realtime transport selection, datastore choice, distributed locking with fencing tokens, batch-vs-stream, and consensus (a 0.67.0 pointer promised it, nothing taught it); plus a five-source convergence on shadow-read verification before migration cutover | **1 new collection skill** (`object-oriented-design`, 94 digests) + **6 capped SDP/DSP changes** (SDP §Edge and traffic path · §Realtime transport · §Choosing the datastore; DSP §Distributed locking and fencing · §Batch vs stream processing · consensus ¶ in §Replication and quorum) + **1 convergence-justified extension** (`deprecation-and-migration` §Shadow Verification Before Cutover), 215 attributed `alld-`/`asdr-`/`aea-` digests across 13 skills' `references/`, and three coverage maps — [`docs/lld-catalog.md`](lld-catalog.md) (113 rows) · [`docs/system-design-resources.md`](system-design-resources.md) (140 rows) · [`docs/engineering-articles.md`](engineering-articles.md) (343 rows) | `0.68.0` |
+| **[pborenstein/handoff](https://github.com/pborenstein/handoff)** (MIT, © 2026 Philip Borenstein — *ideas absorbed in our own words, zero prose copied*; all 18 files read → 7 candidate disciplines → a 7-agent adversarial verify pass with file:line citations → 4 adopted, 3 deliberately not) | Hot state needs a **write-side** budget, not just a read-side trim — the kit’s own live CONTINUITY.md had grown to ~94 KB and was being lossily middle-trimmed at every session start; a checkout can be **behind** its upstream while tracking files look fresh (self-reported timestamps prove nothing); file **age** is a resume signal of its own; and ADR backfill is the missing process half for codebases that predate tracking | The **size budget & rotation** protocol in `rules/continuity.md` (~8 KB hot file; cold archive at `.claude/state/continuity-archive.md`) + the budget in the CONTINUITY template + rotation pointers in the `load-continuity` hook; the **upstream-currency check** (fetch + behind/diverged) and the 7-day **staleness warning** in the resume protocol; the **Retroactive Backfill** section in `documentation-and-adrs` (+ a pointer from `decision`) — **0 new agents/skills/rules/hooks** (not adopted: uninit-guard = guard-by-construction; chronicles = competing history store; meta-repo = different axis) | `0.69.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.68.0 → claude_code_kit-0.69.0}/hooks/scripts/load-continuity.sh

@@ -27,8 +27,19 @@ fi
 
 [ -f "$LIVE" ] || exit 0
 
+# Staleness check: a live file untouched for 7+ days is historical context, not a current plan.
+# Portable mtime: GNU stat first (-c fails on BSD/darwin), BSD stat as fallback; any failure or
+# non-numeric result degrades to "fresh" (no warning) -- advisory only, never a hard failure.
+NOW=$(date +%s 2>/dev/null || echo 0)
+MTIME=$(stat -c %Y "$LIVE" 2>/dev/null || stat -f %m "$LIVE" 2>/dev/null || echo "")
+case "$MTIME" in *[!0-9]* | "") MTIME=$NOW ;; esac
+AGE_DAYS=$(((NOW - MTIME) / 86400))
+
 echo "## Working memory (.claude/CONTINUITY.md) -- read before acting; write back before the turn ends:"
 echo
+if [ "$AGE_DAYS" -ge 7 ]; then
+  printf '> WARNING: CONTINUITY.md was last written %s days ago -- treat it as historical context. Verify against git log/git status (and upstream currency) before resuming from its Next Steps.\n\n' "$AGE_DAYS"
+fi
 
 # Bound the injected size. This file is dumped into context on EVERY session start, and a mature
 # CONTINUITY.md can grow to tens of KB. Cap it to a digest that keeps BOTH ends -- the top
@@ -43,10 +54,10 @@ if [ "$SIZE" -le "$CAP" ]; then
   cat "$LIVE"
 else
   head -c 5500 "$LIVE"
-  printf '\n\n...[middle of CONTINUITY.md trimmed to save context -- %s bytes total; open .claude/CONTINUITY.md for the full working memory]...\n\n' "$SIZE"
+  printf '\n\n...[middle of CONTINUITY.md trimmed to save context -- %s bytes total, over the %s-byte budget; open .claude/CONTINUITY.md for the full working memory, then rotate completed detail to .claude/state/continuity-archive.md per .claude/rules/continuity.md]...\n\n' "$SIZE" "$CAP"
   tail -c 2000 "$LIVE"
 fi
 echo
-echo "Resume from \"Next Steps\". If you change phase or finish work, update CONTINUITY.md before ending the turn. Promote durable lessons to .claude/agent-memory/ via the remember skill."
+echo "Resume from \"Next Steps\". If you change phase or finish work, update CONTINUITY.md before ending the turn. Keep the live file under ~8,000 bytes -- rotate completed-phase detail to .claude/state/continuity-archive.md. Promote durable lessons to .claude/agent-memory/ via the remember skill."
 
 exit 0

{claude_code_kit-0.68.0 → claude_code_kit-0.69.0}/pyproject.toml

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

@@ -54,6 +54,18 @@ resume, compare `git.branch`/`git.sha` against a fresh `git rev-parse` **before
 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.)
 
+The sha comparison catches a checkout that *moved*; it cannot catch one that is **behind**. Snapshot
+and CONTINUITY timestamps are self-reported — they can look fresh while commits have landed
+out-of-band (another worktree, a teammate, CI). So on resume also verify **upstream currency**:
+`git fetch`, then `git rev-list --left-right --count @{upstream}...HEAD` (left = commits behind,
+right = ahead). **Behind** → the snapshot may describe state the remote has since changed;
+reconcile (usually `git pull --rebase`) before trusting it. **Diverged** (both sides > 0) → stop
+and reconcile before planning any new work on that tip. No upstream configured, or the fetch fails
+offline → note it and continue; the check is advisory, never a hard stop. (Currency and staleness
+checks adapted, in the kit's own terms, from the MIT-licensed
+[`pborenstein/handoff`](https://github.com/pborenstein/handoff) `session-pickup` skill,
+© 2026 Philip Borenstein.)
+
 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.
@@ -73,6 +85,10 @@ A gate is PASS only when zero **critical/high/medium** findings remain open (low
 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`).
 
+The `load-continuity.sh` hook warns when the live file hasn't been written for 7+ days. Treat such
+state as **historical context**, not a current plan: verify it against `git log` / `git status`
+(and the upstream-currency check above) before resuming from its **Next Steps**.
+
 **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)**.
@@ -85,6 +101,32 @@ A gate is PASS only when zero **critical/high/medium** findings remain open (low
 
 **Write CONTINUITY before** spawning or awaiting subagents, before a risky operation, and whenever context is getting long (pre-compaction insurance).
 
+## Size budget & rotation (hot state vs. cold archive)
+
+`CONTINUITY.md` is **hot state**, and hot state has a hard budget: keep the live file under
+**~8,000 bytes (~150 lines)** — the size the `load-continuity.sh` SessionStart hook injects
+**uncut**. Past that, the hook still fires but trims the *middle* of the file out of the
+injection — and the middle is where **Decisions Made** and **Mistakes & Learnings** sit, so an
+over-budget file silently mutilates exactly the sections resume depends on. The read-side trim is
+the safety net, not the mechanism. The mechanism is writing small.
+
+When a phase completes — or the file nears the budget — **rotate, don't let the hook trim**:
+
+1. Compress the finished phase to 3–5 lines under **Completed (this session)**: outcome, key
+   decisions by one-line reference, where the evidence lives (artifact path / commit / PR).
+2. Move the displaced detail to `.claude/state/continuity-archive.md` — an **append-only cold
+   file** in the gitignored runtime-state dir the hook already ensures exists. It is never
+   injected into context; open it on demand when an archived detail is actually needed.
+3. The archive is spillover for *run history only* — durable lessons still promote to
+   `agent-memory/` (Rule 4), decisions of record still become ADRs, and neither store is
+   duplicated into it.
+
+The test, after rotating: the live file alone still passes both probes below. If the next session
+would need the archive just to answer "where am I," you rotated too much. (Hot/cold rotation
+adapted, in the kit's own terms, from the MIT-licensed
+[`pborenstein/handoff`](https://github.com/pborenstein/handoff) `project-tracking` skill,
+© 2026 Philip Borenstein.)
+
 ## Template
 
 ```markdown
@@ -158,7 +200,7 @@ the MIT-licensed [`athola/claude-night-market`](https://github.com/athola/claude
 
 ## Rules
 
-1. **Keep it short.** Working memory, not a transcript. Overwrite stale content; do not append endlessly.
+1. **Keep it short.** Working memory, not a transcript. Overwrite stale content; do not append endlessly — stay under the size budget above and rotate completed detail to the archive.
 2. **Truthful state only.** If tests are failing, say so. CONTINUITY must never claim green when it isn't.
 3. **Orchestrator owns the phase line.** Mirror the `PIPELINE:` state line into **Current Phase**.
 4. **Promote, don't hoard.** Durable lessons go to `agent-memory/` via `remember`; CONTINUITY keeps only what this run needs.

{claude_code_kit-0.68.0 → claude_code_kit-0.69.0}/skills/decision/SKILL.md

@@ -44,3 +44,4 @@ Record an architecture decision as an ADR. The user will describe the decision a
 - If a decision supersedes a previous ADR, update the old ADR's status to `Superseded by [NNNN]`
 - Don't create ADRs for trivial decisions (library version bumps, minor refactors, bug fixes)
 - When unsure whether something deserves an ADR, err on the side of recording it — it's easier to delete than to reconstruct rationale later
+- For an existing codebase with no recorded decisions, backfill in batch first — see "Retroactive Backfill" in the `documentation-and-adrs` skill; the template's "Reconstructed from" line marks back-filled ADRs

{claude_code_kit-0.68.0 → claude_code_kit-0.69.0}/skills/documentation-and-adrs/SKILL.md

@@ -89,6 +89,31 @@ PROPOSED → ACCEPTED → (SUPERSEDED or DEPRECATED)
 - **Don't delete old ADRs.** They capture historical context.
 - When a decision changes, write a new ADR that references and supersedes the old one.
 
+### Retroactive Backfill (existing codebases)
+
+An established codebase full of unrecorded decisions doesn't need a historian — it needs the
+handful of decisions that **still bind today**. Time-box the whole exercise to a few hours:
+
+1. **Mine the history for decision points:**
+
+   ```bash
+   git log --all --oneline --grep="decide\|choose\|instead\|switch\|migrate\|refactor"
+   git log --reverse --format="%ad %s" --date=short | head    # project timeline, oldest first
+   ```
+
+2. **Sketch the eras.** Group the history into 3–6 phases around major milestones (rewrites,
+   version releases, architecture pivots). Phase boundaries are where decisions cluster.
+3. **Write only the decisions that still constrain the code** — aim for 5–10 ADRs, not fifty.
+   Mark each `Accepted`, and keep the "Reconstructed from `<source>`" provenance line from the
+   ADR template so readers know it was back-filled, not contemporaneous.
+4. **Stop.** Don't document every commit, and don't invent rationale you can't evidence from
+   commits, code, or people — a back-filled ADR that guesses at *why* is worse than no ADR.
+   From here forward, record decisions as they're made.
+
+(Backfill process adapted, in this kit's terms, from the MIT-licensed
+[`pborenstein/handoff`](https://github.com/pborenstein/handoff) `project-tracking` skill,
+© 2026 Philip Borenstein.)
+
 ## Inline Documentation
 
 ### When to Comment

{claude_code_kit-0.68.0 → claude_code_kit-0.69.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.68.0"
+__version__ = "0.69.0"

{claude_code_kit-0.68.0 → claude_code_kit-0.69.0}/templates/CONTINUITY.template.md

@@ -2,6 +2,9 @@
 
 > Seed template. The `load-continuity.sh` SessionStart hook copies this to `.claude/CONTINUITY.md`
 > (gitignored) on first run. Overwrite the sections below as work progresses — keep it short and truthful.
+> Budget: stay under ~8,000 bytes (~150 lines) — what the hook injects **uncut**. When a phase
+> completes, compress it here and move the detail to `.claude/state/continuity-archive.md`
+> (append-only cold storage, never auto-loaded).
 > Protocol: read at turn start, write at turn end. See `.claude/rules/continuity.md`.
 
 ## Current Phase