@event4u/agent-config 1.35.0 → 1.36.1

package/.agent-src/commands/memory/load.md

@@ -41,6 +41,41 @@ in the entry count and the signal-to-noise degrades fast on large types.
 > 6. ownership
 ```
 
+### 1b. Surface the Tier-0 critical slice
+
+Before loading the requested type, emit every active entry with
+`priority: critical` across **all** memory types as a Tier-0 banner.
+The contract for `priority: critical` is *always-surface regardless of
+query*; this step honours it.
+
+```bash
+./agent-config memory:lookup --priority critical --status active --format yaml
+```
+
+Render the slice in a fenced block titled `Tier-0 (critical)`, ordered
+by `(type, id)`. If the slice is empty, skip the banner silently — do
+not announce absence.
+
+If the lookup helper does not yet support `--priority`, fall back to a
+file-only sweep:
+
+```bash
+python3 - <<'PY'
+import pathlib, yaml
+for f in sorted(pathlib.Path("agents/memory").rglob("*.yml")):
+    data = yaml.safe_load(f.read_text(encoding="utf-8")) or {}
+    for e in data.get("entries", []) or []:
+        if e.get("priority") == "critical" and e.get("status") == "active":
+            print(f"--- {f.parent.name}/{e.get('id')}")
+            print(yaml.safe_dump(e, sort_keys=False), end="")
+PY
+```
+
+The Tier-0 slice is surfaced once per `/memory:load` invocation, even
+when the user picks a type with no critical entries — the slice spans
+types deliberately. Token cost is bounded by the soft cap of 10
+critical entries per type (warned by `scripts/check_memory.py`).
+
 ### 2. Warn about volume
 
 Before loading, count the entries:
@@ -84,6 +119,40 @@ with its declared `confidence` — see
 [`memory-access`](../../docs/guidelines/agent-infra/memory-access.md) for
 how entries modulate edits.
 
+### 5. Inline-review hook (intake backlog)
+
+After step 4, count unreviewed intake entries for the same type:
+
+```bash
+./agent-config memory:lookup --types <type> --intake-only --format json | \
+  python3 -c "import sys, json; print(len(json.load(sys.stdin)))"
+```
+
+Read `memory.review_threshold` from `.agent-settings.yml` (default 10).
+If the count is **0** or **≤ threshold**, skip this step silently. If
+**> threshold**, surface a numbered preview of the top-3 highest-
+confidence intake signals (see
+[`memory-consolidation`](../../skills/memory-consolidation/SKILL.md)
+§ Phase 3 for the consolidation contract):
+
+```
+> ⚠️  {N} unreviewed intake signals for `{type}` (threshold {T}).
+>     Top 3 by confidence:
+>
+>     1. [conf=high] {sig-id} — {one-line observation}
+>     2. [conf=med ] {sig-id} — {one-line observation}
+>     3. [conf=med ] {sig-id} — {one-line observation}
+>
+> Review now?
+> 1. Promote — run /memory promote on a signal id
+> 2. Mine more — run /memory mine-session for fresh signals
+> s. Skip (default) — proceed with the loaded entries
+```
+
+Default action is **skip** — the load completes regardless. This is a
+nudge, not a gate. If `memory.review_threshold` is `0`, skip this
+step entirely (feature off). Never auto-promote.
+
 ## When to reject
 
 - User is mid-implementation and asks for the full load as a shortcut

package/.agent-src/commands/memory/mine-session.md

@@ -0,0 +1,151 @@
+---
+name: memory:mine-session
+cluster: memory
+sub: mine-session
+description: Mine the active session transcript for memory signals (corrections, preferences, decisions, recurring patterns) — preview-by-default, opt-in transcript access, host-agnostic via TranscriptAdapter.
+skills: [memory-consolidation, file-editor]
+disable-model-invocation: true
+suggestion:
+  eligible: false
+  rationale: "Reads transcript files — opt-in, per-invocation confirmation required."
+---
+
+# /memory mine-session
+
+Runs the **GATHER SIGNAL** phase of the [`memory-consolidation`](../../skills/memory-consolidation/SKILL.md)
+loop against the current host's transcripts and surfaces normalised
+project-scoped facts as a preview. No file is written without
+`--commit-intake`. No transcript is read without
+`--confirm-transcript-access`.
+
+## When to use
+
+- After a multi-day implementation, before the conversation history
+  rotates out of context.
+- The user says "mine my recent sessions" or "consolidate what we've
+  decided".
+- The `/memory load` inline-review block flagged > 10 unreviewed signals
+  and the user wants to add fresh ones from the live transcript before
+  promoting.
+
+Do NOT use as an automatic post-session hook. Mining is per-invocation
+and confirmed.
+
+## Flags
+
+| Flag | Default | Purpose |
+|---|---|---|
+| `--since <ISO-date>` | 14 days ago | Only mine turns at or after this date. Re-anchors relative phrases like "yesterday" with `YYYY-MM-DD`. |
+| `--confirm-transcript-access` | off | Opt-in gate. Without it, the miner reads zero turns and prints the opt-in hint. Per-invocation, not persistent. |
+| `--preview` | on | Render normalised facts to stdout. No file write. Default behaviour. |
+| `--commit-intake` | off | Mutually exclusive with `--preview`. Append normalised facts to `agents/memory/intake/<primary-tag>.jsonl`. |
+| `--host <claude-code\|cursor\|augment>` | auto-detect | Force the `TranscriptAdapter`. Phase 1 ships `claude-code` only; others print `not-supported-on-this-host` and exit. |
+
+## Steps
+
+### 1. Verify opt-in
+
+If `--confirm-transcript-access` is absent, print:
+
+```
+> Mining reads your session transcript files. Re-run with
+> --confirm-transcript-access to proceed. The flag is per-invocation
+> and not persisted.
+```
+
+Then exit with code 0. **Do not read any file.**
+
+### 2. Resolve TranscriptAdapter
+
+Auto-detect the host (Claude Code → `~/.claude/projects/<repo>/sessions/*.jsonl`).
+If auto-detect fails or `--host` names an unimplemented adapter, print:
+
+```
+> No TranscriptAdapter for host=<name>. Phase 1 supports: claude-code.
+> Use /memory propose to record signals manually.
+```
+
+Then exit with code 0.
+
+### 3. Stream + extract
+
+Iterate transcript turns within the `--since` window through the four
+signal regex families documented in
+[`memory-consolidation`](../../skills/memory-consolidation/SKILL.md)
+§ Phase 2. For each match, normalise the fact (strip pronouns, IDE
+chrome, timestamps, turn-id) and assign a primary tag from the
+schema-routing table.
+
+If the normalised count exceeds 5, **stop after the 5th** and print:
+
+```
+> ⚠️  Miner produced > 5 facts. Tighten patterns or narrow --since.
+>     Showing the first 5; the rest are dropped.
+```
+
+This is the strict-gate exit per the skill's exit criteria.
+
+### 4. Render preview
+
+Print one Markdown block to stdout:
+
+```
+## Mining preview — <project> · <window> · host=<name>
+
+| # | Tag | Key | Observation | Source turn |
+|---|---|---|---|---|
+| 1 | convention | <symbol> | <one-line fact> | <ts> |
+| 2 | gotcha     | <path>   | <one-line fact> | <ts> |
+
+Schemas touched: conventions, operational-gotchas
+Stale curated entries (last_validated > 90d, not seen in 30d): <list or "none">
+```
+
+If `--preview` (default), stop here.
+
+### 5. Commit (only with `--commit-intake`)
+
+Append each fact as one JSONL line to
+`agents/memory/intake/<primary-tag>.jsonl` with the contract fields:
+`ts`, `type`, `key`, `observation`, `source: agent`,
+`session_id`, plus the optional `tags: [<one>, <two>]` field.
+
+Confirm:
+
+```
+✅ Appended <N> intake lines across <M> files.
+   Next: /memory promote to lift validated lines into curated YAML.
+```
+
+## Safety
+
+- **Never** writes outside `agents/memory/intake/`.
+- **Never** reads transcripts without `--confirm-transcript-access`.
+- **Never** synthesizes facts. The miner is a strict gate against
+  the four regex families; if zero matches → prints "no signals".
+- **Never** auto-promotes. `/memory promote` is a separate, validated
+  step.
+
+## Gotcha
+
+- `--commit-intake` and `--preview` are mutually exclusive. Passing
+  both → exit with usage error.
+- The `TranscriptAdapter` strips IDE chrome (tool-call boilerplate,
+  reasoning blocks, system reminders) before pattern matching. If the
+  miner under-counts, audit the adapter's redact list, not the regex.
+- Date-discipline: relative phrases (`yesterday`, `last week`) in the
+  observation field are rejected by `scripts/check_memory.py` unless
+  re-anchored with `YYYY-MM-DD` within ±20 chars. The miner re-anchors
+  automatically using the turn's `ts`; verify before commit.
+
+## See also
+
+- [`memory-consolidation`](../../skills/memory-consolidation/SKILL.md) — the
+  four-phase loop (ORIENT → GATHER → CONSOLIDATE → PRUNE) this command
+  implements GATHER SIGNAL for.
+- [`memory:propose`](propose.md) — manual fallback when no
+  `TranscriptAdapter` matches the current host.
+- [`memory:promote`](promote.md) — lifts validated intake lines into
+  curated YAML.
+- [`agent-memory-contract`](../../../docs/contracts/agent-memory-contract.md) —
+  intake JSONL schema, including the `tags` field.

package/.agent-src/commands/memory/promote.md

@@ -70,8 +70,43 @@ hydrate the full frontmatter:
   and well-validated — then `high`).
 - `source:` — at minimum the intake jsonl file + line number.
 - `owner:`, `last_validated: <today>`, `review_after_days:`.
+- `priority:` — optional (`critical` | `normal` | `low`); defaults to
+  `normal` when omitted. Pass through from the intake signal if it
+  carries one. Mark `critical` only when the entry is meant to surface
+  on every `/memory:load` regardless of query — e.g. a tenant-isolation
+  invariant or a payment-flow rule. The validator warns when a type
+  accumulates more than 10 active critical entries; raise the bar
+  deliberately. See [`engineering-memory-data-format`](../../docs/guidelines/agent-infra/engineering-memory-data-format.md)
+  § Priority semantics for the full contract.
+- `ts_week:` — optional ISO-week stamp `YYYY-Www` (e.g. `2026-W17`).
+  **Convention, not enforced.** Stamp the curated entry with the week
+  it was promoted, never the day or hour. ISO-week granularity prevents
+  intra-week timing inference (e.g. "this rule was added Tuesday 3pm
+  → that's when the incident hit") while keeping useful long-term
+  ordering. Write it via:
+  ```bash
+  date -u +'%G-W%V'   # POSIX ISO week-numbering year + ISO week
+  ```
+  See [`engineering-memory-data-format`](../../docs/guidelines/agent-infra/engineering-memory-data-format.md)
+  § Temporal jitter for rationale.
 - Type-specific fields (`rule`, `symptom`, `path`, …).
 
+If the intake signal carries `tags: [<one>, <two>]`, **resolve via tag
+intersection** (do not pick by file extension):
+
+| Tags on signal | Curated target |
+|---|---|
+| `[convention]` | `agents/memory/conventions.yml` |
+| `[invariant]` | `agents/memory/domain-invariants.yml` |
+| `[gotcha]` | `agents/memory/operational-gotchas.yml` |
+| `[pattern]` | `agents/memory/recurring-patterns.yml` |
+| `[gotcha, invariant]` | `domain-invariants` (invariant wins — structural beats operational) |
+| `[pattern, gotcha]` | `recurring-patterns` (pattern wins — repetition beats one-off) |
+| `[convention, invariant]` | `domain-invariants` (invariant wins) |
+
+If the user disagrees with the tag-intersection result, ask which
+schema to write to and record the override in the `source:` block.
+
 Show the YAML draft and ask for confirmation before writing.
 
 ### 4. Write the curated entry (content-addressed)

package/.agent-src/commands/memory/propose.md

@@ -62,6 +62,11 @@ Ask once, numbered. If the user picks `skip`, proceed without them:
 - `owner` (ownership)
 - `rule` (domain-invariants, product-rules)
 - `severity` — `low` · `medium` · `high`
+- `tags` — zero or more from `{convention, invariant, gotcha, pattern}`.
+  See [`memory-consolidation`](../../skills/memory-consolidation/SKILL.md)
+  § Phase 3 for the schema-routing table. Two tags are allowed; the
+  primary tag picks the intake JSONL file, the promoter resolves the
+  curated target via tag intersection.
 
 ### 4. Emit via the shared helper
 
@@ -71,9 +76,13 @@ Ask once, numbered. If the user picks `skip`, proceed without them:
     --path "<path>" \
     --body "<body>" \
     --origin "propose-memory" \
-    --extra '{"symptom":"...","severity":"medium"}'
+    --extra '{"symptom":"...","severity":"medium","tags":["convention"]}'
 ```
 
+The `tags` array is optional (default `[]`). When present, downstream
+consumers (`/memory promote`, `/memory load` inline review) use the
+schema-routing table to pick the curated target.
+
 The helper deduplicates identical `(type, path, body)` within 7 days
 automatically — re-running the command on the same finding will
 silently skip the write. Add `--force` only when deliberate duplication

package/.agent-src/commands/memory.md

@@ -1,6 +1,6 @@
 ---
 name: memory
-description: Memory orchestrator — routes to add, load, promote, propose
+description: Memory orchestrator — routes to add, load, mine-session, promote, propose
 cluster: memory
 disable-model-invocation: true
 suggestion:
@@ -20,6 +20,7 @@ commands with a single entry point + sub-command dispatch.
 |---|---|---|
 | `/memory add` | `commands/memory/add.md` | Interactively add a validated entry to a memory file |
 | `/memory load` | `commands/memory/load.md` | Load ALL curated entries of a given memory type into context |
+| `/memory mine-session` | `commands/memory/mine-session.md` | Mine the active session transcript for memory signals (preview-by-default) |
 | `/memory promote` | `commands/memory/promote.md` | Promote an intake signal to a curated memory entry |
 | `/memory propose` | `commands/memory/propose.md` | Append a provisional signal to the intake stream |
 
@@ -36,8 +37,9 @@ Sub-command names match the locked contract in
 
    > 1. add — write a curated entry interactively
    > 2. load — load ALL entries of a type for deep analysis
-   > 3. promote — promote an intake signal to a curated entry
-   > 4. propose — drop a provisional signal into the intake stream
+   > 3. mine-session — preview signals from the active session transcript
+   > 4. promote — promote an intake signal to a curated entry
+   > 5. propose — drop a provisional signal into the intake stream
 
 ## Rules
 

package/.agent-src/commands/roadmap/process-full.md

@@ -56,9 +56,12 @@ ignores them by construction. If the user wants narrower execution they
 invoke `/roadmap:process-phase` (scope = single phase) or
 `/roadmap:process-step` (scope = single step) instead.
 
-Time-boxed plate / horizon framing is forbidden in roadmaps by template
-rule 16 (`templates/roadmaps.md`). If a legacy roadmap still carries
-such phrasing, treat it as ordinary prose — never as a gate.
+Time-boxed plate / horizon framing is opt-in via
+`roadmap.horizon_weeks` in `.agent-settings.yml` (default `0` =
+forbidden, per template rule 16 in `templates/roadmaps.md`). If a
+roadmap carries such phrasing — whether by legacy or by an opt-in
+setting — treat it as ordinary prose during execution, never as a
+gate. Phase ordering and explicit dependency gates govern the loop.
 
 ## Iron Law — Real-time dashboard
 

package/.agent-src/contexts/authority/scope-mechanics.md

@@ -5,8 +5,9 @@ detail behind the Hard Floor restatement, the brief-before-asking
 flow for separate-branch proposals, and the failure modes / bypass
 rules around fenced steps.
 
-**Size budget:** ≤ 4,000 chars. Tracked under Phase 6 of
-`road-to-pr-34-followups`.
+**Size budget:** soft cap ≤ 8,000 chars (context layer, on-demand
+loaded). The mechanics file absorbs growth so `scope-control` stays
+under the 4,000-char kernel ceiling.
 
 ## Production, infrastructure, bulk-destructive — Hard Floor
 
@@ -40,6 +41,23 @@ permission is per-operation, this-turn. Standing autonomy directives
 narrow other rules but never grant permission for items in this Hard
 Floor subset.
 
+## Roadmap shape — no release language
+
+Forbidden in roadmaps / plans / tickets / any planning artifact:
+version numbers (`v2.0`, `1.4.x`), target releases (`Q4 release`,
+`Sprint 23`), deprecation dates tied to release calendars,
+release-tied milestones (`launch milestone`, `GA`), and git tags
+(`tag v1.2.0`).
+
+Roadmaps plan **work**. Releases / tags / version pins are a
+**separate decision** the user pins explicitly on the artifact that
+owns release shape — changelog, release PR, tag annotation — not
+buried inside a planning document. Authoring verbs (`create / draft /
+write the roadmap`) authorize the planning artifact, not version
+pinning inside it. If the user names a version in a planning
+request, ask whether the artifact tracks the work or the release;
+default to work.
+
 ## Brief-before-asking — separate branch / PR / worktree
 
 If a task seems to need a separate branch or PR (spike, hotfix,
@@ -105,3 +123,39 @@ benefits from a spike branch). If in doubt, do not ask.
 A clear *"go ahead"*, *"start now"*, *"mach weiter"*, or an explicit
 *"approved, implement E1.1"* on a later turn lifts the fence. Until
 then: silence on execution.
+
+
+## Authoring vs. implementation — verb discipline
+
+Restated detail for [`scope-control § Authoring vs.
+implementation`](../../rules/scope-control.md). The Iron Law is in
+the kernel; this is the worked-out catalogue.
+
+**Authoring verbs** (artifact-only, never execution): `create`,
+`draft`, `write`, `author`, `prepare`, `outline`, `entwirf`,
+`erstelle`, `schreibe`, `vorbereite`. Deliverable: a roadmap file,
+plan, ADR, ticket, design doc, or brief. Stop after it lands; let
+the user pick the next move.
+
+**Execution verbs** (then the executing rules apply): `implement`,
+`build`, `ship`, `setze um`, `baue`, `arbeite ab`, `arbeite die
+roadmap ab`.
+
+**Worked examples**
+
+- *"Create the roadmap for X"* / *"Erstelle die Roadmap für X"* →
+  write the roadmap file, stop, hand back. Do **not** start
+  implementing the steps it contains; do **not** create a feature
+  branch for the work the roadmap describes.
+- *"Draft an ADR for the auth refactor"* → ADR lands; auth refactor
+  is a separate decision.
+- *"Write the migration plan, then start with phase 1"* → mixed
+  verbs. Default to authoring-only, ask which scope wins.
+
+**Task-scoped autonomy carry-over**
+
+A previous turn's standing autonomy for a *different task* does NOT
+carry over. Concretely: *"arbeite eigenständig"* given for
+"Roadmap A" is consumed when Roadmap A's deliverable lands. A new
+named task (Roadmap B, ticket Y, "next slice") needs fresh
+authorization. See [`autonomous-execution § task-scope`](../../rules/autonomous-execution.md#task-scope--autonomy-is-bound-to-the-named-task).

package/.agent-src/contexts/execution/autonomy-detection.md

@@ -12,15 +12,15 @@ when the user expresses **"stop asking on trivial steps, just work"**.
 The LLM recognizes the **intent**, not a literal substring, and
 understands the semantic equivalent in either language.
 
-## Litmus test — standing permission vs single-decision delegation
+## Litmus test — three shapes, only one flips standing mode
 
-| Question | Outcome |
-|---|---|
-| Would a reasonable reader interpret the message as **standing permission to skip trivial workflow questions**? | Yes → flip. |
-| Is it a **single-decision delegation** ("you decide for this step", "for this one let me know what you'd pick")? | Handle that step autonomously, do **not** flip standing mode. |
+| Question | Shape | Outcome |
+|---|---|---|
+| Standing permission to skip trivial workflow questions, **no deliverable named**? ("stop asking", "just work") | conversation-wide | Flip standing mode. Sticky for the rest of the conversation. |
+| Autonomous execution **bound to a named deliverable** ("arbeite Roadmap X ab", "work end-to-end on PROJ-123", "build feature Y autonomously")? | task-scoped | Execute that deliverable without per-step asks. Do **not** flip standing mode. Scope ends with the deliverable. New task → fresh confirmation, per [`autonomous-execution § task-scope`](../../rules/autonomous-execution.md#task-scope--autonomy-is-bound-to-the-named-task). |
+| Single-decision delegation ("you decide for this step", "for this one let me know what you'd pick")? | one-shot | Handle that step autonomously. Do **not** flip standing mode. |
 
-The flip is sticky for the rest of the conversation; single-decision
-delegation is one-shot.
+Only the first shape is sticky for the conversation. The second is sticky only for the named task. The third is one-shot.
 
 ## Speech-act check — meta-instruction or content?
 

package/.agent-src/contexts/execution/roadmap-process-loop.md

@@ -120,8 +120,13 @@ The following are **authoring annotations**, never halt conditions. Do
 configured boundary anyway. `process-full` processes every open step
 regardless of these annotations — see
 [`/roadmap:process-full § Iron Law`](../../commands/roadmap/process-full.md#iron-law--full-is-full).
-Time-boxed plate / horizon framing is forbidden in roadmaps by template
-rule 16; if encountered in legacy text, treat as ordinary prose.
+Time-boxed plate / horizon framing is opt-in via
+`roadmap.horizon_weeks` in `.agent-settings.yml` (default `0` =
+forbidden, per template rule 16). When `0` and encountered in legacy
+text, treat as ordinary prose; never use it to gate execution. When
+`> 0`, plate framing is allowed in authoring but is still **not** a
+halt condition — phase ordering and explicit dependency gates govern
+execution either way.
 
 ## 6. Final report and archival
 

package/.agent-src/rules/autonomous-execution.md

@@ -32,6 +32,31 @@ In `auto` mode, flip to `on` for the rest of the conversation when the user expr
 
 Algorithm and speech-act heuristic: [`contexts/execution/autonomy-detection.md`](../contexts/execution/autonomy-detection.md). Anchor phrases (DE+EN), no-flip patterns, counter-examples, trivial-vs-blocking taxonomy, commit-policy summary, and named failure modes: [`contexts/execution/autonomy-mechanics.md`](../contexts/execution/autonomy-mechanics.md) + [`contexts/execution/autonomy-examples.md`](../contexts/execution/autonomy-examples.md).
 
+## Task-scope — autonomy is bound to the named task
+
+```
+A STANDING AUTONOMY DIRECTIVE TIED TO A NAMED DELIVERABLE
+DOES NOT CARRY OVER TO A DIFFERENT, LATER DELIVERABLE.
+NEW TASK → FRESH CONFIRMATION.
+```
+
+Two distinct autonomy shapes — keep them apart:
+
+| Shape | Trigger | Scope |
+|---|---|---|
+| **Conversation-wide trivial-question suppression** | "stop asking on trivial steps, just work" — no deliverable named. | Sticky for the rest of the conversation. Suppresses trivial workflow questions only; never lifts blocking, Hard Floor, or [`scope-control`](scope-control.md) gates. |
+| **Task-scoped autonomous execution** | "work autonomously on X", "arbeite die Roadmap Y komplett ab", "do PROJ-123 end-to-end" — a deliverable / artifact / ticket is named. | Bound to **that** task. Ends when the task ends. Does **not** authorize starting a new, distinct task autonomously. |
+
+Litmus test: does the directive name (or unambiguously point to) a single concrete deliverable? Yes → task-scoped, scope ends with the deliverable. No → conversation-wide, trivial-question suppression only.
+
+When the user later issues a **new** request — different ticket, different roadmap, different artifact, different feature — treat it as a fresh task. Re-confirm autonomy for the new scope before:
+
+- creating a branch / worktree / PR / tag for the new work,
+- implementing a roadmap whose **authoring** was the prior turn's deliverable (per [`scope-control § authoring vs implementation`](scope-control.md#authoring-vs-implementation--verb-discipline)),
+- expanding scope beyond the new task's literal ask.
+
+In doubt whether the new request inherits or needs fresh confirmation → fresh confirmation. The Hard Floor and [`scope-control`](scope-control.md) gates apply to every task regardless.
+
 ## See also
 
 - [`non-destructive-by-default`](non-destructive-by-default.md) — universal safety floor; never overridden by autonomy

package/.agent-src/rules/scope-control.md

@@ -28,19 +28,28 @@ The user decides the git shape. Never improvise. Commit specifics: canonical [`c
 - NEVER create / switch / delete a branch without explicit permission — includes spike, scratch, throwaway, worktree branches.
 - NEVER create, close, reopen, or change the target of a pull request without permission.
 - NEVER push a tag or create a release without permission.
-- NEVER include version numbers, target releases, deprecation dates, release-tied milestones, or git tags in roadmaps, plans, tickets, or any planning artifact. Roadmaps plan **work**; releases / tags are a separate decision. User pins by saying so explicitly.
+- NEVER pin versions, release targets, deprecation dates, or git tags in roadmaps / plans / tickets — they plan **work**, not releases. Detail: [`scope-mechanics § Roadmap shape`](../contexts/authority/scope-mechanics.md).
 - Task seems to need a separate branch / PR → STOP and **brief before asking** ([`scope-mechanics § Brief-before-asking`](../contexts/authority/scope-mechanics.md)).
 - BEFORE the first commit on related work, **inventory** existing branches and open PRs. Plausible base beyond the current branch → STOP and ask with numbered options — never improvise. Commands + 4-option template + diverging-stack failure mode: [`scope-mechanics § Branch-base inventory`](../contexts/authority/scope-mechanics.md).
 
 "Explicit permission" = user said so **this turn or in a standing instruction not yet revoked**. Earlier permission for a different operation does not carry over.
 
+## Authoring vs. implementation
+
+```
+"CREATE / DRAFT" AUTHORIZES THE ARTIFACT, NOT ITS EXECUTION.
+NEW TASK NEVER INHERITS PRIOR AUTONOMY.
+```
+
+`create / draft / write / erstelle …` → artifact only. Execution verbs flip scope; mixed → ask. Detail: [`scope-mechanics`](../contexts/authority/scope-mechanics.md).
+
 ## Production, infrastructure, bulk-destructive — Hard Floor
 
 A subset is **never** autonomous, regardless of standing autonomy. Canonical: [`non-destructive-by-default`](non-destructive-by-default.md). Triggers (prod-branch merges, deploys, prod data / infra, bulk-destructive) + this-turn-only clarification: [`scope-mechanics § Production, infrastructure, bulk-destructive`](../contexts/authority/scope-mechanics.md).
 
 ## Kernel-rule edits — slow-rollout guarantee
 
-Each kernel-rule edit ships in **its own PR**, ≥ 24 h between merges. Autonomous mandate does NOT lift this — soak guarantee, not preference. CI fails > 1 kernel rule per PR unless labeled `bundled-always-rules-acknowledged`. Trigger / scope: [`kernel-rule-edits`](../contexts/authority/kernel-rule-edits.md).
+Own PR, ≥ 24 h between merges. Autonomous mandate does not lift — soak guarantee. CI / labels / scope: [`kernel-rule-edits`](../contexts/authority/kernel-rule-edits.md).
 
 ## Decline = silence — no re-asking on the same task
 
@@ -48,13 +57,9 @@ After the user **declines** a proposal (branch switch, PR creation, tag/release,
 
 ## Fenced step — user-set review gates
 
-User explicitly fences off the next step (*"plan only"*, *"review first"*, *"don't implement yet"*, German equivalents) — reply is **deliverable + handoff**, never deliverable + *"shall we start?"*.
-
 ```
 USER FENCED OFF EXECUTION → DELIVER + HAND BACK.
-NO NUMBERED OPTION OFFERING TO BEGIN WORK.
-NO "READY TO IMPLEMENT?" RE-ASK.
-NO "STARTEN WIR MIT PHASE 1?" PIVOT.
+NO "READY TO IMPLEMENT?" / "PHASE 1?" RE-ASK.
 ```
 
-Fence stands until reopened (like `Decline = silence`). Follow-ups cover **the deliverable** (scope, wording, sections), never its execution. Failure modes + bypass phrases: [`scope-mechanics § Fenced step`](../contexts/authority/scope-mechanics.md).
+Fence (*"plan only"*, *"review first"*, German equivalents) stands until reopened — like `Decline = silence`. Follow-ups cover the deliverable, not its execution. Failure modes + bypass: [`scope-mechanics § Fenced step`](../contexts/authority/scope-mechanics.md).