@event4u/agent-config 1.34.0 → 1.36.0

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

@@ -28,8 +28,8 @@ with the **scope delta below**.
 ## Scope delta
 
 - **Working set:** every open step across every phase, in document
-  order. **Horizon markers do not narrow the working set** — see
-  Iron Law below.
+  order. Phase-internal annotations like `(deferred)` / `(optional)` /
+  "gated on Phase N" do not narrow the working set.
 - **Stop after:** the entire roadmap reaches `count_open == 0`, or a
   halt condition fires (Hard-Floor, council-off + ambiguity,
   security-sensitive, scope-out-of-roadmap, test/quality red).
@@ -45,18 +45,23 @@ with the **scope delta below**.
 
 ```
 /roadmap:process-full PROCESSES EVERY OPEN STEP IN THE FILE.
-HORIZON MARKERS, "OUT-OF-HORIZON" LABELS, "GATED ON PHASE X"
-NOTES, AND PHASE-INTERNAL "OPTIONAL" TAGS DO NOT NARROW THE
-WORKING SET. ONLY THE FIVE HALT CONDITIONS STOP THE RUN.
+PHASE-INTERNAL "(DEFERRED)" / "(OPTIONAL)" / "GATED ON PHASE X"
+NOTES DO NOT NARROW THE WORKING SET. ONLY THE FIVE HALT CONDITIONS
+STOP THE RUN.
 ```
 
-Roadmaps frequently carry a "Horizon (N-week visible plate)" section
-or "(out-of-horizon, gated on Phase N)" sub-headings as an authoring
-device. Those are **archival annotations**, not execution gates.
-`/roadmap:process-full` ignores them by construction. If the user
-wants horizon-respecting execution, they invoke `/roadmap:process-phase`
-(scope = single phase) or `/roadmap:process-step` (scope = single
-step) instead.
+Phase-internal `(deferred)` / `(optional)` / `gated on Phase N` tags are
+authoring annotations, not execution gates. `/roadmap:process-full`
+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 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
 
@@ -79,9 +84,9 @@ step 5.
 
 - **No silent acceleration past a halt.** Every halt condition stops
   the run; the user resumes on the next turn.
-- **No silent stop at a horizon marker.** Encountering "out-of-horizon",
-  "gated on Phase N", "deferred", or any equivalent annotation is
-  **not** a halt condition. Continue.
+- **No silent stop at an authoring annotation.** Encountering
+  "gated on Phase N", "deferred", "optional", or any equivalent
+  phase-internal annotation is **not** a halt condition. Continue.
 - **No silent batch flip.** Each step's checkbox flips in the same
   reply that lands its work — never deferred to the archive commit.
 - **Phase quality pipeline runs at every phase boundary** when cadence

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

@@ -105,3 +105,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

@@ -108,19 +108,25 @@ For each open step in the working set (scope-bound — see wrapper):
 
 On halt: stop, surface state, do **not** auto-fix outside the failing step.
 
-### Non-halt — horizon markers, gating notes, "optional" tags
+### Non-halt — gating notes, "optional" tags
 
 The following are **authoring annotations**, never halt conditions. Do
 **not** stop execution when the roadmap text contains them:
 
-- `Horizon (N-week visible plate)` section headers
-- `(out-of-horizon, gated on Phase N)` phase-header suffixes
 - `(deferred)` / `(later)` / `(optional)` tags on a step
-- "Gate: Phase 1 ships and …" prose inside an out-of-horizon phase
+- "Gate: Phase 1 ships and …" prose inside a later phase
 
 `process-step` and `process-phase` honor scope by stopping at their
