@ikon85/agent-workflow-kit 0.21.0 → 0.23.0

package/.agents/skills/setup-workflow/SKILL.md

@@ -26,6 +26,7 @@ This is a prompt-driven skill, not a deterministic script. Explore, present what
 | `## Agent skills` + `## Prod` in CLAUDE.md **and** AGENTS.md | one-line pointers + deploy target (Sections C/G + Write) |
 | `.github/workflows/agent-workflow-kit-update.yml` | optional tested Kit update pull request for GitHub consumers (Section A2) |
 | `docs/agents/census.md` | optional-census choice, paths, state, and safe disable contract seeded from [census.md](./census.md) (Section A3) |
+| `docs/agents/workflow-capabilities.json` + capability assets | consumer-owned Worktree Lifecycle activation and one-time Memory Lifecycle policy seeds (Sections A4–A5) |
 
 ## Idempotency contract — read before writing anything
 
@@ -56,6 +57,8 @@ Read the current state; don't assume. For every target file, read its first line
 - `CONTEXT.md`, `CONTEXT-MAP.md`, `docs/adr/` — domain-doc layout.
 - `docs/agents/`, `docs/agents/skills/`, `docs/conventions/` — prior output of this skill.
 - `docs/agents/census.md`, `.census/profile.json`, `.census/active.json` — an existing census choice or consumer-owned census to adopt.
+- `docs/agents/workflow-capabilities.json`, `.claude/settings.json` — existing capability choices/profile and Worktree Lifecycle hook wiring to adopt.
+- `.memory/active/`, `.memory/archive/`, and `.memory/receipts/` — consumer-owned Memory Lifecycle policies or recovery evidence to adopt without normalization.
 - `gh auth status` (if GitHub) — is `gh` authenticated, and with which scopes?
 
 ### 2. Section A — Issue tracker
@@ -135,6 +138,67 @@ activate without rerunning setup. Disable enforcement first, but retain every
 consumer-owned profile, scanner, test, and active snapshot unless the user
 separately approves deletion. Repeated runs are no-ops after reconciliation.
 
