@event4u/agent-config 1.16.0 → 1.18.0

package/docs/contracts/ui-track-flow.md

@@ -4,8 +4,7 @@ stability: beta
 
 # UI Track — Flow Contract
 
-> Technical contracts for the UI directive sets shipped under
-> [`road-to-product-ui-track.md`](../../agents/roadmaps/road-to-product-ui-track.md).
+> Technical contracts for the UI directive sets.
 > Sibling of [`implement-ticket-flow.md`](implement-ticket-flow.md) — that
 > doc covers `backend`; this one covers `ui`, `ui-trivial`, and the
 > `mixed` set that stitches both.
@@ -14,11 +13,10 @@ stability: beta
 > - **Status:** Phase 1–6 shipped — audit / design / apply / review /
 >   polish handlers live under
 >   [`.agent-src.uncompressed/templates/scripts/work_engine/directives/ui/`](../../.agent-src.uncompressed/templates/scripts/work_engine/directives/ui/).
->   Mixed (Phase 4) under `directives/mixed/`. `ui-trivial` (Phase 2 Step 6)
->   under `directives/ui_trivial/`. R4 (Visual Review Loop) added the
+>   Mixed under `directives/mixed/`. `ui-trivial` under
+>   `directives/ui_trivial/`. R4 (Visual Review Loop) added the
 >   a11y gate, the preview envelope, and a polish-termination rewrite
->   that splits subjective ceilings from objective a11y blocks — see
->   [`road-to-visual-review-loop.md`](../../agents/roadmaps/road-to-visual-review-loop.md).
+>   that splits subjective ceilings from objective a11y blocks.
 >   Golden Transcripts GT-U1..U4, U7, U8, U9..U12 plus GT-U5 (mixed
 >   flow), GT-U6A/B (stack dispatch), and R4's GT-U13..U15 (a11y polish,
 >   a11y ceiling, preview render failure) pin happy-path, ambiguity,
@@ -42,8 +40,6 @@ sentinels that release each gate.
   `SKILL.md` files.
 - A migration guide for the schema — see
   [`implement-ticket-flow.md`](implement-ticket-flow.md#state-schema-v1).
-- A roadmap — phased delivery lives in
-  [`road-to-product-ui-track.md`](../../agents/roadmaps/road-to-product-ui-track.md).
 
 ## The four directive sets
 
@@ -323,15 +319,9 @@ suite asserts every `BLOCKED` path has a matching declaration.
 - [`implement-ticket-flow.md`](implement-ticket-flow.md) — sibling
   contract for the `backend` set; covers `DeliveryState`, schema v1,
   hooks, persona policies, replay protocol.
-- [`road-to-product-ui-track.md`](../../agents/roadmaps/road-to-product-ui-track.md)
-  — phased delivery and Golden-Transcript matrix.
-- [`road-to-product-ui-track-followup.md`](../../agents/roadmaps/archive/road-to-product-ui-track-followup.md)
-  — pinned GT-U5 (mixed flow), GT-U6A/B (stack dispatch), GT-U7
-  (trivial happy path), GT-U8 (trivial reclassification).
-- [`road-to-visual-review-loop.md`](../../agents/roadmaps/road-to-visual-review-loop.md)
-  — R4 contract: a11y gate, preview envelope, polish-termination
-  rewrite. Pinned by GT-U13 (a11y polish), GT-U14 (a11y ceiling),
-  GT-U15 (preview render failure).
+- [`adr-product-ui-track.md`](adr-product-ui-track.md) — locked
+  decisions for the UI track (R3) and the visual-review-loop
+  amendment (R4: a11y gate, preview envelope, polish-termination).
 - [`existing-ui-audit` SKILL](../../.agent-src.uncompressed/skills/existing-ui-audit/SKILL.md)
   — producer of `state.ui_audit`.
 - [`ui-audit-gate` rule](../../.agent-src.uncompressed/rules/ui-audit-gate.md)

package/docs/customization.md

@@ -67,6 +67,8 @@ those sections.
 | `ai_council.cost_budget.max_total_usd` | `0.0` | Per-invocation USD ceiling. `0` disables (token caps still apply). |
 | `ai_council.cost_budget.daily_limit_usd` | `0.0` | Rolling 24h USD ceiling across all `/council` calls. `0` disables. Ledger lives at `~/.config/agent-config/council-spend.jsonl` (mode 0600). |
 
+> **Experimental.** AI Council is not yet validated by external users. API costs apply per consultation.
+
 Council API tokens are installed via `./agent-config keys:install-anthropic`
 and `./agent-config keys:install-openai` — they prompt on `/dev/tty`, write to
 `~/.config/agent-config/<provider>.key` with mode `0600`, and never accept env

package/docs/getting-started.md

@@ -115,7 +115,7 @@ Your agent is now:
 - **Respecting your codebase** — no conflicting patterns
 - **Following standards** — consistent code quality
 
-This is enforced automatically by 57 rules. No configuration needed.
+This is enforced automatically by 58 rules. No configuration needed.
 
 ---
 
@@ -155,7 +155,7 @@ Your agent now understands slash commands:
 | `/chat-history-resume` | Recover context after a crashed or switched session |
 | `/chat-history-clear` | Wipe the chat-history log (with confirmation) |
 
-→ [Browse all 69 active commands](../.agent-src/commands/)
+→ [Browse all 95 active commands](../.agent-src/commands/)
 
 ---
 
@@ -167,8 +167,9 @@ for every profile), the agent keeps a JSONL log of your conversation in
 rotates at the size configured in the profile (`128 KB` on `minimal`,
 `256 KB` on `balanced`, `512 KB` on `full`).
 
