@ikon85/agent-workflow-kit 0.43.0 → 0.44.0

package/.agents/skills/grill-me/SKILL.md

@@ -52,7 +52,9 @@ For a cross-cutting plan, run `python3 .claude/hooks/drift-guard.py --census-sta
 
 ## Plan-lock — writing PLAN.md
 
-Once all decisions are made (plan locked, before sign-off/handoff) and the session runs in a **worktree** → write the locked plan as `PLAN.md` to the worktree root. `PLAN.md` is **expected** to be ignored by git so it never travels over git — the kit never edits your `.gitignore` by itself, but `/setup-workflow` offers to add that rule (consistent with CLAUDE.md "plan inside the worktree"). This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work **without** a worktree stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
+Once all decisions are made (plan locked, before sign-off/handoff) → write the locked plan as `PLAN.md` **where the session already runs**. Planning creates no worktree: a worktree isolates a build, so it belongs to the implementing session, which creates it when the build starts. `PLAN.md` is **expected** to be ignored by git so it never travels over git — the kit never edits your `.gitignore` by itself, but `/setup-workflow` offers to add that rule. Being ignored is also what makes it scratch: the repository has declared it not-work, so it is deletable at teardown and needs no cleanup step of its own. This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
+
+**Durable output is the opposite case.** Domain-model or glossary edits, decision records and research notes this grill produced are **not** scratch — they are ordinary work and have to reach a commit. Land them with `$wrapup`: a planning session with no worktree takes its Content route, which claims an explicitly confirmed file list and opens the ordinary PR, with no teardown half. Never leave them behind as an uncommitted session leftover.
 
 ## Re-grill reconcile — execute-ready (Wave 26)
 

package/.agents/skills/grill-with-docs/SKILL.md

@@ -40,7 +40,9 @@ For a cross-cutting plan, run `python3 .claude/hooks/drift-guard.py --census-sta
 
 ## Plan-lock — writing PLAN.md
 
-Once all decisions are made (plan locked, before sign-off/handoff) and the session runs in a **worktree** → write the locked plan as `PLAN.md` to the worktree root. `PLAN.md` is **expected** to be ignored by git so it never travels over git — the kit never edits your `.gitignore` by itself, but `/setup-workflow` offers to add that rule (consistent with CLAUDE.md "plan inside the worktree"). This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work **without** a worktree stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
+Once all decisions are made (plan locked, before sign-off/handoff) → write the locked plan as `PLAN.md` **where the session already runs**. Planning creates no worktree: a worktree isolates a build, so it belongs to the implementing session, which creates it when the build starts. `PLAN.md` is **expected** to be ignored by git so it never travels over git — the kit never edits your `.gitignore` by itself, but `/setup-workflow` offers to add that rule. Being ignored is also what makes it scratch: the repository has declared it not-work, so it is deletable at teardown and needs no cleanup step of its own. This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
+
+**Durable output is the opposite case.** This grill writes `CONTEXT.md` and ADR updates inline, by design, and a session often adds research notes as well. None of that is scratch — it is ordinary work and has to reach a commit. Land it with `$wrapup`: a planning session with no worktree takes its Content route, which claims an explicitly confirmed file list and opens the ordinary PR, with no teardown half. Never leave the documentation this grill just sharpened behind as an uncommitted session leftover.
 
 </plan-lock>
 

package/.agents/skills/kit-update/SKILL.md

@@ -113,10 +113,10 @@ release contain the same artifact.
    pull request all name the same outstanding actions. Each action names the
    workflow that resolves it, the Consumer file that carries the decision, and
    the exact missing decision. `kit-update` only detects and reports it: it
-   never writes the decision, never infers a value, and never invents or
-   auto-accepts a pattern that would grant deletion authority. An empty but
-   explicit decision is a committed decision and clears the action; a missing
-   one keeps it pending on every rerun.
+   never writes the decision and never infers a value. An empty but explicit
+   decision is a committed decision and clears the action; a missing one keeps
+   it pending on every rerun. A registry with no entries is the normal state —
+   report no outstanding action rather than inventing one.
 
    For each conflicted kit-shipped file, always ask the user whether the local
    edit is a generic improvement or project-specific; never decide or act