+### 2c. Section A4 — Optional Worktree Lifecycle
+
+> Worktree Lifecycle is one consumer capability for isolated setup, shared
+> branch/worktree facts, enforcement, handoff, and safe cleanup. The profile is
+> tracked and consumer-owned; hook wiring activates only after an explicit yes.
+
+Read [worktree-lifecycle.md](./worktree-lifecycle.md) in full. Reconcile the
+complete `yes / later / no / existing / disable` matrix from its structured
+contract. If no choice exists, ask: *"Should setup activate the portable
+Worktree Lifecycle for this repository?"* Offer exactly **Yes**, **Later**, and
+**No**.
+
+- **Yes** — create or deepen only the `worktreeLifecycle` section in
+  `docs/agents/workflow-capabilities.json`, preserve every other section and
+  unknown key, and reconcile only the exact kit-owned hook commands listed in
+  the seed.
+- **Later / No** — record the choice in the tracked profile without installing
+  hook wiring. Ordinary reruns do not ask again.
+- **Existing** — adopt the current section and wiring without normalizing
+  consumer-owned values.
+- **Disable** — remove only the exact kit-owned hook commands first, then set
+  `enabled: false`; retain the profile, setup policy, and unknown keys.
+
+The default setup entry is
+`python3 scripts/worktree-lifecycle/setup.py`; a proven consumer-native helper
+may remain the configured `setupEntry` for parity. The handoff advisory always
+reads that configured entry and never hardcodes a project script.
+
+### 2d. Section A5 — Optional Memory Lifecycle
+
+> Memory Lifecycle keeps project memories inside consumer-owned roots and makes
+> restore operations previewable, collision-safe, and reversible. The policy
+> templates become fully consumer-owned after their first seed.
+
+Read the `memoryLifecycle` section of
+`docs/agents/workflow-capabilities.json` before offering anything. Missing or
+disabled configuration remains unchanged on an ordinary setup rerun. An
+existing enabled section is adopted byte-for-byte; preserve unknown profile
+keys, placement/retention settings, restore grants, and consumer-specific memory
+rows.
+If no section exists, explain the capability and offer an explicit opt-in. Only
+an affirmative consumer decision may run:
+
+```bash
+node scripts/memory-lifecycle/setup.mjs --enable
+```
+
+That command adds the minimal enabled section while preserving every existing
+top-level profile key, sets restore and pruning approval to `false` unless the
+consumer already recorded values, and seeds
+`meta_decision_layer_choice.md` plus `meta_memory_lifecycle.md` into the
+configured active root exactly once. Existing files are adopted and never
+overwritten. The profile's `templatesSeeded` marker transfers full ownership:
+later setup runs do not recreate a template the consumer edited, moved, or
+deleted.
+Choosing later, declining, or merely running `init`, `update`, or ordinary
+`setup-workflow` performs no Memory Lifecycle write and never changes
+activation, roots, retention, restore, or pruning grants. Template files have
+no kit-managed or `append-managed` region; a future bounded-region contract
+requires a separate decision.
+
 ### 3. Section B — Triage labels
 
 > When `triage` processes an incoming issue it applies labels (or your tracker's equivalent). It needs strings you've actually configured, or it creates duplicates.
@@ -220,6 +284,17 @@ pre-existing consumer-owned census file. `yes`, `later`, `no`, and an adopted
 existing census are terminal for ordinary setup reruns. Only an explicit user
 request changes a recorded choice.
 
+For `docs/agents/workflow-capabilities.json`, reconcile only the selected
+capability section. Never replace the whole file: Project Release, Memory
+Lifecycle, Worktree Lifecycle, future sections, and unknown consumer keys share
+this profile. Apply the Worktree Lifecycle transition and hook ownership rules
+from [worktree-lifecycle.md](./worktree-lifecycle.md) transactionally.
+
+For Memory Lifecycle, use only the deterministic setup helper from Section A5.
+Do not copy templates with shell commands or edit the capability profile by
+hand. Report `seeded · adopted · skipped`; do not print memory contents or
+receipt contents.
+
 For the **`## Workflow`**, **`## Agent skills`**, and **`## Prod`** blocks, reconcile per section in **both** CLAUDE.md and AGENTS.md that exist:
 
 - If **both** files exist → write/update the block in **both** (keep them coherent — Codex is a first-class surface).

package/.agents/skills/setup-workflow/worktree-lifecycle.md

@@ -0,0 +1,81 @@
+# Worktree Lifecycle setup contract
+
+Worktree Lifecycle is one opt-in capability backed by the consumer-owned
+`docs/agents/workflow-capabilities.json` profile. Enabling it activates the
+portable setup entry, shared branch/worktree facts, thin hook adapters, handoff
+advisory, and safe cleanup policy as one unit.
+
+## Choice matrix
+
+| State | Setup action |
+|---|---|
+| `missing` | Ask `yes / later / no`; do not infer or write before the answer. |
+| `yes` | Reconcile the enabled profile and exact kit-owned hook commands. |
+| `later` | Record the retryable deferral; do not activate hooks. |
+| `no` | Record the opt-out; do not activate hooks. |
+| `existing` | Adopt the consumer profile byte-safely and preserve unknown keys. |
+| `disable` | Remove only kit-owned hook wiring, then set `enabled: false`; retain the profile and unknown keys. |
+
+```json worktree-lifecycle-setup-effects
+[
+  {
+    "state": "missing",
+    "choice": null,
+    "operations": []
+  },
+  {
+    "state": "yes",
+    "choice": "yes",
+    "operations": [
+      "record-choice",
+      "reconcile-profile-enabled",
+      "reconcile-hook-wiring"
+    ]
+  },
+  {
+    "state": "later",
+    "choice": "later",
+    "operations": [
+      "record-choice"
+    ]
+  },
+  {
+    "state": "no",
+    "choice": "no",
+    "operations": [
+      "record-choice"
+    ]
+  },
+  {
+    "state": "existing",
+    "choice": "yes",
+    "operations": [
+      "adopt-existing"
+    ]
+  },
+  {
+    "state": "disable",
+    "choice": "yes",
+    "operations": [
+      "remove-hook-wiring",
+      "update-profile-disabled"
+    ]
+  }
+]
+```
+
+## Hook ownership
+
+The exact kit-owned commands are:
+
+- SessionStart: `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/branch-context.py"`
+- UserPromptSubmit: `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/slice-handoff-hint.py"`
+- PostToolUse on Bash: `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/branch-watch.py"`
+- PreToolUse on Edit/Write/MultiEdit:
+  `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/enforce-worktree.py"`
+- PreToolUse on Bash:
+  `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/enforce-worktree-cwd.py"` and
+  `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/enforce-worktree-discipline.py"`
+
+Preserve unrelated settings, hook groups, profile sections, and unknown keys.
+Repeated reconciliation with the same choice is byte-identical.

package/.claude/hooks/slice-handoff-hint.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit adapter for configured Worktree Lifecycle handoffs."""
+
+import json
+import sys
+from pathlib import Path
+
+from _hook_utils import hook_event_output, load_worktree_lifecycle_core
+
+
+def main() -> int:
+    try:
+        payload = json.load(sys.stdin)
+        core = load_worktree_lifecycle_core()
+        profile = core.load_profile(Path("docs/agents/workflow-capabilities.json"))
+        decision = core.evaluate(profile, core.collect_facts(Path.cwd()), "handoff", payload)
+    except Exception:
+        return 0
+    if decision.action == "emit":
+        print(json.dumps(hook_event_output(decision.event_name, decision.message)))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.claude/skills/setup-workflow/SKILL.md

@@ -26,6 +26,7 @@ This is a prompt-driven skill, not a deterministic script. Explore, present what
 | `## Agent skills` + `## Prod` in CLAUDE.md **and** AGENTS.md | one-line pointers + deploy target (Sections C/G + Write) |
 | `.github/workflows/agent-workflow-kit-update.yml` | optional tested Kit update pull request for GitHub consumers (Section A2) |
 | `docs/agents/census.md` | optional-census choice, paths, state, and safe disable contract seeded from [census.md](./census.md) (Section A3) |
+| `docs/agents/workflow-capabilities.json` + capability assets | consumer-owned Worktree Lifecycle activation and one-time Memory Lifecycle policy seeds (Sections A4–A5) |
 
 ## Idempotency contract — read before writing anything
 
@@ -56,6 +57,8 @@ Read the current state; don't assume. For every target file, read its first line
 - `CONTEXT.md`, `CONTEXT-MAP.md`, `docs/adr/` — domain-doc layout.
 - `docs/agents/`, `docs/agents/skills/`, `docs/conventions/` — prior output of this skill.
 - `docs/agents/census.md`, `.census/profile.json`, `.census/active.json` — an existing census choice or consumer-owned census to adopt.
+- `docs/agents/workflow-capabilities.json`, `.claude/settings.json` — existing capability choices/profile and Worktree Lifecycle hook wiring to adopt.
+- `.memory/active/`, `.memory/archive/`, and `.memory/receipts/` — consumer-owned Memory Lifecycle policies or recovery evidence to adopt without normalization.
 - `gh auth status` (if GitHub) — is `gh` authenticated, and with which scopes?
 
 ### 2. Section A — Issue tracker
@@ -135,6 +138,67 @@ activate without rerunning setup. Disable enforcement first, but retain every
 consumer-owned profile, scanner, test, and active snapshot unless the user
 separately approves deletion. Repeated runs are no-ops after reconciliation.
 
+### 2c. Section A4 — Optional Worktree Lifecycle
+
+> Worktree Lifecycle is one consumer capability for isolated setup, shared
+> branch/worktree facts, enforcement, handoff, and safe cleanup. The profile is
+> tracked and consumer-owned; hook wiring activates only after an explicit yes.
+
+Read [worktree-lifecycle.md](./worktree-lifecycle.md) in full. Reconcile the
+complete `yes / later / no / existing / disable` matrix from its structured
+contract. If no choice exists, ask: *"Should setup activate the portable
+Worktree Lifecycle for this repository?"* Offer exactly **Yes**, **Later**, and
+**No**.
+
+- **Yes** — create or deepen only the `worktreeLifecycle` section in
+  `docs/agents/workflow-capabilities.json`, preserve every other section and
+  unknown key, and reconcile only the exact kit-owned hook commands listed in
+  the seed.
+- **Later / No** — record the choice in the tracked profile without installing
+  hook wiring. Ordinary reruns do not ask again.
+- **Existing** — adopt the current section and wiring without normalizing
+  consumer-owned values.
+- **Disable** — remove only the exact kit-owned hook commands first, then set
+  `enabled: false`; retain the profile, setup policy, and unknown keys.
+
+The default setup entry is
+`python3 scripts/worktree-lifecycle/setup.py`; a proven consumer-native helper
+may remain the configured `setupEntry` for parity. The handoff advisory always
+reads that configured entry and never hardcodes a project script.
+
+### 2d. Section A5 — Optional Memory Lifecycle
+
+> Memory Lifecycle keeps project memories inside consumer-owned roots and makes
+> restore operations previewable, collision-safe, and reversible. The policy
+> templates become fully consumer-owned after their first seed.
+
+Read the `memoryLifecycle` section of
+`docs/agents/workflow-capabilities.json` before offering anything. Missing or
+disabled configuration remains unchanged on an ordinary setup rerun. An
+existing enabled section is adopted byte-for-byte; preserve unknown profile
+keys, placement/retention settings, restore grants, and consumer-specific memory
+rows.
+If no section exists, explain the capability and offer an explicit opt-in. Only
+an affirmative consumer decision may run:
+
+```bash
+node scripts/memory-lifecycle/setup.mjs --enable
+```
+
+That command adds the minimal enabled section while preserving every existing
+top-level profile key, sets restore and pruning approval to `false` unless the
+consumer already recorded values, and seeds
+`meta_decision_layer_choice.md` plus `meta_memory_lifecycle.md` into the
+configured active root exactly once. Existing files are adopted and never
+overwritten. The profile's `templatesSeeded` marker transfers full ownership:
+later setup runs do not recreate a template the consumer edited, moved, or
+deleted.
+Choosing later, declining, or merely running `init`, `update`, or ordinary
+`setup-workflow` performs no Memory Lifecycle write and never changes
+activation, roots, retention, restore, or pruning grants. Template files have
+no kit-managed or `append-managed` region; a future bounded-region contract
+requires a separate decision.
+
 ### 3. Section B — Triage labels
 
 > When `triage` processes an incoming issue it applies labels (or your tracker's equivalent). It needs strings you've actually configured, or it creates duplicates.
@@ -220,6 +284,17 @@ pre-existing consumer-owned census file. `yes`, `later`, `no`, and an adopted
 existing census are terminal for ordinary setup reruns. Only an explicit user
 request changes a recorded choice.
 
+For `docs/agents/workflow-capabilities.json`, reconcile only the selected
+capability section. Never replace the whole file: Project Release, Memory
+Lifecycle, Worktree Lifecycle, future sections, and unknown consumer keys share
+this profile. Apply the Worktree Lifecycle transition and hook ownership rules
+from [worktree-lifecycle.md](./worktree-lifecycle.md) transactionally.
+
+For Memory Lifecycle, use only the deterministic setup helper from Section A5.
+Do not copy templates with shell commands or edit the capability profile by
+hand. Report `seeded · adopted · skipped`; do not print memory contents or
+receipt contents.
+
 For the **`## Workflow`**, **`## Agent skills`**, and **`## Prod`** blocks, reconcile per section in **both** CLAUDE.md and AGENTS.md that exist:
 
 - If **both** files exist → write/update the block in **both** (keep them coherent — Codex is a first-class surface).

package/.claude/skills/setup-workflow/worktree-lifecycle.md

@@ -0,0 +1,81 @@
+# Worktree Lifecycle setup contract
+
+Worktree Lifecycle is one opt-in capability backed by the consumer-owned
+`docs/agents/workflow-capabilities.json` profile. Enabling it activates the
+portable setup entry, shared branch/worktree facts, thin hook adapters, handoff
+advisory, and safe cleanup policy as one unit.
+
+## Choice matrix
+
+| State | Setup action |
+|---|---|
+| `missing` | Ask `yes / later / no`; do not infer or write before the answer. |
+| `yes` | Reconcile the enabled profile and exact kit-owned hook commands. |
+| `later` | Record the retryable deferral; do not activate hooks. |
+| `no` | Record the opt-out; do not activate hooks. |
+| `existing` | Adopt the consumer profile byte-safely and preserve unknown keys. |
+| `disable` | Remove only kit-owned hook wiring, then set `enabled: false`; retain the profile and unknown keys. |
+
+```json worktree-lifecycle-setup-effects
+[
+  {
+    "state": "missing",
+    "choice": null,
+    "operations": []
+  },
+  {
+    "state": "yes",
+    "choice": "yes",
+    "operations": [
+      "record-choice",
+      "reconcile-profile-enabled",
+      "reconcile-hook-wiring"
+    ]
+  },
+  {
+    "state": "later",
+    "choice": "later",
+    "operations": [
+      "record-choice"
+    ]
+  },
+  {
+    "state": "no",
+    "choice": "no",
+    "operations": [
+      "record-choice"
+    ]
+  },
+  {
+    "state": "existing",
+    "choice": "yes",
+    "operations": [
+      "adopt-existing"
+    ]
+  },
+  {
+    "state": "disable",
+    "choice": "yes",
+    "operations": [
+      "remove-hook-wiring",
+      "update-profile-disabled"
+    ]
+  }
+]
+```
+
+## Hook ownership
+
+The exact kit-owned commands are:
+
+- SessionStart: `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/branch-context.py"`
+- UserPromptSubmit: `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/slice-handoff-hint.py"`
+- PostToolUse on Bash: `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/branch-watch.py"`
+- PreToolUse on Edit/Write/MultiEdit:
+  `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/enforce-worktree.py"`
+- PreToolUse on Bash:
+  `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/enforce-worktree-cwd.py"` and
+  `python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/enforce-worktree-discipline.py"`
+
+Preserve unrelated settings, hook groups, profile sections, and unknown keys.
+Repeated reconciliation with the same choice is byte-identical.

package/README.md

@@ -332,6 +332,28 @@ still reference. Flags: `--force` (overwrite pre-existing files on `init`),
 
 ## Release notes
 
+### 0.23.0
+
+- added: `assets/memory-templates/meta_decision_layer_choice.md`
+- added: `assets/memory-templates/meta_memory_lifecycle.md`
+- added: `scripts/memory-lifecycle/setup.mjs`
+- changed: `.agents/skills/setup-workflow/SKILL.md`
+- changed: `.claude/skills/setup-workflow/SKILL.md`
+- changed: `scripts/memory-lifecycle/index.mjs`
+
+### 0.22.0
+
+- added: `.agents/skills/setup-workflow/worktree-lifecycle.md`
+- added: `.claude/hooks/slice-handoff-hint.py`
+- added: `.claude/skills/setup-workflow/worktree-lifecycle.md`
+- added: `scripts/worktree-lifecycle/cleanup.py`
+- changed: `.agents/skills/setup-workflow/SKILL.md`
+- changed: `.claude/skills/setup-workflow/SKILL.md`
+- changed: `scripts/worktree-lifecycle/README.md`
+- changed: `scripts/worktree-lifecycle/capabilities.json`
+- changed: `scripts/worktree-lifecycle/core.py`
+- changed: `scripts/wrapup-land.py`
+
 ### 0.21.0
 
 - added: `.agents/skills/project-release/SKILL.md`

package/agent-workflow-kit.package.json

@@ -1,5 +1,5 @@
 {
-  "kitVersion": "0.21.0",
+  "kitVersion": "0.23.0",
   "files": [
     {
       "path": ".agents/skills/ask-matt/SKILL.md",
@@ -573,7 +573,7 @@
       "kind": "skill",
       "ownerSkill": "setup-workflow",
       "surface": "codex",
-      "sha256": "91ba30cc08206204c83d189274579471366221ccfe8f2abdf36957ad85ae136b",
+      "sha256": "247250aa38a81b542600db42cfe4d02eecc1236e8af47df1f4def627f4df0668",
       "mode": 420,
       "origin": "kit"
     },
@@ -622,6 +622,15 @@
       "mode": 420,
       "origin": "kit"
     },
+    {
+      "path": ".agents/skills/setup-workflow/worktree-lifecycle.md",
+      "kind": "skill",
+      "ownerSkill": "setup-workflow",
+      "surface": "codex",
+      "sha256": "5e0914874f0b9f940205fbcfcfbba87d0c2df8f31db104d2c5328a0d20c80616",
+      "mode": 420,
+      "origin": "kit"
+    },
     {
       "path": ".agents/skills/spec-self-critique/scenarios.md",
       "kind": "skill",
@@ -921,6 +930,13 @@
       "mode": 493,
       "origin": "kit"
     },
+    {
+      "path": ".claude/hooks/slice-handoff-hint.py",
+      "kind": "hook",
+      "sha256": "664ca09a7e86c267ce7d49bf6b2529ebb9e75a4fd3443548f36f6eb9d4665abf",
+      "mode": 493,
+      "origin": "kit"
+    },
     {
       "path": ".claude/hooks/sync-board-status.py",
       "kind": "hook",
@@ -1626,7 +1642,7 @@
       "kind": "skill",
       "ownerSkill": "setup-workflow",
       "surface": "claude",
-      "sha256": "91ba30cc08206204c83d189274579471366221ccfe8f2abdf36957ad85ae136b",
+      "sha256": "247250aa38a81b542600db42cfe4d02eecc1236e8af47df1f4def627f4df0668",
       "mode": 420,
       "origin": "kit"
     },
@@ -1675,6 +1691,15 @@
       "mode": 420,
       "origin": "kit"
     },
+    {
+      "path": ".claude/skills/setup-workflow/worktree-lifecycle.md",
+      "kind": "skill",
+      "ownerSkill": "setup-workflow",
+      "surface": "claude",
+      "sha256": "5e0914874f0b9f940205fbcfcfbba87d0c2df8f31db104d2c5328a0d20c80616",
+      "mode": 420,
+      "origin": "kit"
+    },
     {
       "path": ".claude/skills/spec-self-critique/scenarios.md",
       "kind": "skill",
@@ -1945,6 +1970,20 @@
       "mode": 420,
       "origin": "kit"
     },
+    {
+      "path": "assets/memory-templates/meta_decision_layer_choice.md",
+      "kind": "template",
+      "sha256": "b22bd1d0e3daa31cbdbb9a3a81964d7a00d5275e69c92c9bd4ad3b4e40995b41",
+      "mode": 420,
+      "origin": "kit"
+    },
+    {
+      "path": "assets/memory-templates/meta_memory_lifecycle.md",
+      "kind": "template",
+      "sha256": "215e865d4e803ce0b2cd43e88d76501a61269dfa90aae5e6a474941a0b72b0ca",
+      "mode": 420,
+      "origin": "kit"
+    },
     {
       "path": "docs/agents/security-audit-runbook-template.md",
       "kind": "template",
@@ -2074,7 +2113,14 @@
     {
       "path": "scripts/memory-lifecycle/index.mjs",
       "kind": "script",
-      "sha256": "d83a71891e9c070179a00d6413b18d073061eef75e50919a7f28b8510f7ca20d",
+      "sha256": "871507e20133ccbb11f2a57f092bcb41aa1f6b7deaaa74df2418573316e6bd96",
+      "mode": 420,
+      "origin": "kit"
+    },
+    {
+      "path": "scripts/memory-lifecycle/setup.mjs",
+      "kind": "script",
+      "sha256": "c2c8885b806a830239ae54314c9dd0400399140870b6e62dc1e8b043dffcb78f",
       "mode": 420,
       "origin": "kit"
     },
@@ -2151,14 +2197,21 @@
     {
       "path": "scripts/worktree-lifecycle/capabilities.json",
       "kind": "doc",
-      "sha256": "3e51acaf2a8ac3ace0a400e23a30732ff0c3e9b4864f763c7abf82019605f309",
+      "sha256": "e80501bd86bbdb0ba296fc6b172442d8ad128f43e571777698657491279e4305",
       "mode": 420,
       "origin": "kit"
     },
+    {
+      "path": "scripts/worktree-lifecycle/cleanup.py",
+      "kind": "script",
+      "sha256": "370af8840732db3b6ba39b4825686f3980f69f612038123bc86b2c68921f02ca",
+      "mode": 493,
+      "origin": "kit"
+    },
     {
       "path": "scripts/worktree-lifecycle/core.py",
       "kind": "script",
-      "sha256": "36848a16ed7eaed1f731399efd2caf5771c9c5b48331771d6aedcbad2156e62a",
+      "sha256": "d54c4d663c234b7d2e607b99f6090b46104c21ba4326ef03bcb65de39d1cce19",
       "mode": 420,
       "origin": "kit"
     },
@@ -2172,7 +2225,7 @@
     {
       "path": "scripts/worktree-lifecycle/README.md",
       "kind": "doc",
-      "sha256": "59b78826308404497545b0a0ba57ff50f4618be2f6838f64e6a8c18bce83ea7f",
+      "sha256": "5dba0332253c37162ad1b2f1b7bf504a23af85bf297fdaa8920036f610ff754a",
       "mode": 420,
       "origin": "kit"
     },
@@ -2186,7 +2239,7 @@
     {
       "path": "scripts/wrapup-land.py",
       "kind": "script",
-      "sha256": "24ce9373c464cc8363c53b0c690c3231cbf11362e6e08336e0e97663579d1f19",
+      "sha256": "ee1f567e7be4f7baae222ed3974d39e5efee93edb2a663cacc8e18b567fa837e",
       "mode": 493,
       "origin": "kit"
     },

package/assets/memory-templates/meta_decision_layer_choice.md

@@ -0,0 +1,25 @@
+# Durable Knowledge Placement
+
+Use this consumer-owned policy to decide where a learning belongs. Edit the
+categories and examples to match this repository's terminology.
+
+## Placement layers
+
+- Repository instructions: stable rules that should guide every relevant task.
+- Workflow skill: repeatable procedure with a named entry point and verification.
+- Domain documentation: product language, boundaries, and durable decisions.
+- Local memory: contextual knowledge that helps future sessions but is not yet a
+  repository-wide rule.
+
+## Decision check
+
+Before retaining a learning, record:
+
+1. who needs it;
+2. when it should be loaded;
+3. what evidence would make it stale;
+4. which tracked layer is the narrowest durable owner.
+
+Prefer a tracked repository layer when the knowledge changes how work should be
+performed. Keep personal preferences and user-profile information outside
+project-owned memories unless the user explicitly places them here.

package/assets/memory-templates/meta_memory_lifecycle.md

@@ -0,0 +1,25 @@
+# Memory Lifecycle Policy
+
+This file is consumer-owned after its first seed. Edit roots, retention classes,
+and review cadence to match the repository. Kit updates must never overwrite it.
+
+## Retention classes
+
+- Active: still relevant to current work and safe to load.
+- Archive candidate: useful history that should leave the active set.
+- Protected: user-profile, preference, or other content that must not be pruned
+  by an automated repository workflow.
+
+## Archive and restore
+
+- Archive only inside the configured consumer-owned archive root.
+- Preview every action before mutation.
+- Restore only with an explicit restore grant.
+- Preserve the archive and refuse destination collisions.
+- Record path verdicts and hashes in a content-free, collision-safe receipt.
+
+## Pruning
+
+Pruning is never implied by setup, update, archive, or restore. It requires a
+separate preview and explicit user approval. A failed or interrupted operation
+must leave the last safe active and archived state recoverable.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikon85/agent-workflow-kit",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Portable AI-agent workflow skills (plan → execute → land → learn) for Claude Code & Codex — grilling, TDD, diagnosis, two-axis code review, cross-model Codex review, design & domain-modeling, plus a skill router (ask-matt). npx init/update/diff/uninstall.",
   "type": "module",
   "bin": {
@@ -21,6 +21,7 @@
     ".claude/",
     "!.claude/logs/",
     ".agents/",
+    "assets/",
     "scripts/",
     "docs/",
     "src/",

package/scripts/memory-lifecycle/index.mjs

@@ -10,6 +10,8 @@ import { createHash, randomUUID } from 'node:crypto';
 import { dirname, isAbsolute, normalize, relative, resolve, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 
+export { setupMemoryLifecycle } from './setup.mjs';
+
 async function exists(path) {
   try {
     return await lstat(path);

package/scripts/memory-lifecycle/setup.mjs

@@ -0,0 +1,167 @@
+import {
+  lstat,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
+import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
+
+const PROFILE_PATH = 'docs/agents/workflow-capabilities.json';
+const TEMPLATE_NAMES = [
+  'meta_decision_layer_choice.md',
+  'meta_memory_lifecycle.md',
+];
+
+function contained(root, path) {
+  if (isAbsolute(path)) return null;
+  const normalized = normalize(path);
+  if (normalized === '..' || normalized.startsWith(`..${sep}`)) return null;
+  const absolute = resolve(root, normalized);
+  return relative(resolve(root), absolute).split(sep)[0] === '..' ? null : absolute;
+}
+
+async function lstatIfPresent(path) {
+  try {
+    return await lstat(path);
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+async function hasSymlink(root, path) {
+  let current = resolve(root);
+  const segments = relative(current, path).split(sep).filter(Boolean);
+  for (const segment of segments) {
+    current = resolve(current, segment);
+    if ((await lstatIfPresent(current))?.isSymbolicLink()) return true;
+  }
+  return false;
+}
+
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+async function writeJsonAtomic(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const staged = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(staged, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
+    await rename(staged, path);
+  } finally {
+    await rm(staged, { force: true });
+  }
+}
+
+function defaultCapability() {
+  return {
+    enabled: true,
+    activeRoot: '.memory/active',
+    archiveRoot: '.memory/archive',
+    receiptRoot: '.memory/receipts',
+    approvals: { restore: false, prune: false },
+    memories: TEMPLATE_NAMES.map((path) => ({ path, enabled: true })),
+    templatesSeeded: true,
+  };
+}
+
+export async function setupMemoryLifecycle({
+  projectRoot = process.cwd(),
+  templateRoot = join(projectRoot, 'assets', 'memory-templates'),
+  decision,
+} = {}) {
+  const profilePath = resolve(projectRoot, PROFILE_PATH);
+  if (await hasSymlink(projectRoot, profilePath)) {
+    throw new Error('memoryLifecycle profile path contains a symlink');
+  }
+  const profile = await readJson(profilePath);
+  const existing = profile?.memoryLifecycle;
+
+  if (decision !== 'enable') {
+    return {
+      state: existing?.enabled ? 'enabled' : 'disabled',
+      seeded: [],
+      adopted: [],
+    };
+  }
+
+  const capability = {
+    ...defaultCapability(),
+    ...existing,
+    enabled: true,
+    approvals: {
+      restore: false,
+      prune: false,
+      ...existing?.approvals,
+    },
+    templatesSeeded: true,
+  };
+  const activeRoot = contained(projectRoot, capability.activeRoot);
+  if (!activeRoot) throw new Error('memoryLifecycle.activeRoot must stay inside the project');
+  if (await hasSymlink(projectRoot, activeRoot)) {
+    throw new Error('memoryLifecycle.activeRoot contains a symlink');
+  }
+
+  const shouldSeed = existing?.templatesSeeded !== true;
+  const sources = shouldSeed
+    ? await Promise.all(TEMPLATE_NAMES.map(async (name) => ({
+        name,
+        content: await readFile(join(templateRoot, name)),
+      })))
+    : [];
+  const seeded = [];
+  const adopted = [];
+  const destinations = sources.map(({ name, ...source }) => ({
+    ...source,
+    name,
+    destination: contained(activeRoot, name),
+  }));
+  for (const { destination } of destinations) {
+    if (await hasSymlink(activeRoot, destination)) {
+      throw new Error('memory policy destination contains a symlink');
+    }
+  }
+  for (const { content, destination } of destinations) {
+    await mkdir(dirname(destination), { recursive: true });
+    try {
+      await writeFile(destination, content, { flag: 'wx' });
+      seeded.push(relative(projectRoot, destination));
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      adopted.push(relative(projectRoot, destination));
+    }
+  }
+
+  await writeJsonAtomic(profilePath, {
+    schemaVersion: 1,
+    ...profile,
+    memoryLifecycle: capability,
+  });
+  return { state: 'enabled', seeded, adopted };
+}
+
+export const MEMORY_POLICY_TEMPLATES = Object.freeze([...TEMPLATE_NAMES]);
+
+async function main(argv) {
+  const result = await setupMemoryLifecycle({
+    decision: argv.includes('--enable') ? 'enable' : undefined,
+  });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+  main(process.argv.slice(2)).catch((error) => {
+    process.stderr.write(`${error.message}\n`);
+    process.exitCode = 1;
+  });
+}

package/scripts/test_worktree_wrapup_contract.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Wrapup must reuse the shipped Worktree Lifecycle cleanup assessment."""
+
+import importlib.util
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+REPO = Path(__file__).resolve().parent.parent
+WRAPUP = REPO / "scripts/wrapup-land.py"
+
+
+def load_wrapup():
+    spec = importlib.util.spec_from_file_location("wrapup_land_worktree_contract", WRAPUP)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+class WorktreeCleanupContract(unittest.TestCase):
+    def test_active_profile_delegates_removal_safety_to_shared_assessment(self):
+        wrapup = load_wrapup()
+        calls = []
+
+        class FakeCore:
+            @staticmethod
+            def load_profile(path):
+                calls.append(("profile", path))
+                return {"enabled": True}
+
+            @staticmethod
+            def cleanup_assessment(profile, main, target, merge_target=None):
+                calls.append(("assessment", main, target, merge_target))
+                return SimpleNamespace(reasons=("dirty worktree",), assumptions="reviewed")
+
+        with tempfile.TemporaryDirectory() as tmp:
+            main = Path(tmp)
+            profile = main / "docs/agents/workflow-capabilities.json"
+            profile.parent.mkdir(parents=True)
+            profile.write_text('{"worktreeLifecycle":{"enabled":true}}\n')
+            with patch.object(wrapup, "load_worktree_cleanup_core", return_value=FakeCore):
+                with self.assertRaises(wrapup.Stop) as stopped:
+                    wrapup.ensure_worktree_removable(str(main / "wt"), str(main))
+
+        self.assertIn("shared cleanup guard", stopped.exception.reason)
+        self.assertEqual(calls[1][-1], "origin/main")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/scripts/worktree-lifecycle/README.md

@@ -31,6 +31,14 @@ the core proves the target is unsafe.
 | `enforce-worktree.py` | PreToolUse | blocks tracked main-checkout edits and cross-worktree leaks |
 | `enforce-worktree-cwd.py` | PreToolUse | blocks verification or Git mutation in the wrong checkout |
 | `enforce-worktree-discipline.py` | PreToolUse | routes issue-branch creation through the configured setup entry |
+| `slice-handoff-hint.py` | UserPromptSubmit | names the configured setup entry for a defined slice |
+
+## Cleanup
+
+`cleanup.py` previews by default. Removal refuses protected, dirty, or unmerged
+worktrees. The assessment reads `ANNAHMEN.md` before removal and returns its
+contents for propagation. `wrapup-land.py` invokes this same assessment after a
+merge and before killing processes or removing the worktree.
 
 Claude hook wiring and any Codex adaptation consume this same profile and core.
 An adapter may change only the surface event envelope; it must preserve the

package/scripts/worktree-lifecycle/capabilities.json

@@ -3,34 +3,42 @@
   "capabilities": [
     {
       "historicalPath": "scripts/setup-worktree.sh",
+      "artifact": "scripts/worktree-lifecycle/setup.py",
       "primitives": ["profile", "git-facts", "transactional-setup"]
     },
     {
       "historicalPath": ".claude/hooks/branch-context.py",
+      "artifact": ".claude/hooks/branch-context.py",
       "primitives": ["profile", "git-facts", "hook-event-output"]
     },
     {
       "historicalPath": ".claude/hooks/branch-watch.py",
+      "artifact": ".claude/hooks/branch-watch.py",
       "primitives": ["profile", "git-facts", "hook-event-output"]
     },
     {
       "historicalPath": ".claude/hooks/enforce-worktree.py",
+      "artifact": ".claude/hooks/enforce-worktree.py",
       "primitives": ["profile", "git-facts", "worktree-decision"]
     },
     {
       "historicalPath": ".claude/hooks/enforce-worktree-cwd.py",
+      "artifact": ".claude/hooks/enforce-worktree-cwd.py",
       "primitives": ["profile", "git-facts", "worktree-decision"]
     },
     {
       "historicalPath": ".claude/hooks/enforce-worktree-discipline.py",
+      "artifact": ".claude/hooks/enforce-worktree-discipline.py",
       "primitives": ["profile", "git-facts", "worktree-decision"]
     },
     {
       "historicalPath": ".claude/hooks/slice-handoff-hint.py",
+      "artifact": ".claude/hooks/slice-handoff-hint.py",
       "primitives": ["profile", "git-facts", "hook-event-output"]
     },
     {
       "historicalPath": "scripts/cleanup-worktrees.sh",
+      "artifact": "scripts/worktree-lifecycle/cleanup.py",
       "primitives": ["profile", "git-facts", "cleanup-safety"]
     }
   ]

package/scripts/worktree-lifecycle/cleanup.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Preview or safely remove a profile-governed linked worktree."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from core import LifecycleError, cleanup_assessment, load_profile, main_worktree, run
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--profile", default="docs/agents/workflow-capabilities.json")
+    parser.add_argument("--remove", action="store_true")
+    parser.add_argument("worktree")
+    return parser.parse_args()
+
+
+def execute(args: argparse.Namespace) -> dict:
+    main = main_worktree(Path.cwd())
+    profile_path = Path(args.profile)
+    if not profile_path.is_absolute():
+        profile_path = main / profile_path
+    profile = load_profile(profile_path)
+    assessment = cleanup_assessment(profile, main, Path(args.worktree))
+    report = {
+        "worktree": str(assessment.worktree),
+        "branch": assessment.branch,
+        "removable": assessment.removable,
+        "reasons": list(assessment.reasons),
+        "assumptions": assessment.assumptions,
+        "removed": False,
+    }
+    if not args.remove:
+        return report
+    if not assessment.removable:
+        raise LifecycleError("; ".join(assessment.reasons))
+    run(["git", "worktree", "remove", str(assessment.worktree)], cwd=main)
+    run(["git", "branch", "-d", assessment.branch], cwd=main)
+    report["removed"] = True
+    return report
+
+
+def main() -> int:
+    try:
+        print(json.dumps(execute(parse_args()), ensure_ascii=False, indent=2))
+        return 0
+    except LifecycleError as error:
+        print(f"STOP: {error}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/worktree-lifecycle/core.py

@@ -38,6 +38,18 @@ class Decision:
     event_name: str = ""
 
 
+@dataclass(frozen=True)
+class CleanupAssessment:
+    worktree: Path
+    branch: str
+    assumptions: str
+    reasons: tuple[str, ...]
+
+    @property
+    def removable(self) -> bool:
+        return not self.reasons
+
+
 def collect_facts(cwd: Path) -> RepoFacts:
     root = Path(run(["git", "rev-parse", "--show-toplevel"], cwd=cwd).stdout.strip()).resolve()
     main = main_worktree(root)
@@ -104,6 +116,50 @@ def is_tracked(root: Path, relative: str) -> bool:
     return result.returncode == 0
 
 
+def cleanup_assessment(
+    profile: WorktreeProfile,
+    main: Path,
+    target: Path,
+    merge_target: str | None = None,
+) -> CleanupAssessment:
+    worktree = target.resolve()
+    reasons = []
+    branch = run(
+        ["git", "-C", str(worktree), "branch", "--show-current"],
+        cwd=main,
+        check=False,
+    ).stdout.strip()
+    if worktree not in registered_worktrees(main):
+        reasons.append("not a registered worktree")
+    if not branch:
+        reasons.append("detached or unreadable branch")
+    if branch in profile.protected_branches or worktree == main.resolve():
+        reasons.append(f"protected worktree branch: {branch or '<unknown>'}")
+    status = run(
+        ["git", "-C", str(worktree), "status", "--porcelain"],
+        cwd=main,
+        check=False,
+    ).stdout
+    if status.strip():
+        reasons.append("dirty worktree")
+    if branch and branch not in profile.protected_branches:
+        main_branch = merge_target or run(
+            ["git", "-C", str(main), "branch", "--show-current"],
+            cwd=main,
+            check=False,
+        ).stdout.strip()
+        merged = run(
+            ["git", "merge-base", "--is-ancestor", branch, main_branch],
+            cwd=main,
+            check=False,
+        )
+        if merged.returncode != 0:
+            reasons.append(f"unmerged branch: {branch}")
+    assumptions_path = worktree / "ANNAHMEN.md"
+    assumptions = assumptions_path.read_text(encoding="utf-8") if assumptions_path.is_file() else ""
+    return CleanupAssessment(worktree, branch, assumptions, tuple(reasons))
+
+
 def edit_decision(
     profile: WorktreeProfile,
     facts: RepoFacts,
@@ -196,6 +252,28 @@ def branch_create_decision(
     return Decision("allow")
 
 
+def handoff_decision(
+    profile: WorktreeProfile,
+    facts: RepoFacts,
+    payload: dict[str, Any],
+) -> Decision:
+    prompt = str(payload.get("prompt") or "")
+    pattern = re.compile(
+        rf"{re.escape(profile.setup_entry)}\s+(\d+)\s+(\S+)"
+    )
+    match = pattern.search(prompt)
+    if match is None or not facts.is_main_worktree:
+        return Decision("skip")
+    issue, slug = match.groups()
+    command = f"{profile.setup_entry} {issue} {slug}"
+    return Decision(
+        "emit",
+        f"Defined slice detected: create its isolated worktree first with `{command}`, "
+        "then perform repository reads from that worktree.",
+        "UserPromptSubmit",
+    )
+
+
 def evaluate(
     profile: WorktreeProfile,
     facts: RepoFacts,
@@ -216,4 +294,6 @@ def evaluate(
         return command_decision(profile, facts, payload)
     if event == "branch-create":
         return branch_create_decision(profile, facts, payload)
+    if event == "handoff":
+        return handoff_decision(profile, facts, payload)
     return Decision("skip")

package/scripts/wrapup-land.py

@@ -20,6 +20,7 @@ no --no-verify; the caller diagnoses.
 from __future__ import annotations
 
 import argparse
+import importlib.util
 import json
 import os
 import re
@@ -90,6 +91,44 @@ def load_profile() -> dict:
         return {}
 
 
+def load_worktree_cleanup_core():
+    path = Path(__file__).resolve().parent / "worktree-lifecycle" / "core.py"
+    module_dir = str(path.parent)
+    if module_dir not in sys.path:
+        sys.path.insert(0, module_dir)
+    spec = importlib.util.spec_from_file_location("_wrapup_worktree_lifecycle", path)
+    if spec is None or spec.loader is None:
+        raise Stop("cleanup", f"cannot load shared cleanup core from {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def ensure_worktree_removable(wt: str, main_tree: str):
+    profile_path = Path(main_tree) / "docs/agents/workflow-capabilities.json"
+    if not profile_path.is_file():
+        return None
+    core = load_worktree_cleanup_core()
+    try:
+        profile = core.load_profile(profile_path)
+        assessment = core.cleanup_assessment(
+            profile,
+            Path(main_tree),
+            Path(wt),
+            merge_target="origin/main",
+        )
+    except core.LifecycleError as error:
+        raise Stop("cleanup", f"shared cleanup guard failed: {error}") from error
+    if assessment.reasons:
+        raise Stop(
+            "cleanup",
+            "shared cleanup guard refused worktree removal",
+            "; ".join(assessment.reasons),
+        )
+    return assessment
+
+
 # ---------- drift log (ANNAHMEN.md) ----------
 
 def parse_annahmen(text: str, default_section: str) -> tuple[list[dict], list[str]]:
@@ -428,6 +467,12 @@ def cmd_land(args) -> dict:
 
     # Step 2 — kill the worktree's dev server, then Step 4 — teardown
     if wt_exists:
+        git(["fetch", "origin", "main"], cwd=main_tree, check=True)
+        cleanup = ensure_worktree_removable(wt, main_tree)
+        report["cleanup_guard"] = {
+            "active": cleanup is not None,
+            "assumptions_read": bool(cleanup and cleanup.assumptions),
+        }
         report["killed_processes"] = kill_worktree_processes(wt)
         p = git(["worktree", "remove", wt], cwd=main_tree)
         if p.returncode != 0:

package/src/lib/bundle.mjs

@@ -65,15 +65,18 @@ export const HELPER_FILES = [
   { path: 'scripts/census/delta.mjs', kind: 'script', mode: 0o644 },
   { path: 'scripts/census/state.mjs', kind: 'script', mode: 0o644 },
   { path: 'scripts/census/transaction.mjs', kind: 'script', mode: 0o644 },
-  // Consumer-owned memory planning and recovery. The module is both the stable
-  // skill API and the no-write-by-default CLI.
+  // Consumer-owned memory planning, one-time policy seeding, and recovery.
   { path: 'scripts/memory-lifecycle/index.mjs', kind: 'script', mode: 0o644 },
+  { path: 'scripts/memory-lifecycle/setup.mjs', kind: 'script', mode: 0o644 },
+  { path: 'assets/memory-templates/meta_decision_layer_choice.md', kind: 'template', mode: 0o644 },
+  { path: 'assets/memory-templates/meta_memory_lifecycle.md', kind: 'template', mode: 0o644 },
   // Profile-driven Worktree Lifecycle foundation. The setup adapter imports
   // core.py, while capabilities.json keeps the historical 8/8 denominator
   // explicit until the remaining hook and cleanup adapters are activated.
   { path: 'scripts/worktree-lifecycle/core.py', kind: 'script', mode: 0o644 },
   { path: 'scripts/worktree-lifecycle/profile.py', kind: 'script', mode: 0o644 },
   { path: 'scripts/worktree-lifecycle/setup.py', kind: 'script', mode: 0o755 },
+  { path: 'scripts/worktree-lifecycle/cleanup.py', kind: 'script', mode: 0o755 },
   { path: 'scripts/worktree-lifecycle/capabilities.json', kind: 'doc', mode: 0o644 },
   { path: 'scripts/worktree-lifecycle/README.md', kind: 'doc', mode: 0o644 },
   // Shared hook utility imported by the shipped hooks (drift-guard,
@@ -87,6 +90,7 @@ export const HELPER_FILES = [
   { path: '.claude/hooks/enforce-worktree.py', kind: 'hook', mode: 0o755 },
   { path: '.claude/hooks/enforce-worktree-cwd.py', kind: 'hook', mode: 0o755 },
   { path: '.claude/hooks/enforce-worktree-discipline.py', kind: 'hook', mode: 0o755 },
+  { path: '.claude/hooks/slice-handoff-hint.py', kind: 'hook', mode: 0o755 },
   { path: '.claude/hooks/drift-guard.py', kind: 'hook', mode: 0o755 },
   // SessionStart skill-freshness drift-hint (audit-skills names it). For each
   // <skill>/SOURCES.txt it flags sources newer in git than the SKILL.md. Imports