-When a chat opens and finds an existing log, the agent runs a
-4-state ownership check and chooses the right flow:
+When a chat opens and finds an existing log, the host agent is
+instructed to run a 4-state ownership check and choose the right
+flow:
 
 - **match** — this chat already owns the file. Append silently.
 - **foreign** — a different session's file. You get 3 options:

package/docs/guidelines/agent-infra/ask-when-uncertain-demos.md

@@ -0,0 +1,134 @@
+---
+demo_for: ask-when-uncertain
+layer: pattern-memory
+prose_delta:
+  rule_chars_before: 3893
+  rule_chars_after: 4267
+  measured_at: phase-3.3-cross-link-landing
+  note: "+374 chars from the Examples cross-link block; future prose-pruning rounds (out of scope for Phase 3) will pull pattern prose from the rule into this demo and drive the after-count below the before-count."
+---
+
+# ask-when-uncertain — Pattern Memory
+
+> Wrong / right / why demos for the `ask-when-uncertain` Iron Law
+> (one question per turn, vague-request must ask). Linked from
+> [`ask-when-uncertain`](../../.agent-src.uncompressed/rules/ask-when-uncertain.md)
+> § Examples. Outcome baseline at
+> [`tests/golden/outcomes/ask_when_uncertain.json`](../../tests/golden/outcomes/ask_when_uncertain.json).
+
+## Demo 1 — Vague request, multi-question stack
+
+### Wrong shape
+
+```
+User: improve this
+
+Agent:
+1. Should I optimize for readability or speed?
+2. Refactor the function signature?
+3. Add tests too?
+4. Run PHPStan after?
+
+Reply with a, b, c, d so I can pick.
+```
+
+**Failure mode:** four `?` aimed at the user, structured-answer
+demand (`a, b, c, d`), no triage. Iron Law breach: a turn with a
+question has *exactly one*. Compound thinking load — answer to Q1
+reframes Q2.
+
+### Right shape
+
+```
+User: improve this
+
+Agent: Welche Achse soll "improve" treffen?
+
+1. Lesbarkeit (Naming, Funktions-Splits)
+2. Performance (Allokationen, N+1)
+3. Robustheit (Error-Handling, Edge Cases)
+
+Dann lege ich los.
+```
+
+### Why it works
+
+Single `?`, numbered options without compound asks, picks the
+question whose answer reframes everything downstream. The follow-up
+("tests? PHPStan?") rides on the next turn — its framing depends on
+the answer here.
+
+## Demo 2 — Drive-by execution on a vague trigger
+
+### Wrong shape
+
+```
+User: clean up this file
+
+Agent: [edits 12 files, removes 200 lines, reformats imports,
+extracts 3 helpers, renames 5 variables]
+Done.
+```
+
+**Failure mode:** "clean up" is a vague-request trigger
+(`ask-when-uncertain` § Vague-request triggers). MUST-ask before
+touching code. Without scope, the diff is a guess at the user's
+intent.
+
+### Right shape
+
+```
+User: clean up this file
+
+Agent: Was bedeutet "clean up" hier?
+
+1. Toten Code raus
+2. Format / Imports sortieren
+3. Refactor (Funktionen splitten)
+
+Pick one — sonst ist der Diff Raten.
+```
+
+### Why it works
+
+Names the trigger explicitly ("vague-request"), surfaces the three
+canonical interpretations from the rule's trigger table, and
+declines to act without scope. The cost of asking once << cost of
+ripping through 12 files in the wrong direction.
+
+## Demo 3 — Stacked questions inside a handoff
+
+### Wrong shape
+
+```
+Agent: Bevor ich die Roadmap übergebe:
+
+- Welcher Branch?
+- Soll ich PRs erwähnen?
+- Welches Modell für die Fortsetzung?
+- Soll ich .agent-chat-history zitieren?
+
+Antworte als 1, 2, 3, 4.
+```
+
+**Failure mode:** four-question handoff block. Per § Ordering &
+handoff: handoff questions ride LAST, after domain clarifications,
+folded into the handoff prompt itself — not as a parallel quiz.
+
+### Right shape
+
+```
+Agent: [delivers the handoff prompt with sensible defaults filled
+in: current branch, PR link present if open, model
+recommendation per `model-recommendation`, history reference
+auto-included]
+
+Welche der vier Defaults soll ich vor dem Übergeben anpassen?
+```
+
+### Why it works
+
+Defaults absorb three of the four "questions"; the remaining
+question is the only one that genuinely needs user input — and it's
+phrased so a one-word answer ("PR link" / "model" / "passt") closes
+the loop.