@@ -150,16 +150,14 @@ release contain the same artifact.
    python3 scripts/profile_globs.py docs/agents/workflow-capabilities.json
    ```
 
-   Every consumer-profile glob — Worktree Lifecycle `scratchPatterns` and
-   `wrapup.landingGeneratedArtifactPatterns`, Workflow Advisories
+   Every consumer-profile glob — the Workflow Advisories keys
    `baseline.sourceGlobs` and the `preRefactor`/`stopChecks` surface globs — is
    matched by one shared repository-relative dialect. A pattern written for an
    older matcher can narrow or widen. The check names each such pattern with
-   the witness path that proves the difference and marks the keys that carry
-   deletion authority; exit code 1 means at least one needs review. Report the
-   named patterns and let the user rewrite them. The updater never rewrites a
-   consumer pattern, and a widened deletion-authority pattern is never accepted
-   silently — an update must not expand what cleanup may remove. A missing or
+   the witness path that proves the difference; exit code 1 means at least one
+   needs review. Report the named patterns and let the user rewrite them. The
+   updater never rewrites a consumer pattern. No Worktree Lifecycle decision
+   reads a glob, so an update cannot expand what cleanup removes. A missing or
    disabled profile leaves nothing to review and does not invalidate the
    update.
 

package/.agents/skills/orchestrate-wave/SKILL.md

@@ -126,7 +126,7 @@ replace the ~30-second heartbeat; otherwise the standing heartbeat remains requi
 
 1. **Read everything**: the anchor body, every sub-issue body (each has a Handoff
    block: scope, blast-radius, live-verify, PR line), and the locked plan /
-   plan-review doc in the planning worktree (file-exact).
+   plan-review doc the handoff points at, file-exact when one is on disk.
 2. **Select exact commands or the generic fallback.** If the readiness result
    activated `projectRecipe`, use the loaded filled recipe wherever a phase below
    points at a `§`-section. Otherwise use each phase's generic fallback; the
@@ -141,9 +141,10 @@ replace the ~30-second heartbeat; otherwise the standing heartbeat remains requi
    LOCAL annotated tag, so two sessions racing one wave cannot both win. Either
    `acquired: false` or a work signal you did not create means another session
    owns the wave — **STOP**, report the returned `claim.owner` plus the exact
-   branch/worktree, touch nothing. After acquisition, begin the claim-bound teardown receipt with `python3 scripts/worktree-lifecycle/session.py begin --anchor <anchor> --owner <claim-owner> --base <wave-HEAD>`; claim and receipt stay local — never push them.
-4. **Wave worktree**: reuse the planning worktree (never re-create; the handoff
-   points there). Bring its branch to current `main`:
+   branch/worktree, touch nothing. The claim stays local — never push it.
+4. **Wave worktree**: reuse the planning worktree when the handoff names one,
+   never re-creating it; planning binds to no worktree, so a wave may need one
+   cut with your worktree helper. Bring its branch to current `main`:
    `git -C <wave> merge --ff-only origin/main` (if your repo guards destructive
    git, ff-merge is the safe path — not `reset --hard`). Install dependencies with
    your package manager after (the lockfile may have moved). A plan doc the repository
@@ -195,8 +196,7 @@ disjoint wave, conflict hub first. Dispatch only `FREI` slices: re-read
 `frontier <anchor#>` before each wave and clear changed edges only via `dep-remove`.
 Before each slice, bind **(a) inline vs delegate** and **(b) tier + effort** under
 Standing rules. Tiny mechanical work may stay inline.
-For Path A/B, create each new worktree through the active receipt: `python3 scripts/worktree-lifecycle/session.py create --anchor <anchor> --owner <claim-owner> --base <wave-HEAD> --profile <profile> <slice-issue> <slug> <type>`.
-It refuses reused/pre-existing targets; never replace this ownership proof with raw `git worktree add`.
+For Path A/B, create each new worktree with your project's worktree helper — in this kit `python3 scripts/worktree-lifecycle/setup.py --profile <profile> --base <wave-HEAD> <slice-issue> <slug> <type>`, which rolls the worktree and branch back if project setup fails.
 - **Claim each slice issue at builder launch — the wave claim is not a slice
   claim.** It guards the anchor on this machine only; the slice issue is the
   grabbable unit a second machine or cloud agent sees. Before dispatch, skip and
@@ -358,8 +358,8 @@ written · merge order documented.
 - A skill edited during the wave → sync its dual-surface mirror in the SAME PR
   using the tool named by `§Landing` when present; mirror parity remains a pre-PR
   gate.
-- After reading every `ANNAHMEN.md`, seal the receipt, inspect it against fetched canonical `main`, then run its `teardown`; only ancestry/one-to-one patch-equivalent exact owned OIDs are compare-deleted, while foreign targets, unique/ambiguous content, changed OIDs, dirty/protected worktrees, and open/unknown PR evidence stop.
-- Keep the completed receipt as recovery-OID evidence; only then release this run's wave claim.
+- After reading every `ANNAHMEN.md`, tear each landed slice worktree down from the repository's current state: tracked changes, non-ignored untracked files, an unmerged branch, or a protected branch stop that one worktree and name the cause.
+- Only once every worktree decision is made, release this run's wave claim.
 
 **Done when:** no orphan process · this run's wave claim removed · this run's
 unlanded slice claims released · ANNAHMEN propagated ·

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

@@ -204,27 +204,28 @@ Worktree Lifecycle for this repository?"* Offer exactly **Yes**, **Later**, and
 
 - **Yes** — create or deepen only the `worktreeLifecycle` section in
   `docs/agents/workflow-capabilities.json`, preserve every other section and
-  unknown key, reconcile an explicit consumer-derived `scratchPatterns` array,
-  explicitly derive and review the consumer's
-  `wrapup.landingGeneratedArtifactPatterns` array from real landing outputs,
-  and reconcile only the exact kit-owned hook commands listed in the seed.
+  unknown key, reconcile both branch templates — `branchTemplate` for an
+  issue-anchored slice and `contentBranchTemplate` (default `{type}/{slug}`)
+  for the issue-less branch of a durable-content session — 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. Preserve an existing landing-artifact policy
-  byte-for-byte; if it is missing, surface the explicit derivation decision and
-  do not write a default.
+  consumer-owned values, including keys this kit no longer reads.
 - **Disable** — remove only the exact kit-owned hook commands first, then set
   `enabled: false`; retain the profile, setup policy, and unknown keys.
 