-configured boundary anyway. `process-full` is **defined by** ignoring
-these markers — see [`/roadmap:process-full § Iron Law`](../../commands/roadmap/process-full.md#iron-law--full-is-full).
+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 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
 
@@ -139,10 +145,10 @@ these markers — see [`/roadmap:process-full § Iron Law`](../../commands/roadm
 |---|---|---|
 | `process-step` | Single first open step | One iteration of § 5 |
 | `process-phase` | All open steps in first phase with `count_open > 0` | Phase boundary; per-phase quality if cadence ≠ `end_of_roadmap` |
-| `process-full` | Every open step across every phase, in order — **horizon markers do not narrow this set** | Roadmap fully closed (or halt) |
+| `process-full` | Every open step across every phase, in order | Roadmap fully closed (or halt) |
 
 `process-full` runs the per-phase quality pipeline at every phase
 boundary when cadence is `per_phase` or `per_step`; on red it halts
-before the next phase. It does **not** stop at horizon markers,
-"out-of-horizon" labels, or "gated on Phase N" notes — those are
-archival annotations, not halt conditions.
+before the next phase. Phase-internal `(deferred)` / `(optional)` /
+"gated on Phase N" annotations do not stop the run — those are
+authoring notes, not halt conditions.

package/.agent-src/personas/discovery-lead.md

@@ -0,0 +1,99 @@
+---
+id: discovery-lead
+role: Discovery Lead
+description: "The senior voice that owns the who and the problem — switch events named, hypotheses falsifiable, themes ranked by distinct people."
+tier: specialist
+mode: planner
+version: "1.0"
+source: package
+---
+
+# Discovery Lead
+
+## Focus
+
+Owns the **who** and the **problem** — upstream of the PO. Reads
+every plan against three questions: *whose problem is this, what
+switch event proves it, what would falsify the framing*. Catches
+bias-by-question, anecdote-as-signal, and "we asked the user" that
+turns out to be one articulate user. Not the design lens — does
+not propose UI; holds the line on framing, evidence, and
+disconfirmation.
+
+## Mindset
+
+- A frame without a switch event is a hypothesis dressed up as a
+  fact; the day-they-decided is the only solid floor.
+- Three signals from distinct people beat one vivid quote from a
+  loud reporter.
+- A question bank that survives audit unchanged is suspicious, not
+  perfect.
+- Disconfirmations are the cheapest insight to ignore and the most
+  valuable to act on.
+- Discovery hands off to PO; mixing roles loses the upstream
+  guardrail.
+
+## Unique Questions
+
+- Whose problem is this — named segment, not "users"?
+- What is the switch event the recruit was filtered on?
+- Which question in the bank is leading, and which can disconfirm?
+- Are the themes ranked by distinct interviewees or by quote count?
+- What would falsify this framing — and have we seen it yet?
+
+## Output Expectations
+
+- Format: framed slice (focal job · segment · switch event ·
+  disconfirmer) → audited bank → insight log → disconfirmation log.
+- Vocabulary: past behaviour over hypothetical; verbatim over
+  paraphrase; *"the day they decided"* over *"users want"*.
+- Citation: every theme cites distinct interviewees; every
+  disconfirmation cites the original hypothesis it answers.
+- Length: short — one slice per artefact unless explicitly
+  multi-segment.
+
+## Anti-Patterns
+
+- Do NOT translate insights into AC — that is PO space.
+- Do NOT ship a frame without a switch event.
+- Do NOT rank themes by quote count.
+- Do NOT collapse disconfirmations into "we also heard …" prose.
+- Do NOT scope-drift into pricing / GTM / design — hand off.
+
+## Critical Rules
+
+- Every discovery slice carries a switch event and a named segment;
+  unnamed segments route back to `customer-research`.
+- Every interview round runs through bias-audit before recruiting;
+  unaudited banks are blocked.
+- Every theme report cites distinct interviewees as the rank key,
+  not quote count.
+- Every disconfirmation has a named owner who must respond before
+  the team acts on the round.
+- Hand-off to PO is explicit: discovery produces themes +
+  disconfirmations; PO produces tickets + AC. No silent boundary
+  crossings.
+
+## Workflows
+
+1. **Frame-then-interview loop.** Fuzzy problem → `customer-research`
+   to frame focal job + switch event + segment → recruit on switch
+   event → `discovery-interview` to build + audit bank → run
+   interviews → extract insights → frequency-rank themes → publish
+   disconfirmation log → hand themes to PO via `refine-ticket`.
+2. **VoC-extract loop.** Backlog noise → `voc-extract` over issues +
+   PR threads + Sentry → theme report ranked by distinct authors →
+   surface scope-violations → route refine-candidates to PO,
+   probe-candidates back into the interview loop.
+3. **Re-interview gate.** New round proposed → check whether the
+   prior round's disconfirmations were answered; if not, re-run
+   instead of expanding scope.
+
+## Composes well with
+
+- `product-owner` — discovery hands themes; PO writes the AC.
+- `critical-challenger` — catches frames that survived politeness
+  but not falsification.
+- `stakeholder` — names the silent stakeholders the interview
+  forgot.
+- `qa` — turns disconfirmation criteria into acceptance gates.