package/docs/guidelines/agent-infra/asking-and-brevity-examples.md

@@ -0,0 +1,100 @@
+# asking-and-brevity-examples
+
+Companion examples for three always-rules:
+[`ask-when-uncertain`](../../../.agent-src.uncompressed/rules/ask-when-uncertain.md),
+[`no-cheap-questions`](../../../.agent-src.uncompressed/rules/no-cheap-questions.md),
+[`direct-answers`](../../../.agent-src.uncompressed/rules/direct-answers.md).
+
+The rules carry the Iron Laws and the obligation surface. This file
+carries the illustrative material (example questions, rationale
+tables, failure-mode catalogs) that does not need to live in the
+always-loaded rule body — extracted to fit the always-rule budget.
+
+## Vague-request triggers — example questions
+
+Companion to `ask-when-uncertain` § Vague-request triggers. The rule
+lists the trigger patterns and the "missing info" columns; this file
+adds the example question to ask back at the user.
+
+| Pattern | Example clarifying question |
+|---|---|
+| "improve / optimize this" | "Optimize for what — execution speed or readability?" |
+| "add caching" | "Which cache driver, and what invalidates it?" |
+| "make it better / cleaner" | "What specifically feels wrong in the current code?" |
+| "clean up this file" | "Remove unused code, reformat, or restructure?" |
+| "fix this" (without specifying) | "What output/behavior is wrong right now?" |
+| "refactor X" | "Refactor toward what — smaller methods, extract class, or something else?" |
+| "use best practices" | "Best practices for what specifically — testing, naming, structure?" |
+| "handle errors properly" | "For which failure modes, and what should happen on error?" |
+| "add a UI / component / tile / page" when the repo mixes frameworks | "This repo uses {A} and {B} for UI — which one for this?" |
+
+## One-question-per-turn — why serial always wins
+
+Companion to `ask-when-uncertain` § How to ask. The rule states the
+Iron Law and the self-check; this file expands the rationale.
+
+| Situation | Why serial always wins |
+|---|---|
+| Design / architecture decisions | Answer to Q1 reframes Q2 |
+| Naming / command-syntax / API shape | Later choices depend on it |
+| Scope / PR boundaries | Changes what the other questions even mean |
+| Tool / library selection | Downstream choices branch from it |
+| "Which approach: A vs B vs C" | Each answer opens a different follow-up |
+| Even "independent" yes/no pairs | User still has to parse two contexts |
+| Any question the user has to **think** about, not just pick | Thinking load compounds when stacked |
+
+The shorthand: if the user has to *think* about an answer, that
+answer almost always reframes whatever question would have come
+next. Serial preserves the framing; parallel destroys it.
+
+## Cheap-question class catalog — extended examples
+
+Companion to `no-cheap-questions` § What counts as cheap. The rule
+lists the classes; this file adds longer-form examples per class.
+
+| Class | Pattern · why cheap | Concrete example |
+|---|---|---|
+| **Sequencing** | "Step 2 or 3 next?" when roadmap orders them — answer is in the roadmap | Roadmap says "2.1 then 2.2" → don't ask "should I do 2.2 next?" |
+| **Format-only** | "Table or paragraph?" — no semantic trade-off | User asked for a summary; format is a non-decision |
+| **Commit asks** | "Commit now?" — `commit-policy`: never ask | The commit-policy Iron Law forbids the question |
+| **CI / test asks** | "Run tests now?" — `verify-before-complete` decides | Verification is mandatory before completion claims; not a choice |
+| **Fenced-step re-asks** | "Start Phase 1?" after "plan only" — `scope-control § fenced step` | The fence stands until the user explicitly lifts it |
+| **Iron-Law option** | Option breaches `commit-policy`, `scope-control § git-ops`, or `non-destructive-by-default` — does not exist | Don't surface "force-push to main?" as Option 2 |
+| **Context-derived** | Answer follows from prior turn / standing instruction / roadmap — act, state assumption inline | "Use the same branch?" after user said "stay on this branch" |
+| **Dominant option** | One choice obviously correct; alternatives carry no upside — pick it | "Run the linter or skip it?" when the linter is part of CI |
+| **Re-ask after decline** | Same path after user said no — `scope-control § decline = silence` | User declined a separate branch → don't propose it again on the same task |
+
+## Direct-answers — severity-tiered claim examples
+
+Companion to `direct-answers` § Iron Law 2 (no invented facts). The
+rule lists the severity table; this file adds concrete examples and
+hedge-language patterns.
+
+| Severity | Examples | Verification action |
+|---|---|---|
+| **High — load-bearing** | "Method `X::y()` exists at `path/to/file.php:142`", "version 12.4.1 added the API", "this test passes" | MUST verify with `view`, `grep`, `codebase-retrieval`, or fresh command output **before** claiming. Too expensive → ask. |
+| **Medium — project-shape** | "This project uses Pest for testing", "controllers live under `app/Http/Controllers`" | Verify if one tool call reaches it; otherwise hedge: *"I'd guess X — not checked"*. |
+| **Low — well-known idioms** | "PHP `array_map` returns a new array", "git tags are immutable", "JS arrays are zero-indexed" | Inference acceptable. Mark as inference if not 100% sure. |
+
+Hedge-language patterns:
+
+- ✅ "haven't verified X — likely from {known-similar-codebase}"
+- ✅ "guess, not checked — `path/to/file.php:142` is my best read"
+- ❌ "probably" alone — name what's unverified
+- ❌ "vermutlich" without hedge target
+
+## Direct-answers — failure modes the user will call out
+
+Companion to `direct-answers` § Failure modes. The rule lists the
+modes; this file adds the trigger phrases and the in-language
+correction pattern.
+
+| Failure | User's typical callout | Correct response |
+|---|---|---|
+| Iron Law 1 violation | "skip the flattery", "ohne smalltalk" | drop the opener; deliver substance |
+| Iron Law 2 violation | "have you actually checked?", "wo steht das?" | re-verify with a tool call; correct or retract the claim |
+| Iron Law 3 violation | "kürzer", "less prose", "tldr" | trim to one sentence + the answer |
+| Emoji blacklist hit | "ohne emojis", "no decoration" | re-render plain |
+
+Acknowledge once, in the user's language, switch behavior, no
+excuses (mirrors `language-and-tone` § slip handling).