-Whenever a profile already carries patterns — on **Yes** over an existing
-section and on **Existing** — run
+Reconcile no deletion-pattern list at any state. Deletion policy has exactly
+one configuration surface, the ignore mechanism, so a profile that still
+carries a pattern key from an older kit keeps it verbatim as consumer data: it
+is ignored in silence, never rewritten and never reported.
+
+Whenever a profile already carries Workflow Advisories globs — on **Yes** over
+an existing section and on **Existing** — run
 `python3 scripts/profile_globs.py docs/agents/workflow-capabilities.json` and
 report every pattern it names. Patterns whose match set narrows or widens under
-the shared dialect are a consumer decision: name them with their witness path,
-mark the deletion-authority keys, and let the consumer rewrite them. Never
-rewrite a pattern for them, and never accept a widened deletion-authority
-pattern silently.
+the shared dialect are a consumer decision: name them with their witness path
+and let the consumer rewrite them. Never rewrite a pattern for them.
 
 The default setup entry is
 `python3 scripts/worktree-lifecycle/setup.py`; a proven consumer-native helper
@@ -452,8 +453,9 @@ step may write `.gitignore`; `init` and `update` reconciliation never reach the
 seeder.
 
 Report `appended · nothing to do (already ignored) · declined · blocked
-(consumer-edited block)`. After an approval — and only then — the Section A4
-`scratchPatterns` derivation has real ignored planning artefacts to read.
+(consumer-edited block)`. After an approval — and only then — those artefacts
+are Scratch, because being ignored is the whole of what makes a file deletable
+at teardown.
 
 ### 3. Section B — Triage labels
 
@@ -605,9 +607,9 @@ unknown consumer keys share this profile. Apply the transition and hook
 ownership rules from [worktree-lifecycle.md](./worktree-lifecycle.md),
 [workflow-advisories.md](./workflow-advisories.md), and
 [safety-guardrails.md](./safety-guardrails.md) transactionally.
-The landing-artifact policy is deletion authority: it is always an explicit
-consumer-reviewed setup value, never an update-time default or an inference
-from ignored paths.
+The profile carries structural facts only; it holds no deletion policy, because
+the ignore mechanism is the single surface that decides what teardown may
+remove.
 
 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

package/.agents/skills/setup-workflow/board-sync.md

@@ -24,6 +24,8 @@ How the board-managed workflow skills (`to-prd`, `to-issues`, `board-to-waves`,
 
 The optional `wrapup` block is a wrapup-only switch, not a board field: `wrapup.remoteBranchSweep` (default `false`) gates `wrapup` Step 5d's remote-branch sweep — `false`/missing (the shipped default) means Step 5d only reports the count of stale merged-PR remotes it found; `true` lets it actually `git push origin --delete` them. Flip it to `true` once you trust the sweep in your repo.
 
+`wrapup.censusTrackingIssue` (default `false`) is the second switch in that block. It gates `wrapup` Step 5f's tracking issue: `false`/missing (the shipped default) means a stale census verdict is reported as a session-end finding only; `true` additionally opens — or, on a later session, updates — one marker-identified tracking issue so the finding survives the session. The finding itself never blocks a landing either way, and the recovery route stays a dedicated pull request, never a census file mirrored between checkouts.
+
 <!-- board-sync:profile -->
 ```json
 {
@@ -75,7 +77,8 @@ The optional `wrapup` block is a wrapup-only switch, not a board field: `wrapup.
     "wavePrefix": "Wave"
   },
   "wrapup": {
-    "remoteBranchSweep": false
+    "remoteBranchSweep": false,
+    "censusTrackingIssue": false
   }
 }
 ```

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

@@ -78,8 +78,9 @@ project commands from the tools already present, then asks before activating.
 
 `baseline.sourceGlobs`, `preRefactor.surfaces[].globs`, and
 `stopChecks.surfaces[].globs` are matched by the one shared dialect in
-`scripts/profile_globs.py` — the same matcher Worktree Lifecycle uses for its
-scratch and landing-artifact policies. There is no second matcher and no
+`scripts/profile_globs.py`. They are the only consumer-profile globs the kit
+reads: Worktree Lifecycle carries no pattern list, because the ignore mechanism
+is the single deletion-policy surface. There is no second matcher and no
 per-capability variant:
 
 - `*` matches any run of characters inside one path segment, never `/`.

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

@@ -29,7 +29,6 @@ advisory, and safe cleanup policy as one unit.
     "operations": [
       "record-choice",
       "reconcile-profile-enabled",
-      "reconcile-landing-artifact-policy",
       "reconcile-hook-wiring"
     ]
   },
