@event4u/agent-config 8.9.0 → 8.10.0

package/dist/agent-src/skills/voice-and-tone-design/evals/evals.json

@@ -0,0 +1,16 @@
+{
+  "skill": "voice-and-tone-design",
+  "_calibration": "Behavioural fixture (road-to-skill-eval-coverage Phase 2, default-surface). Deterministic assertions on a real output property where reliable; rubric pins the qualitative core as a known-limit (pass ratified in PR review, not a hidden judge). finding_floor n is a conservative floor, not a calibrated per-host number.",
+  "scenarios": [
+    {
+      "id": "define-voice",
+      "prompt": "Define the brand voice and tone for our fintech product.",
+      "assertions": [
+        {
+          "kind": "rubric",
+          "criterion": "Produces named voice attributes with do/don't examples and a tone-by-context matrix, grounded in the audience — not adjectives alone."
+        }
+      ]
+    }
+  ]
+}

package/dist/agent-src/skills/worktree-lifecycle/SKILL.md

@@ -0,0 +1,180 @@
+---
+model_tier: medium
+name: worktree-lifecycle
+description: "Use when governing a worktree across its whole life — scope-lock declaration, merge-readiness status, scoped verification, and safe cleanup that refuses while unique unmerged commits exist."
+domain: process
+workspaces:
+  - engineering
+packs:
+  - engineering-base
+---
+
+# worktree-lifecycle
+
+Governance layer for worktrees that already exist (or are about to).
+Creation mechanics — directory convention, ignore-safety, clean
+baseline — live in [`using-git-worktrees`](../using-git-worktrees/SKILL.md)
+and are **referenced, never restated** here. This skill owns everything
+after the spawn: what the worktree is allowed to touch, when it is
+merge-ready, and when it may be removed.
+
+## When to use
+
+* Deciding whether a task should be isolated in a worktree at all
+* Declaring **which paths a worktree owns** so parallel agents stay disjoint
+* Answering "is this worktree merge-ready?" — status, dirty state,
+  ahead/behind, verification evidence
+* Running the scoped verification for a worktree's declared change
+* Removing a finished worktree without losing commits
+
+Do NOT use when:
+
+* Creating the worktree — that is [`using-git-worktrees`](../using-git-worktrees/SKILL.md)
+  (Iron Law: no worktree without verified ignore + clean baseline)
+* Plain branch work (switch, rebase, PR) without worktree isolation —
+  [`git-workflow`](../git-workflow/SKILL.md)
+* Picking a subagent-orchestration mode — `subagent-orchestration`
+  selects the mode; this skill governs the worktrees a chosen mode uses
+
+## The Iron Law
+
+```
+EVERY GOVERNED WORKTREE DECLARES ITS SCOPE. NO REMOVAL WHILE
+UNIQUE UNMERGED COMMITS EXIST. INHERITED COMMITS ARE NEVER DROPPED.
+```
+
+## Procedure
+
+### 1. Decide isolation
+
+Isolate when **any** holds; otherwise stay on the current branch
+(per the Do-NOT list in `using-git-worktrees`):
+
+* Parallel agents/sessions must not share a working directory
+* The current branch is mid-work and a stash/switch would risk state
+* The change is exploratory and may be thrown away whole
+* A long-running build/test occupies the current worktree
+
+Then create via [`using-git-worktrees`](../using-git-worktrees/SKILL.md)
+(or the host primitive — § Host-native mapping below), declare the
+scope lock (§ 2), keep status honest (§ 3), and gate removal (§ 4).
+
+### 2. Scope lock
+
+At worktree start, write a `.worktree-scope.md` note at the worktree
+root and keep it untracked via `.git/info/exclude` (shared exclude —
+one line `.worktree-scope.md`, no commit needed):
+
+    ## Scope lock
+    - branch: <branch-name>
+    - owns: <path or glob list — the ONLY paths this worktree edits>
+    - task: <one-line task statement>
+    - created: <ISO date>
+
+The lock is the disjointness contract between parallel worktrees. A
+diff that leaves the owned paths is scope creep — stop and surface,
+per `scope-control`. Check mechanically:
+
+```bash
+git diff --name-only "$(git merge-base HEAD <base>)"..HEAD
+# every path must match an `owns:` entry
+```
+
+### 3. Status / merge-ready checklist
+
+A worktree is **merge-ready** only when ALL hold:
+
+1. **Clean tree** — `git status --porcelain` is empty.
+2. **Scope lock respected** — changed files ⊆ `owns:` paths (command above).
+3. **Verification evidence attached** — the scoped probe for the
+   declared change ran fresh and passed (per `verify-before-complete`);
+   record command + result tail in the status report. No fresh
+   evidence → not merge-ready, regardless of how the diff looks.
+4. **Ahead/behind known** — `git fetch origin --quiet` then
+   `git rev-list --left-right --count HEAD...origin/<base>`. Behind →
+   flag; divergent (both sides non-zero on a pushed branch) → route to
+   [`git-workflow § Divergent-State Recovery`](../git-workflow/SKILL.md#procedure-divergent-state-recovery).
+5. **No inherited-commit drops** — commits on the branch that this
+   session did not author stay on the branch; never rebase-out,
+   reset-away, or exclude them (rule `git-history-discipline`,
+   shared-branch Iron Law).
+
+### 4. Cleanup discipline
+
+Removal is gated, in order:
+
+1. **Dirty check** — `git status --porcelain` in the worktree non-empty
+   → refuse (`git worktree remove` refuses too; never answer with
+   `--force`).
+2. **Unique-commit check** — commits reachable from the worktree branch
+   but from **no other ref** (branches, remotes, tags):
+
+   ```bash
+   git log <branch> --oneline --not \
+     $(git for-each-ref --format='%(refname)' | grep -v "^refs/heads/<branch>$")
+   ```
+
+   Non-empty → **refuse removal**; the branch holds work that exists
+   nowhere else. Surface the commit list and hand back — merging or
+   preserving them is the user's call (`git-history-discipline`).
+   Empty → removal allowed.
+3. **Remove, never delete** — `git worktree remove <path>`, then
+   `git worktree prune`. Branch deletion is a separate, permission-gated
+   step (`scope-control`); never force-delete (`-D`) as part of cleanup.
+
+## Host-native mapping
+
+| Host capability | Use |
+|---|---|
+| Claude Code `EnterWorktree` / `ExitWorktree` | Enter/leave a governed worktree in-session; scope lock is written right after enter |
+| Claude Code subagent `isolation: "worktree"` | Dispatch a slice into its own auto-managed worktree; unchanged worktrees are auto-cleaned by the host — the unique-commit gate still applies to any it leaves behind |
+| No worktree primitive (other hosts) | Degrade to plain `git worktree add` per [`using-git-worktrees`](../using-git-worktrees/SKILL.md) § Procedure — same scope lock, same gates |
+
+The mapping changes only who creates the directory. Scope lock,
+merge-ready checklist, and cleanup gates are host-independent.
+
+## Gotcha
+
+* **`git log <branch> --not --all` is always empty** — `--all` includes
+  the branch itself, so the naive check never fires. The
+  `--exclude="refs/heads/<branch>" --all` variant is also unreliable
+  when combined with `--not` (observed on git 2.39). Use the
+  `for-each-ref` expansion above — it enumerates every ref except the
+  branch explicitly.
+* **Scope note committed by accident** — `.worktree-scope.md` must be
+  in `.git/info/exclude`; `.gitignore` would be a tracked change
+  outside the scope lock.
+* **"Unchanged worktree" ≠ "no unique commits"** — a host auto-clean
+  only covers worktrees with no changes; a worktree with committed but
+  unmerged work still needs the unique-commit gate.
+* **Stale ahead/behind** — always `git fetch` before the
+  `rev-list --left-right` count; a cached view reports merge-ready on
+  a diverged branch.
+
+## Output format
+
+1. **Worktree** — path + branch, and the scope-lock `owns:` list
+2. **State** — clean/dirty, ahead/behind vs base, merge-ready verdict
+   with the failing checklist item named when not ready
+3. **Evidence** — verification command(s) run + result tail, or
+   "none attached" stated explicitly
+4. **Next step** — merge path, missing verification, or cleanup verdict
+   (allowed / refused with the unique-commit list)
+
+## Do NOT
+
+* NEVER remove a worktree whose branch has commits on no other ref
+* NEVER `git worktree remove --force` past a dirty tree
+* NEVER drop, rebase-out, or reset-away inherited commits (rule
+  `git-history-discipline`)
+* NEVER report merge-ready without fresh verification evidence
+* NEVER edit outside the scope-lock `owns:` paths without surfacing it
+
+## Handover
+
+| Task | Skill / command |
+|---|---|
+| Creating the worktree (ignore-safety, baseline) | [`using-git-worktrees`](../using-git-worktrees/SKILL.md) |
+| Divergence recovery, safe squash, PR flow | [`git-workflow`](../git-workflow/SKILL.md) |
+| Finishing the branch | `finishing-a-development-branch` |
+| Day-to-day operations | `/worktree create` · `status` · `verify` · `cleanup` |

package/dist/agent-src/skills/worktree-lifecycle/evals/triggers.json

@@ -0,0 +1,52 @@
+{
+    "skill": "worktree-lifecycle",
+    "last_eval": "2026-07-10",
+    "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers DE + EN phrasings for worktree governance (scope lock, merge-readiness status, scoped verification, safe cleanup). Should-not-trigger covers the near-miss neighbours (plain branch switch, git-worktree info question, subagent-orchestration mode selection, worktree creation mechanics, remote branch deletion) whose vocabulary overlaps.",
+    "queries": [
+        {
+            "q": "declare a scope lock for this worktree before I start editing",
+            "trigger": true
+        },
+        {
+            "q": "is this worktree merge-ready? check dirty state, ahead/behind and verification evidence",
+            "trigger": true
+        },
+        {
+            "q": "clean up the finished worktrees but make sure no unmerged commits get lost",
+            "trigger": true
+        },
+        {
+            "q": "welche Worktrees sind noch aktiv, und welche Pfade gehören welchem Worktree?",
+            "trigger": true
+        },
+        {
+            "q": "run the scoped verification for the change in this worktree, not the full CI",
+            "trigger": true
+        },
+        {
+            "q": "switch to the feature branch and continue working there",
+            "trigger": false,
+            "note": "plain branch switch, no worktree governance → git-workflow"
+        },
+        {
+            "q": "what does the output of git worktree list mean?",
+            "trigger": false,
+            "note": "git info question, not lifecycle governance"
+        },
+        {
+            "q": "which subagent-orchestration mode should I pick for these three independent tasks?",
+            "trigger": false,
+            "note": "mode selection → subagent-orchestration; worktrees only enter after a mode is chosen"
+        },
+        {
+            "q": "spawn a worktree with ignore-safety checks and a clean test baseline for this refactor",
+            "trigger": false,
+            "note": "creation mechanics → using-git-worktrees"
+        },
+        {
+            "q": "delete the old release branch on origin",
+            "trigger": false,
+            "note": "remote branch deletion, no worktree involved → git-workflow (permission-gated)"
+        }
+    ]
+}

package/dist/agent-src/templates/agents/agent-project-settings.example.yml

@@ -39,7 +39,7 @@ schema_version: 1
 # CI guard: a release bump of `package.json` must update this value
 # in lockstep — see scripts/check_template_pin_drift.ts (road-to-
 # portable-runtime-and-update-check P3.3).
-agent_config_version: "8.9.0"
+agent_config_version: "8.10.0"
 
 # --- Project identity ---
 project:

package/dist/discovery/deprecation-report.md

@@ -1,6 +1,6 @@
 # Discovery — Deprecation Report
 
-- Generated: `2026-07-10T10:26:10Z`
+- Generated: `2026-07-10T18:19:22Z`
 - Deprecated artefacts: **0**
 
 _None. Tree is clean._