package/docs/guidelines/agent-infra/direct-answers-demos.md

@@ -0,0 +1,145 @@
+---
+demo_for: direct-answers
+layer: pattern-memory
+prose_delta:
+  rule_chars_before: 4098
+  rule_chars_after: 4514
+  measured_at: phase-3.3-cross-link-landing
+  note: "+416 chars from the Examples cross-link block; future prose-pruning rounds (out of scope for Phase 3) will pull pattern prose from the rule into this demo and drive the after-count below the before-count."
+---
+
+# direct-answers — Pattern Memory
+
+> Wrong / right / why demos for the three Iron Laws of
+> `direct-answers` (no flattery, no invented facts, brevity by
+> default). Linked from
+> [`direct-answers`](../../.agent-src.uncompressed/rules/direct-answers.md)
+> § Examples. Outcome baseline at
+> [`tests/golden/outcomes/direct_answers.json`](../../tests/golden/outcomes/direct_answers.json).
+
+## Demo 1 — Flattery opener (Iron Law 1)
+
+### Wrong shape
+
+```
+User: Wie viele Always-Rules gibt es aktuell?
+
+Agent: Sehr gute Frage! Das ist tatsächlich eine spannende
+Eigenschaft des Systems. Lass mich das für dich aufschlüsseln —
+aktuell sind es 38 Always-Rules.
+```
+
+**Failure mode:** flattery opener ("Sehr gute Frage!"), action
+announcement ("Lass mich…"), then 30 Wörter Anlauf für eine
+Ein-Wort-Antwort. Iron Law 1 + Iron Law 3 zusammen verletzt.
+
+### Right shape
+
+```
+User: Wie viele Always-Rules gibt es aktuell?
+
+Agent: 38.
+```
+
+### Why it works
+
+Eine Frage mit einer wahren Antwort = ein Satz. Kein Anlauf, kein
+Kissen, kein "let me…". Die Zahl ist die ganze Antwort.
+
+## Demo 2 — Hedged claim without verification (Iron Law 2)
+
+### Wrong shape
+
+```
+User: Hat verify-before-complete ein "load_context"-Feld?
+
+Agent: Ja, ich glaube schon — die meisten Always-Rules haben das
+inzwischen. Sollte in der Frontmatter stehen.
+```
+
+**Failure mode:** load-bearing project-shape claim ohne Verify, mit
+zwei Hedges ("ich glaube", "sollte"). Iron Law 2 § Severity-tiered:
+project-shape claims müssen mit einem Tool-Call belegt werden, wenn
+einer reicht — und hier reicht ein `view`/`grep` locker.
+
+### Right shape
+
+```
+User: Hat verify-before-complete ein "load_context"-Feld?
+
+Agent: [grept frontmatter]
+Nein. `verify-before-complete.md` deklariert keinen load_context-
+Eintrag (nur die anderen vier Safety-Floor-Rules tun das).
+```
+
+### Why it works
+
+Tool-Call vor Antwort, dann konkrete Aussage mit Begründung. Wenn
+der Verify-Aufwand zu groß wäre → fragen, nicht raten. Hier kostet
+ein `grep` zwei Sekunden, also Tool-Call ist Pflicht.
+
+## Demo 3 — Post-hoc summary creep (Iron Law 3)
+
+### Wrong shape
+
+```
+User: Wie öffne ich die VBC-Demos?
+
+Agent: Hier der Pfad zur Datei:
+
+`docs/guidelines/agent-infra/verify-before-complete-demos.md`
+
+Zusammenfassend: das ist die Demo-Datei für die Iron Law des
+verify-before-complete-Rule. Sie folgt dem wrong/right/why-Schema
+und ist Teil der Phase 3 von road-to-context-layer-maturity.
+Lass mich wissen, falls du Fragen dazu hast.
+```
+
+**Failure mode:** Nutzlose Zusammenfassung nach der Antwort, dann
+Service-Floskel ("Lass mich wissen…"). Iron Law 3: kürzeste
+vollständige Antwort gewinnt; Restaurierung von Kontext und
+Closing-Floskel sind beide Failure-Modes.
+
+### Right shape
+
+```
+User: Wie öffne ich die VBC-Demos?
+
+Agent: `docs/guidelines/agent-infra/verify-before-complete-demos.md`
+```
+
+### Why it works
+
+Pfad ist die ganze Antwort. Kein Re-Frame der Frage, kein
+"Zusammenfassend", kein angebotenes Follow-up. Wenn Matze mehr
+will, fragt er.
+
+## Demo 4 — Functional emoji vs prose flair
+
+### Wrong shape
+
+```
+Agent: 🚀 Tests sind durch! ✨ Alle 47 grün 🎉 Bereit für den nächsten Schritt 💪
+```
+
+**Failure mode:** Emoji als Stil-Element, nicht als funktionaler
+Marker. § Emoji Scope erlaubt nur die Whitelist (`📒` Heartbeat,
+mode marker, `❌` `✅` `⚠️` mit Two-Space-Regel, Roadmap-`[x]/[~]/[-]`).
+Alles andere ist Rauschen.
+
+### Right shape
+
+```
+Agent: Tests durch:
+
+$ vendor/bin/pest -q
+............................................... 47 passed
+
+✅  47/47 grün, Exit 0.
+```
+
+### Why it works
+
+Genau ein Emoji aus der Whitelist (`✅` mit Two-Space), funktional
+verwendet als Status-Marker neben dem CLI-Output. Keine Deko, keine
+Reaktions-Emojis.