@@ -51,8 +50,7 @@ advisory, and safe cleanup policy as one unit.
     "state": "existing",
     "choice": "yes",
     "operations": [
-      "adopt-existing",
-      "reconcile-landing-artifact-policy"
+      "adopt-existing"
     ]
   },
   {
@@ -105,28 +103,34 @@ approved step may write `.gitignore`.
 
 ## Scratch classification and sweep
 
-Reconcile an explicit `scratchPatterns` array when enabling a new profile.
-Derive its glob values from the consumer's ignored planning artefacts; an empty
-array is valid. Existing values are consumer-owned and remain byte-identical on
-adoption or rerun. Core never supplies filename defaults — the offered ignore
-rules above are what give that derivation something real to read.
-
-Also reconcile an explicit
-`wrapup.landingGeneratedArtifactPatterns` array. Derive candidates from the
-consumer's real landing commands and ignored outputs, show the exact list for
-review, and write it only as part of that explicit setup decision. Never copy
-another repository's values or infer deletion authority from `.gitignore`
-alone. An empty array is valid. Existing configured values remain byte-identical.
-If an existing enabled profile lacks the key, report one actionable setup
-decision and leave the project layer unchanged until the consumer confirms the
-derived list.
+Reconcile **no** pattern list. Deletion policy has exactly one configuration
+surface, the ignore mechanism: a file is Scratch — deletable at teardown —
+precisely when the repository's own exclude sources classify it as ignored.
+Making a file deletable therefore means ignoring it, which is what the offered
+planning-artifact rules above do. Setup never derives, writes, or reviews a
+deletion pattern, and a profile that still carries one from an older kit keeps
+it as consumer data: the loader ignores unknown keys in silence, so there is
+nothing to migrate and nothing to warn about.
+
+## Branch templates
+
+`branchTemplate` names the branch of an issue-anchored slice and renders
+`{type}`, `{issue}`, and `{slug}`. `contentBranchTemplate` names the issue-less
+branch a session cuts when its output is durable content — a planning session
+has no issue number — and renders `{type}` and `{slug}` only; an `{issue}`
+placeholder in it is refused rather than filled with a guess.
+
+Reconcile `contentBranchTemplate` with the default `{type}/{slug}` when
+enabling a new profile, and offer the consumer their own naming instead.
+An existing value is consumer-owned and remains byte-identical on adoption or
+rerun.
 
 ## Profile glob dialect
 
-Every consumer-profile glob in this kit — Worktree Lifecycle and Workflow
-Advisories alike — is matched by the one shared dialect in
-`scripts/profile_globs.py`. There is no second matcher and no per-capability
-variant:
+Every consumer-profile glob in this kit — the Workflow Advisories keys
+`baseline.sourceGlobs`, the `preRefactor`/`stopChecks` surface globs — is
+matched by the one shared dialect in `scripts/profile_globs.py`. There is no
+second matcher and no per-capability variant:
 
 - `*` matches any run of characters inside one path segment, never `/`.
 - `?` matches exactly one character inside one path segment.
@@ -147,14 +151,15 @@ trusting its patterns:
 python3 scripts/profile_globs.py docs/agents/workflow-capabilities.json
 ```
 
-The check names every pattern whose match set narrows or widens against that
-key's legacy matcher, prints the concrete witness path that proves the
-difference, and marks the keys that carry deletion authority. Exit code 1 means
-at least one pattern needs review. Report the named patterns and let the
-consumer rewrite them; never migrate a pattern automatically and never treat a
-widened deletion-authority pattern as an accepted default. The check reads the
-profile and never edits it.
+The check names every pattern whose match set narrows or widens against the
+legacy matcher and prints the concrete witness path that proves the difference.
+Exit code 1 means at least one pattern needs review. Report the named patterns
+and let the consumer rewrite them; never migrate a pattern automatically. The
+check reads the profile and never edits it. No Worktree Lifecycle decision
+reads a glob, so a pattern here can widen only what an advisory selects, never
+what teardown removes.
 
 The shipped read-only inventory is
-`python3 scripts/worktree-lifecycle/cleanup.py sweep`. The same profile powers
-its branch issue extraction and scratch-only cleanup verdicts.
+`python3 scripts/worktree-lifecycle/cleanup.py sweep`. The profile powers its
+branch issue extraction; the scratch each row reports comes from the same
+stateless classification teardown itself uses, never from a profile pattern.

package/.agents/skills/to-issues/SKILL.md

@@ -505,3 +505,46 @@ The Program graph engine emits `planning-mode=program` in its own counted audit
 after the complete preview gate; the facade relays that audit unchanged.
 
 Do NOT close or modify any parent issue beyond the promote stamp.
+
+### 8. End state — name what the session leaves behind
+
+Publication is not the end of the session. `to-issues` **never deletes** what it
+leaves behind — the locked plan is the implementing session's input and the
+assumption log is `$wrapup`'s. Classify, report, hand over.
+
+Read the classes from the repository itself, never from a pattern list — git's
+own taxonomy is the classification:
+
+```bash
+git status --short             # tracked edits + untracked, non-ignored files
+git status --short --ignored   # the same, plus the ignored paths, marked `!!`
+```
+
+- **Durable content** — everything the first command already lists. Domain-model
+  or glossary updates, decision records, research notes, any tracked edit the
+  planning produced. This is ordinary work: it has to reach a commit and the
+  ordinary PR gate. `to-issues` does not commit it.
+- **Scratch** — the `!!` entries only the second command adds: the locked plan,
+  its review log, the assumption log. The repository has already declared them
+  not-work, so they are deletable at teardown and die with the checkout they
+  were written in. Leave them here — the implementing session reads the plan and
+  `$wrapup` reads the assumption log.
+- **Nothing** — neither class present. Report it. An empty end state is a
+  result, not silence.
+
+Then emit the state report — exactly two lines, on every run:
+
+```
+end state: durable=<n file(s) | none> · scratch=<n file(s) | none>
+next: <$wrapup — lands the durable content | nothing to land — this session is done>
+```
+
+`$wrapup` is **user-invoked only**: name it as the next step, never call it from
+here.
+
+**A project with no worktree helper changes nothing about this.** The
+classification is git's, not the worktree layout's, and `$wrapup` lands durable
+content from whichever checkout it runs in — its Content route exists precisely
+for a session that has no worktree and no slice. Report the situation as
+observed instead of assuming a worktree convention the project may not have, and
+never propose creating one just to have something to land through.

package/.agents/skills/wrapup/SKILL.md

@@ -9,10 +9,13 @@ description: >-
   merged-branch leftovers (local + stale remote whose PR is merged). If the
   slice isn't landed yet, it first makes it landable (Step 0): commits a dirty
   tree (after an .env/secret check), pushes, and opens the PR — reusing one if
-  it already exists. User-triggered only (never auto-invoke, never hook). Aborts
-  hard only on: not in a feature worktree, a detected .env/secret, a rejected
-  push, a conflicting PR, terminal red checks, or checks still pending after
-  the bounded wait budget.
+  it already exists. Second route (no worktree, no slice): durable content dirty
+  in the main checkout lands via one confirmed, hash-verified file claim on an
+  issue-less branch — bystanders untouched, no teardown. User-triggered
+  only (never auto-invoke, never hook). Aborts hard only on: the worktree flow
+  on the main checkout or a protected branch, a detached or unborn HEAD, a
+  detected .env/secret, a rejected push, a conflicting PR, terminal red checks,
+  or checks still pending after the bounded wait budget.
 ---
 
 <!-- project-extension:protocol-v1:start -->
@@ -48,7 +51,7 @@ Run **in the worktree**:
 ```bash
 python3 scripts/wrapup-land.py preflight
 ```
-Hard stop (the only pure precondition): not in a feature worktree / on `main` — the script exits 1. The report carries everything the later steps need: dirty files, `.env` hits, secret-grep hits, issue + parent (leaf vs. anchor slice), existing PR + whether its body has a `**Retro:**` line, parsed `ANNAHMEN.md` drift lines, profile values (`retro_values`, `vor_bau`, remote-sweep switch).
+Hard stop (the only pure preconditions): the main checkout, a protected branch, a detached HEAD, or an unborn branch — the script exits 1 and names which. Any other born, attached worktree qualifies, whatever its name or location. The report carries everything the later steps need: dirty files, `.env` hits, secret-grep hits, issue + parent (leaf vs. anchor slice), existing PR + whether its body has a `**Retro:**` line, parsed `ANNAHMEN.md` drift lines, profile values (`retro_values`, `vor_bau`, remote-sweep switch).
 
 Then run:
 
@@ -101,68 +104,109 @@ Run **from the main tree** (the script refuses inside the worktree — an in-wor
 ```bash
 python3 scripts/wrapup-land.py land --branch "<branch>" --title "<title>" --body-file /tmp/wrapup-pr-body.md
 ```
-One call covers: push → PR create/reuse (+ drift markers merged into the body) → `pr-body-check.py` gate (exit 1 = STOP, exit 2 = fail-open warning) → merge gate (pending/null-conclusion checks poll for up to 20 minutes with progress on stderr; terminal red / `CONFLICTING` / timeout = STOP; known zero-step billing or runner failures are named `infrastructure failure`; an already-`MERGED` PR resumes at teardown) → **merge** (`--merge` + `--delete-branch`, verified `MERGED`) → dev-server kill (`.dev-ports` ports + cwd-under-worktree walk, own shell ancestry excluded) → worktree remove (no `--force`; refusal = STOP, check surviving processes first) → main `--ff-only` pull + `branch -d` → issue-close verify (auto-close misses are closed manually) → local merged-branch sweep (`-d` only — squash/rebase-merged branches stay a manual call by design) → remote merged-PR sweep (opt-in `wrapup.remoteBranchSweep` in the board profile; PR-status-authoritative via `ls-remote`; deleted remote branches are restorable from the PR page) → anchor-sync (dry-run diff in the report) + anchor completeness check + `execute-ready-check --mode audit` → **upward propagation:** if the anchor's native parent is a Program-PRD, `program-sync` refreshes its Wellenplan (Status + Issue cells) and checks off mechanically completed Phasen-Gates — the slice event is visible at the program level, not only in the wave (`program_sync` block in the report; skipped when the parent isn't a program).
+One call covers: push → PR create/reuse (+ drift markers merged into the body) → `pr-body-check.py` gate (exit 1 = STOP, exit 2 = fail-open warning) → merge gate (pending/null-conclusion checks poll for up to 20 minutes with progress on stderr; terminal red / `CONFLICTING` / timeout = STOP; known zero-step billing or runner failures are named `infrastructure failure`; an already-`MERGED` PR resumes at teardown) → **merge** (`--merge` + `--delete-branch`, verified `MERGED`) → dev-server kill (`.dev-ports` listeners only, own shell ancestry excluded) → teardown classification + scratch removal → worktree remove (no `--force`; refusal = STOP, check surviving processes first) → integration-branch `--ff-only` pull + branch retirement by authority → issue-close verify (auto-close misses are closed manually) → local merged-branch sweep (`-d` only — squash/rebase-merged branches stay a manual call by design) → remote merged-PR sweep (opt-in `wrapup.remoteBranchSweep` in the board profile; PR-status-authoritative via `ls-remote`; deleted remote branches are restorable from the PR page) → anchor-sync (dry-run diff in the report) + anchor completeness check + `execute-ready-check --mode audit` → **upward propagation:** if the anchor's native parent is a Program-PRD, `program-sync` refreshes its Wellenplan (Status + Issue cells) and checks off mechanically completed Phasen-Gates — the slice event is visible at the program level, not only in the wave (`program_sync` block in the report; skipped when the parent isn't a program) → **census freshness** (Step 5f, see below).
+
+STOP → diagnose in the main conversation, fix, re-run `land`. Re-running is the
+only recovery route there is: every step re-reads present state (is the remote
+already at this commit? does the PR exist? is it merged? is the worktree still
+there?) and skips what is already done, so an interrupted landing resumes
+exactly where it stopped. The report's `skipped` list names what it found done.
+
+Teardown always runs, and running `/wrapup` in a worktree *is* its
+authorization — including a worktree an external tool created under a foreign
+name and path, and a branch that carries no issue number. Teardown authority is
+the repository's current state, nothing else: a tracked change or an unmerged
+path blocks, an untracked non-ignored file blocks with a bounded report (count
+plus top directories, never a path dump), and an ignored entry is deletable
+scratch. One hardcoded exception: an `.env*` file is deletable only when it is
+byte-identical to the main checkout's copy at the same path — otherwise the
+refusal names the exact file. An ignored symlink is unlinked, never followed,
+and only while its target stays inside the worktree: an absolute, escaping,
+dangling, or since-changed target keeps the worktree and names the link. Make
+something deletable by ignoring it; there is no pattern list to configure.
+
+Branch retirement is authorized, never assumed. A branch that is an ancestor of
+the **freshly fetched** integration branch is deleted with `-d`; a fetch that
+fails stops instead of trusting a stale ancestry check. Otherwise the platform's
+own record decides: exactly one pull request matching the full tuple — this
+repository on both sides (no fork heads), this head ref, the configured base
+ref, merged — whose head SHA still equals the branch tip re-read immediately
+before the deletion, authorizes the force delete. Zero matches, several matches,
+an open PR on the same head, a tip that moved in between, or no platform access
+at all keep the branch and report why (`branch_authority` in the report; a
+degraded run says so instead of implying the platform agreed). A reused head ref
+resolves to several pull requests, so the head SHA carries the uniqueness, not
+the ref — `land --pr <n>` names the pull request to check when that record is
+ambiguous. `--pr` selects which pull request is validated; it never skips the
+validation.
+
+Two refusals name a state landing cannot repair for you: a **detached HEAD**
+(attach a branch in that worktree first) and an **unborn branch** (make the
+first commit first).
+
+Step 5f gives the census freshness verdict a session-end home. It reads
+`drift-guard.py --census-status` **for the main checkout** — the tree the next
+session starts from — because a census describes the tree it was scanned in: a
+refresh committed inside a worktree is visible in that one working tree only, so
+a worktree-green verdict must never stand in for a stale main checkout. `current`
+and `no_census` leave no trace at all; only `refresh_required` speaks, as a
+`census` block in the report that names the verdict, its reasons, the **evaluated
+checkout**, and the recovery route — run `$census-update` there and land the
+refresh as a dedicated pull request of its own, never a census file mirrored
+between checkouts. It is a finding, never a gate: topology drift is repo-wide and
+usually not caused by the PR at hand, so the landing completes regardless, and a
+census step that cannot answer degrades to one warning. Opt in with
+`wrapup.censusTrackingIssue` in the board profile to also open one
+marker-identified tracking issue — a later session updates that same issue
+instead of minting a duplicate, and an ambiguous or unreachable lookup writes
+nothing and says why.
+
+The dev-server kill is `.dev-ports`-scoped and never signals on doubt: only a
+listener on a port this worktree declares, whose working directory is inside
+it, is signalled — pinned by `pidfd` so a recycled PID cannot be hit. Anything
+else on those ports is a STOP naming the process, not a kill.
 
-STOP → diagnose in the main conversation, fix, re-run `land` (an already-merged PR resumes at teardown).
+### 6 · Post-merge (agent)
+- **Sibling propagation:** for each `drift_markers` entry in the land report, append the note to the target issue's `vor_bau` section + re-stamp its `plan_revision`. Log-based markers → **write directly, then show what was written where** (mandatory report — visibility moved from a pre-gate into the report, decision 2026-07-06); fallback candidates the user hasn't confirmed yet → confirm first. Program context widens the target set to unbuilt wave-stubs/leaves and the Program-PRD itself — same append-only mechanism. **Exception:** appends to the Program-PRD or unbuilt wave-stubs do **not** re-stamp `plan_revision` — that stays reserved for structural wave-plan edits via the `to-waves` escalation path; a mere drift note must not stale-block published stubs.
+- **Anchor close:** report says `anchor_complete: true` → `gh issue close <anchor> -c "Wave complete — all slices merged via PR #<pr>."` and verify board status Done. The guard keeps anchors away from every auto-close — this verified close is the only close path; without it the anchor stays silently open after the last slice. **Then re-run the upward propagation**: the land-time `program-sync` ran BEFORE this close, so on a wave-completing slice the Wellenplan still shows 🔄 and the Phasen-Gate stays unchecked — after the board shows Done, run `python3 scripts/board-sync.py program-sync <program-prd#>` once more (the report's `program_sync.program` names it; skip when the report says the parent is not a program). Board auto-rules can lag the close (Close→Done race) — verify Done first, that's what the token reads.
+- **Report**, concise, from the land JSON: PR merged · issue close (auto/manual) · worktree removed · branch deleted · sweep counts local/remote · anchor synced + complete/pending · program propagation (`program_sync`: Wellenplan refreshed / gates checked / skipped) · propagation writes (what → where) · census finding when the report carries one (verdict + evaluated checkout + recovery route + tracking issue; silent otherwise) · `main` at `<sha>`.
+
+<!-- readiness:block deployReport -->
+- **Deploy-aware report:** read the coherent `## Prod` block; before merging,
+  state the configured deploy trigger and expected outcome. After merge, report
+  the configured target and its actual known state. Do not claim a deployment
+  is running or live unless the configured trigger and observed evidence prove
+  it; keep unknown timing explicit.
+<!-- readiness:end -->
 
-Before merge, the committed worktree policy only nominates exact landing
-evidence. After merge, cleanup reloads `docs/agents/workflow-capabilities.json`
-from canonical `origin/main`; only the identical merged, attempt-bound scratch
-and generator policy authorizes each evidence path and deletion. A mismatch is
-a hard STOP that preserves every file—never bypass it with the unmerged branch
-profile.
+## Content route — durable content without a worktree
 
-Landing provenance has one explicit relinquish route. If the STOP names an
-unfinished or drifted landing attempt and the ambiguous files cannot be restored
-to their frozen identities, run:
+**Explicit invocation only, never a fallback from the flow above.** Use it when `$wrapup` or `/wrapup` runs in the **main checkout on a protected branch** and the session produced durable content — a decision record, a glossary update, a research note — with no worktree and no slice. A session that has a worktree always takes the flow above. Authorization is unchanged: the user's direct invocation, nothing else.
 
+### C1 · Infer (read-only)
 ```bash
-python3 scripts/wrapup-land.py land --branch "<branch>" --abandon-unfinished-attempt
+python3 scripts/wrapup-land.py content-claim
 ```
+Reports every dirty path that could be durable content, each with the blob hash it carries **right now**, plus `unclaimable` — deletions, renames, symlinks, `.env*` — named instead of hidden. Ignored paths are scratch and never appear. A dirty tree too large to reason about stops with a bounded summary (count plus top directories), never a path dump.
 
-This archives the started or frozen attempt receipt only. It deletes and claims
-no files, works even when the older creation baseline is missing, and returns
-before push, PR, or merge. The next `land` conservatively protects every current
-matching path; classify or move those blockers first. Do not use relinquish for
-an exact unchanged frozen attempt: a normal retry validates that evidence and
-resumes deterministically.
-
-An attempt journaled under the superseded v1 contract is **legacy, not
-corruption**. The STOP says so explicitly and names the same
-`--abandon-unfinished-attempt` archive route; archival stays valid for a v1 and
-a v2 receipt even without a creation baseline or a local main profile, and no
-generated or consumer file is deleted or claimed on that route.
-
-If canonical `origin/main` changed its scratch or generator policy *after* the
-attempt started, the PR can merge and cleanup then STOPs with `worktree cleanup
-policy differs from merged canonical origin/main`. That STOP stays fail-closed
-and names its one supported route out:
+### C2 · Claim (the one gate — agent judgment)
+Show the candidates and let the **user confirm an explicit file list**. Inference proposes; the claim decides. Write exactly the confirmed records — `path` and `oid` copied verbatim — to a claim file:
+```json
+{"claimed": [{"path": "docs/decisions/lifecycle.md", "oid": "<from content-claim>"}]}
+```
 
+### C3 · Land
 ```bash
-python3 scripts/wrapup-land.py land --branch "<branch>" --recover-canonical-cleanup
+python3 scripts/wrapup-land.py content-commit --claim-file /tmp/wrapup-claim.json \
+  -m "<commit message>" --type "<branch type>" --slug "<slug>" [--anchor <n>] [--body-file <body>]
 ```
+The branch name comes from the profile's content branch template (issue-less by construction — a planning session has no issue number); the type is one of the profile's own branch prefixes. One call covers: re-read every claimed path (a path whose content moved since the claim is **dropped and named** in the report, the rest still lands; every claimed path gone → STOP) → `.env*` hard block plus the ordinary secret scan on exactly the diff to be committed → stage the claim into a private index and verify the resulting tree by name **and** object id → collision-check the branch locally **and** on the remote → commit → return the main checkout to the protected branch.
 
-This resumes the teardown of an **already-merged** worktree only. It never reads
-the stale worktree candidate policy: it re-reads the merged canonical policy,
-requires the branch to already be an ancestor of canonical `origin/main`, and
-revalidates each frozen landing identity against that canonical policy before
-the ordinary shared assessment and removal run. Evidence the canonical policy no
-longer names, a changed identity, and any pre-existing or foreign file are hard
-STOPs that delete nothing. Re-running after a successful teardown is a no-op.
-The flag is mutually exclusive with `--abandon-unfinished-attempt`.
+Everything not in the claim is a bystander and is never read, staged, or written — including changes the user had already staged. The route has no wholesale staging step to widen, so the ordinary dirty-tree commit cannot be reached from here at all. It never closes an anchor: `--anchor` renders the board profile's `prMarkers.partOf` reference, and a `--body-file` that declares a close keyword is refused. There is no teardown half — no worktree to remove, no branch to retire.
 
-### 6 · Post-merge (agent)
-- **Sibling propagation:** for each `drift_markers` entry in the land report, append the note to the target issue's `vor_bau` section + re-stamp its `plan_revision`. Log-based markers → **write directly, then show what was written where** (mandatory report — visibility moved from a pre-gate into the report, decision 2026-07-06); fallback candidates the user hasn't confirmed yet → confirm first. Program context widens the target set to unbuilt wave-stubs/leaves and the Program-PRD itself — same append-only mechanism. **Exception:** appends to the Program-PRD or unbuilt wave-stubs do **not** re-stamp `plan_revision` — that stays reserved for structural wave-plan edits via the `to-waves` escalation path; a mere drift note must not stale-block published stubs.
-- **Anchor close:** report says `anchor_complete: true` → `gh issue close <anchor> -c "Wave complete — all slices merged via PR #<pr>."` and verify board status Done. The guard keeps anchors away from every auto-close — this verified close is the only close path; without it the anchor stays silently open after the last slice. **Then re-run the upward propagation**: the land-time `program-sync` ran BEFORE this close, so on a wave-completing slice the Wellenplan still shows 🔄 and the Phasen-Gate stays unchecked — after the board shows Done, run `python3 scripts/board-sync.py program-sync <program-prd#>` once more (the report's `program_sync.program` names it; skip when the report says the parent is not a program). Board auto-rules can lag the close (Close→Done race) — verify Done first, that's what the token reads.
-- **Report**, concise, from the land JSON: PR merged · issue close (auto/manual) · worktree removed · branch deleted · sweep counts local/remote · anchor synced + complete/pending · program propagation (`program_sync`: Wellenplan refreshed / gates checked / skipped) · propagation writes (what → where) · `main` at `<sha>`.
+Then land it like any other branch: `land --branch <branch> --title … --body-file …` finds no worktree and tears nothing down.
 
-<!-- readiness:block deployReport -->
-- **Deploy-aware report:** read the coherent `## Prod` block; before merging,
-  state the configured deploy trigger and expected outcome. After merge, report
-  the configured target and its actual known state. Do not claim a deployment
-  is running or live unless the configured trigger and observed evidence prove
-  it; keep unknown timing explicit.
-<!-- readiness:end -->
+STOPs name their cause and force nothing: a claimed `.env*` or ignored path, a claim whose every path drifted, a secret in the claimed content, a branch that already exists locally or on the remote, and a **blocked return switch** — a conflicting checkout leaves the main checkout on the content branch and says so; the content is safe in the commit, and nothing is stashed or forced.
 
 ## Out of scope
 - Live-verify / DoD: must happen **before** `$wrapup` or `/wrapup` — this skill lands, it does not verify.

package/.claude/skills/grill-me/SKILL.md

@@ -52,7 +52,9 @@ For a cross-cutting plan, run `python3 .claude/hooks/drift-guard.py --census-sta
 
 ## Plan-lock — writing PLAN.md
 
-Once all decisions are made (plan locked, before sign-off/handoff) and the session runs in a **worktree** → write the locked plan as `PLAN.md` to the worktree root. `PLAN.md` is **expected** to be ignored by git so it never travels over git — the kit never edits your `.gitignore` by itself, but `/setup-workflow` offers to add that rule (consistent with CLAUDE.md "plan inside the worktree"). This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work **without** a worktree stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
+Once all decisions are made (plan locked, before sign-off/handoff) → write the locked plan as `PLAN.md` **where the session already runs**. Planning creates no worktree: a worktree isolates a build, so it belongs to the implementing session, which creates it when the build starts. `PLAN.md` is **expected** to be ignored by git so it never travels over git — the kit never edits your `.gitignore` by itself, but `/setup-workflow` offers to add that rule. Being ignored is also what makes it scratch: the repository has declared it not-work, so it is deletable at teardown and needs no cleanup step of its own. This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
+
+**Durable output is the opposite case.** Domain-model or glossary edits, decision records and research notes this grill produced are **not** scratch — they are ordinary work and have to reach a commit. Land them with `$wrapup`: a planning session with no worktree takes its Content route, which claims an explicitly confirmed file list and opens the ordinary PR, with no teardown half. Never leave them behind as an uncommitted session leftover.
 
 ## Re-grill reconcile — execute-ready (Wave 26)
 

package/.claude/skills/grill-me-codex/SKILL.md

@@ -49,7 +49,9 @@ For a cross-cutting plan, run `python3 .claude/hooks/drift-guard.py --census-sta
 
 When the decision tree is resolved and we're aligned, **write the agreed plan to `PLAN.md`** in this structure, then move to Act 2:
 
-> **Where to write it:** `PLAN.md` + `PLAN-REVIEW-LOG.md` are per-session scratch — write them in the working directory the implementing session will actually use, and invoke the wrapper from that directory. A project may gitignore these files, so don't rely on git to carry them across checkouts/worktrees. In worktree-based repos, create the issue worktree BEFORE this write and plan inside it.
+> **Where to write it:** `PLAN.md` + `PLAN-REVIEW-LOG.md` are per-session scratch — write them where this session already runs, and invoke the wrapper from that directory. Planning creates no worktree: a worktree isolates a build, so it belongs to the implementing session, which creates it when the build starts. A project may gitignore these files, so don't rely on git to carry them across checkouts/worktrees; being ignored is also what makes them scratch, deletable at teardown and needing no cleanup step of their own.
+>
+> **Durable output is the opposite case:** decision records, glossary edits and research notes this grill produced are ordinary work and have to reach a commit. Land them with `$wrapup` — a planning session with no worktree takes its Content route, which claims an explicitly confirmed file list and opens the ordinary PR, with no teardown half. Never leave them behind as an uncommitted session leftover.
 
 ```markdown
 # Plan: <task>