package/docs/guidelines/agent-infra/verify-before-complete-demos.md

@@ -0,0 +1,128 @@
+---
+demo_for: verify-before-complete
+layer: pattern-memory
+prose_delta:
+  rule_chars_before: 2196
+  rule_chars_after: 2603
+  measured_at: phase-3.3-cross-link-landing
+  note: "+407 chars from the Examples cross-link block; future prose-pruning rounds (out of scope for Phase 3) will pull pattern prose from the rule into this demo and drive the after-count below the before-count."
+---
+
+# verify-before-complete — Pattern Memory
+
+> Wrong / right / why demos for the `verify-before-complete` Iron
+> Law (no completion claim without fresh evidence in this message).
+> Linked from
+> [`verify-before-complete`](../../.agent-src.uncompressed/rules/verify-before-complete.md)
+> § Examples. Outcome baseline at
+> [`tests/golden/outcomes/verify_before_complete.json`](../../tests/golden/outcomes/verify_before_complete.json).
+
+## Demo 1 — Hedged completion claim
+
+### Wrong shape
+
+```
+User: ist der Fix fertig?
+
+Agent: Ja, sollte jetzt durchlaufen — ich habe die fehlende
+Bedingung ergänzt und die Tests müssten grün sein.
+```
+
+**Failure mode:** "sollte", "müssten" are red-flag hedges (§ Red
+flags — STOP immediately). No fresh command output in this message.
+The claim rides on inference, not evidence.
+
+### Right shape
+
+```
+User: ist der Fix fertig?
+
+Agent: Frisch gerade ausgeführt:
+
+$ python3 -m pytest tests/test_load_context.py -v
+============================== 7 passed in 0.07s ===============================
+
+Exit code 0, 7/7 grün. Damit ist der Fix verifiziert.
+```
+
+### Why it works
+
+Literal command line, fresh output, exit code, pass count — all in
+this message. The user can scroll up and see the same shape that
+the test runner produced. No hedging vocabulary.
+
+## Demo 2 — Trusting an earlier run
+
+### Wrong shape
+
+```
+[12 messages earlier, agent ran tests — green]
+
+User: also fertig zum committen?
+
+Agent: Ja, die Tests waren ja grün vorhin. Du kannst committen.
+```
+
+**Failure mode:** "Trusting a previous run from earlier in the
+conversation" — explicit red flag. Code drifted in the meantime;
+the earlier run is stale evidence.
+
+### Right shape
+
+```
+User: also fertig zum committen?
+
+Agent: Ich verifiziere kurz — Tests laufen jetzt:
+
+$ python3 -m pytest tests/ -q
+... 47 passed in 2.31s
+
+Grün. Plus ein quality-tools-Lauf:
+
+$ task ci
+... ✅  All checks passed
+
+Jetzt ist der Stand sauber.
+```
+
+### Why it works
+
+Re-runs both gates *now*. The `quality-tools` skill handles the
+specific commands; the rule only mandates "fresh in this message".
+"Stand sauber" is anchored on actual exit codes, not on memory.
+
+## Demo 3 — Partial verification claimed as complete
+
+### Wrong shape
+
+```
+User: ready für den PR?
+
+Agent: Tests sind grün, ich öffne den PR.
+```
+
+**Failure mode:** "Relying on partial verification (ran tests but
+not PHPStan)" — explicit red flag. PR-readiness needs the full
+gate, not a single channel.
+
+### Right shape
+
+```
+User: ready für den PR?
+
+Agent: Ich check beide Gates:
+
+$ vendor/bin/pest
+... 47 passed
+$ vendor/bin/phpstan analyse
+... [OK] No errors
+
+Beide grün. Soll ich den PR jetzt erstellen?
+```
+
+### Why it works
+
+Both gates run fresh, both outputs in the message, exit summaries
+visible. The follow-up question is permission-gated per
+`scope-control` § Git operations — the verification is done
+independently of the user's go-ahead.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@event4u/agent-config",
-    "version": "1.16.0",
+    "version": "1.18.0",
     "description": "Shared agent configuration \u2014 skills, rules, commands, guidelines, and templates for AI coding tools",
     "license": "MIT",
     "private": false,