@event4u/agent-config 2.12.0 → 2.13.0

package/scripts/ai_council/config.py

@@ -0,0 +1,368 @@
+"""Council configuration loader — single source of truth.
+
+Reads ``agents/.ai-council.yml`` per the contract in
+``docs/contracts/ai-council-config.md``. Replaces the fragmented
+``.agent-settings.yml`` ``ai_council`` block (Phase 0 migration).
+
+Validation contract (7 rules, all enforced at load time):
+
+1. ``enabled`` is a bool.
+2. ``defaults.mode`` ∈ {``api``, ``manual``}; per-member mode same set.
+3. ``members.<name>`` keys are restricted to the known provider set.
+4. ``cost_budget.*`` numeric fields are >= 0.
+5. Enabled members carry a non-empty ``model`` and ``api_key_ref``.
+6. ``api_key_ref`` starts with ``file:`` or ``env:`` — raw keys are
+   refused even if syntactically plausible.
+7. Resolved ``file:`` key paths must have mode 0o600 (delegated to
+   :func:`resolve_api_key`; runs at use-time, not parse-time).
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from scripts._lib import user_global_paths
+
+_VALID_PROVIDERS = frozenset({"anthropic", "openai", "gemini", "xai", "perplexity"})
+_VALID_MODES = frozenset({"api", "manual"})
+
+#: Prefixes that signal "this is a raw API key" so we refuse it loudly
+#: even when the user accidentally inlined it in ``api_key_ref``.
+_RAW_KEY_PREFIXES = ("sk-", "sk-ant-", "ya29.", "AIza", "xai-", "pplx-", "gsk_")
+
+
+class CouncilConfigError(RuntimeError):
+    """Raised when ``agents/.ai-council.yml`` violates the schema."""
+
+
+@dataclass(frozen=True)
+class DefaultsConfig:
+    mode: str = "api"
+    min_rounds: int = 2
+    deep_min_rounds: int = 3
+    max_output_tokens: int = 0
+    session_retention_days: int = 7
+    debate_max_rounds: int = 4
+
+
+@dataclass(frozen=True)
+class CostBudgetConfig:
+    max_input_tokens: int = 500_000
+    max_output_tokens: int = 200_000
+    max_calls: int = 50
+    max_total_usd: float = 20.0
+
+
+@dataclass(frozen=True)
+class MemberConfig:
+    name: str
+    enabled: bool
+    model: str
+    api_key_ref: str | None
+    mode: str | None = None
+
+
+@dataclass(frozen=True)
+class AdvisorConfig:
+    """Replace-mode advisor binding (Phase 6).
+
+    `member` names the provider whose plain call is replaced by this
+    advisor-persona call. `persona` is the path to the advisor persona
+    file (resolved relative to the package root). `model` is an
+    optional override of the bound member's plain model.
+    """
+
+    name: str
+    enabled: bool
+    member: str
+    persona: str
+    model: str | None = None
+
+
+@dataclass(frozen=True)
+class ConsensusScoringConfig:
+    """Consensus-scoring round settings (Phase 4 / F3).
+
+    Only the `analysis` lens activates the scoring round today. Other
+    lenses see this as inert config. Thresholds are inclusive on the
+    `strong` side (> strong → strong bucket) and exclusive on the
+    `minority` side (≤ minority → minority bucket); the middle bucket
+    is `(minority, strong]`. Defaults mirror the roadmap (0.7 / 0.4).
+    """
+
+    enabled: bool = False
+    strong_threshold: float = 0.7
+    minority_threshold: float = 0.4
+    lenses: tuple[str, ...] = ("analysis",)
+
+
+@dataclass(frozen=True)
+class CouncilConfig:
+    enabled: bool
+    defaults: DefaultsConfig
+    cost_budget: CostBudgetConfig
+    members: dict[str, MemberConfig]
+    advisors: dict[str, AdvisorConfig] = field(default_factory=dict)
+    consensus_scoring: ConsensusScoringConfig = field(
+        default_factory=ConsensusScoringConfig,
+    )
+    source_path: Path | None = None
+
+
+def load_council_config(path: Path) -> CouncilConfig:
+    """Load and validate the council YAML at ``path``."""
+    if not path.exists():
+        raise CouncilConfigError(
+            f"Council config not found at {path}. "
+            f"Create it per docs/contracts/ai-council-config.md."
+        )
+    try:
+        raw = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError as exc:
+        raise CouncilConfigError(f"{path}: invalid YAML — {exc}") from exc
+    if not isinstance(raw, dict):
+        raise CouncilConfigError(f"{path}: top-level must be a mapping.")
+    return _build_config(raw, source_path=path)
+
+
+def _build_config(raw: dict[str, Any], *, source_path: Path) -> CouncilConfig:
+    enabled = raw.get("enabled", False)
+    if not isinstance(enabled, bool):
+        raise CouncilConfigError("`enabled` must be a bool.")
+
+    defaults = _build_defaults(raw.get("defaults") or {})
+    cost_budget = _build_cost_budget(raw.get("cost_budget") or {})
+
+    members_raw = raw.get("members") or {}
+    if not isinstance(members_raw, dict):
+        raise CouncilConfigError("`members` must be a mapping.")
+    members: dict[str, MemberConfig] = {}
+    for name, cfg in members_raw.items():
+        members[name] = _build_member(name, cfg or {})
+
+    advisors_raw = raw.get("advisors") or {}
+    if not isinstance(advisors_raw, dict):
+        raise CouncilConfigError("`advisors` must be a mapping.")
+    advisors: dict[str, AdvisorConfig] = {}
+    for adv_name, adv_cfg in advisors_raw.items():
+        advisors[adv_name] = _build_advisor(adv_name, adv_cfg or {})
+
+    # Cross-validate enabled advisors against the members block. An
+    # advisor referencing a missing or disabled member is a hard error
+    # — never a silent skip — so a typo never costs the user money on
+    # an unintended call plan.
+    for adv in advisors.values():
+        if not adv.enabled:
+            continue
+        bound = members.get(adv.member)
+        if bound is None:
+            raise CouncilConfigError(
+                f"advisors.{adv.name}.member={adv.member!r}: no such "
+                f"member in the `members` block."
+            )
+        if not bound.enabled:
+            raise CouncilConfigError(
+                f"advisors.{adv.name}.member={adv.member!r}: member "
+                f"exists but is disabled. Enable the member or disable "
+                f"the advisor."
+            )
+
+    consensus = _build_consensus_scoring(raw.get("consensus_scoring") or {})
+
+    return CouncilConfig(
+        enabled=enabled,
+        defaults=defaults,
+        cost_budget=cost_budget,
+        members=members,
+        advisors=advisors,
+        consensus_scoring=consensus,
+        source_path=source_path,
+    )
+
+
+def _build_consensus_scoring(d: dict[str, Any]) -> ConsensusScoringConfig:
+    if not isinstance(d, dict):
+        raise CouncilConfigError("`consensus_scoring` must be a mapping.")
+    strong = float(d.get("strong_threshold", 0.7))
+    minority = float(d.get("minority_threshold", 0.4))
+    if not 0.0 <= minority <= strong <= 1.0:
+        raise CouncilConfigError(
+            f"consensus_scoring thresholds broken: require "
+            f"0 <= minority ({minority}) <= strong ({strong}) <= 1."
+        )
+    lenses_raw = d.get("lenses", ["analysis"])
+    if not isinstance(lenses_raw, list) or not all(isinstance(x, str) for x in lenses_raw):
+        raise CouncilConfigError("`consensus_scoring.lenses` must be a list of strings.")
+    return ConsensusScoringConfig(
+        enabled=bool(d.get("enabled", False)),
+        strong_threshold=strong,
+        minority_threshold=minority,
+        lenses=tuple(lenses_raw),
+    )
+
+
+def _build_defaults(d: dict[str, Any]) -> DefaultsConfig:
+    if not isinstance(d, dict):
+        raise CouncilConfigError("`defaults` must be a mapping.")
+    mode = d.get("mode", "api")
+    if mode not in _VALID_MODES:
+        raise CouncilConfigError(
+            f"defaults.mode={mode!r} not in {sorted(_VALID_MODES)}."
+        )
+    return DefaultsConfig(
+        mode=mode,
+        min_rounds=int(d.get("min_rounds", 2)),
+        deep_min_rounds=int(d.get("deep_min_rounds", 3)),
+        max_output_tokens=int(d.get("max_output_tokens", 0)),
+        session_retention_days=int(d.get("session_retention_days", 7)),
+        debate_max_rounds=int(d.get("debate_max_rounds", 4)),
+    )
+
+
+def _build_cost_budget(d: dict[str, Any]) -> CostBudgetConfig:
+    if not isinstance(d, dict):
+        raise CouncilConfigError("`cost_budget` must be a mapping.")
+    cb = CostBudgetConfig(
+        max_input_tokens=int(d.get("max_input_tokens", 500_000)),
+        max_output_tokens=int(d.get("max_output_tokens", 200_000)),
+        max_calls=int(d.get("max_calls", 50)),
+        max_total_usd=float(d.get("max_total_usd", 20.0)),
+    )
+    for fname in ("max_input_tokens", "max_output_tokens", "max_calls", "max_total_usd"):
+        val = getattr(cb, fname)
+        if val < 0:
+            raise CouncilConfigError(
+                f"cost_budget.{fname} must be >= 0 (got {val!r})."
+            )
+    return cb
+
+
+def _build_member(name: str, cfg: dict[str, Any]) -> MemberConfig:
+    if name not in _VALID_PROVIDERS:
+        raise CouncilConfigError(
+            f"members.{name}: unknown provider; valid: {sorted(_VALID_PROVIDERS)}."
+        )
+    member_enabled = bool(cfg.get("enabled", False))
+    model = cfg.get("model") or ""
+    api_key_ref = cfg.get("api_key_ref")
+    if member_enabled:
+        if not model:
+            raise CouncilConfigError(
+                f"members.{name}: enabled members require a non-empty `model`."
+            )
+        if not api_key_ref:
+            raise CouncilConfigError(
+                f"members.{name}: enabled members require an `api_key_ref`."
+            )
+    if api_key_ref is not None:
+        _validate_api_key_ref(f"members.{name}", api_key_ref)
+    member_mode = cfg.get("mode")
+    if member_mode is not None and member_mode not in _VALID_MODES:
+        raise CouncilConfigError(
+            f"members.{name}.mode={member_mode!r} not in {sorted(_VALID_MODES)}."
+        )
+    return MemberConfig(
+        name=name,
+        enabled=member_enabled,
+        model=model,
+        api_key_ref=api_key_ref,
+        mode=member_mode,
+    )
+
+
+def _build_advisor(name: str, cfg: dict[str, Any]) -> AdvisorConfig:
+    if not isinstance(cfg, dict):
+        raise CouncilConfigError(f"advisors.{name}: must be a mapping.")
+    member = cfg.get("member")
+    if member not in _VALID_PROVIDERS:
+        raise CouncilConfigError(
+            f"advisors.{name}.member={member!r} not a valid provider; "
+            f"valid: {sorted(_VALID_PROVIDERS)}."
+        )
+    # `persona` may be set explicitly; otherwise default to the
+    # convention path so the YAML stays terse.
+    persona = cfg.get("persona") or f"personas/advisors/{name}.md"
+    model = cfg.get("model")
+    if model is not None and not isinstance(model, str):
+        raise CouncilConfigError(
+            f"advisors.{name}.model must be a string when set."
+        )
+    return AdvisorConfig(
+        name=name,
+        enabled=bool(cfg.get("enabled", False)),
+        member=member,
+        persona=persona,
+        model=model,
+    )
+
+
+def _validate_api_key_ref(scope: str, ref: Any) -> None:
+    if not isinstance(ref, str) or not ref:
+        raise CouncilConfigError(f"{scope}.api_key_ref must be a non-empty string.")
+    if any(ref.startswith(prefix) for prefix in _RAW_KEY_PREFIXES):
+        raise CouncilConfigError(
+            f"{scope}.api_key_ref looks like a raw API key. "
+            f"Use `file:<path>` (0600) or `env:<VAR>` — never inline secrets."
+        )
+    if ref.startswith("file:"):
+        if not ref[len("file:"):].strip():
+            raise CouncilConfigError(f"{scope}.api_key_ref `file:` ref missing path.")
+        return
+    if ref.startswith("env:"):
+        if not ref[len("env:"):].strip():
+            raise CouncilConfigError(f"{scope}.api_key_ref `env:` ref missing variable name.")
+        return
+    raise CouncilConfigError(
+        f"{scope}.api_key_ref must start with `file:` or `env:` (got {ref!r})."
+    )
+
+
+def resolve_api_key(ref: str, *, scope: str = "api_key_ref") -> str:
+    """Resolve ``file:<path>`` or ``env:<VAR>`` to the raw key string.
+
+    ``file:`` — relative paths resolve under the user-global namespace
+    (``~/.event4u/agent-config/`` today, with the pre-2.4
+    ``~/.config/agent-config/`` tree read as a fallback). Mode must be
+    0o600. ``env:`` — reads from ``os.environ``; empty/missing is a
+    hard error. Never echoes the value.
+    """
+    _validate_api_key_ref(scope, ref)
+    if ref.startswith("env:"):
+        var = ref[len("env:"):].strip()
+        if not var:
+            raise CouncilConfigError(f"{scope}: `env:` ref missing variable name.")
+        value = os.environ.get(var, "").strip()
+        if not value:
+            raise CouncilConfigError(f"{scope}: env var {var!r} is unset or empty.")
+        return value
+    spec = ref[len("file:"):].strip()
+    if not spec:
+        raise CouncilConfigError(f"{scope}: `file:` ref missing path.")
+    path = Path(spec).expanduser()
+    if not path.is_absolute():
+        found = user_global_paths.resolve_with_fallback(spec)
+        if found is None:
+            target = user_global_paths.write_target(spec)
+            raise CouncilConfigError(
+                f"{scope}: key file not found at {target} (or legacy fallback)."
+            )
+        path = found
+    if not path.exists():
+        raise CouncilConfigError(f"{scope}: key file does not exist at {path}.")
+    mode = stat.S_IMODE(path.stat().st_mode)
+    if mode != 0o600:
+        raise CouncilConfigError(
+            f"{scope}: unsafe permissions on {path}: got {oct(mode)}, expected 0o600. "
+            f"Fix:  chmod 600 {path}"
+        )
+    value = path.read_text(encoding="utf-8").strip()
+    if not value:
+        raise CouncilConfigError(f"{scope}: key file at {path} is empty.")
+    return value
+

package/scripts/ai_council/consensus.py

@@ -0,0 +1,290 @@
+"""Consensus scoring for the analysis lens (Phase 4 / F3).
+
+After the final deliberation round, members score each other's
+findings. The renderer ranks findings by consensus and surfaces a
+"Minority Views" section for sub-threshold items so they remain
+audit-trail signal rather than silent drop.
+
+Schema (Opus's machine-readable contract):
+
+    Finding            — `{id: str, source: str, text: str}`
+    FindingScore       — `{finding_id: str, scorer: str, score: 1..10,
+                          agree: bool, reason: str}`
+    ConsensusMetadata  — per-finding aggregate:
+                         `{finding_id, consensus_strength: 0..1,
+                           dissent_count, scorers, mean_score}`
+
+Threshold bucketing (Phase 4 Step 3):
+
+    consensus_strength > strong   → Strong Consensus
+    minority < strength <= strong → Findings (default body)
+    strength <= minority          → Minority Views
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Iterable
+
+_JSON_BLOCK = re.compile(r"```(?:json)?\s*(\[.*?\])\s*```", re.DOTALL)
+_BARE_ARRAY = re.compile(r"(\[\s*\{.*?\}\s*\])", re.DOTALL)
+
+# Defaults mirror the roadmap (Phase 4 Step 4). The .agent-settings.yml
+# block overrides them at run time.
+DEFAULT_STRONG_THRESHOLD: float = 0.7
+DEFAULT_MINORITY_THRESHOLD: float = 0.4
+
+
+@dataclass(frozen=True)
+class Finding:
+    """One finding extracted from a member's deliberation output."""
+
+    id: str
+    source: str  # provider/model that authored the finding
+    text: str
+
+
+@dataclass(frozen=True)
+class FindingScore:
+    """One scorer's vote on one finding."""
+
+    finding_id: str
+    scorer: str
+    score: int  # 1..10
+    agree: bool
+    reason: str
+
+
+@dataclass(frozen=True)
+class ConsensusMetadata:
+    """Aggregate consensus stats for a single finding."""
+
+    finding_id: str
+    consensus_strength: float  # 0..1
+    dissent_count: int
+    scorers: tuple[str, ...]
+    mean_score: float
+
+
+@dataclass(frozen=True)
+class ConsensusBucket:
+    """Threshold-bucketed findings ready for renderer sectioning."""
+
+    strong: list[tuple[Finding, ConsensusMetadata]] = field(default_factory=list)
+    findings: list[tuple[Finding, ConsensusMetadata]] = field(default_factory=list)
+    minority: list[tuple[Finding, ConsensusMetadata]] = field(default_factory=list)
+
+
+def aggregate_scores(
+    findings: Iterable[Finding],
+    scores: Iterable[FindingScore],
+) -> dict[str, ConsensusMetadata]:
+    """Aggregate per-finding scores into ConsensusMetadata.
+
+    `consensus_strength` = mean(score) / 10 * agreement_rate.
+
+    A finding's *own author* is never expected to score it; we drop
+    self-scores defensively to keep the aggregate honest. Missing
+    findings get zero scorers (strength=0, dissent_count=0).
+    """
+    by_id: dict[str, list[FindingScore]] = {f.id: [] for f in findings}
+    sources: dict[str, str] = {f.id: f.source for f in findings}
+    for s in scores:
+        if s.finding_id not in by_id:
+            continue
+        if s.scorer == sources[s.finding_id]:
+            continue  # ignore self-scores
+        by_id[s.finding_id].append(s)
+    out: dict[str, ConsensusMetadata] = {}
+    for fid, fs in by_id.items():
+        if not fs:
+            out[fid] = ConsensusMetadata(
+                finding_id=fid, consensus_strength=0.0,
+                dissent_count=0, scorers=(), mean_score=0.0,
+            )
+            continue
+        mean = sum(s.score for s in fs) / len(fs)
+        agree_rate = sum(1 for s in fs if s.agree) / len(fs)
+        strength = (mean / 10.0) * agree_rate
+        dissent = sum(1 for s in fs if not s.agree)
+        scorers = tuple(s.scorer for s in fs)
+        out[fid] = ConsensusMetadata(
+            finding_id=fid, consensus_strength=round(strength, 3),
+            dissent_count=dissent, scorers=scorers,
+            mean_score=round(mean, 2),
+        )
+    return out
+
+
+def bucket_by_threshold(
+    findings: Iterable[Finding],
+    metadata: dict[str, ConsensusMetadata],
+    *,
+    strong: float = DEFAULT_STRONG_THRESHOLD,
+    minority: float = DEFAULT_MINORITY_THRESHOLD,
+) -> ConsensusBucket:
+    """Split findings into Strong / Findings / Minority buckets.
+
+    `strong` and `minority` are the thresholds from
+    `.agent-settings.yml::ai_council.consensus_threshold_*`. Findings
+    with no metadata (no scorers) fall into the Minority bucket — they
+    were uncontested but unsupported.
+    """
+    if not 0.0 <= minority <= strong <= 1.0:
+        raise ValueError(
+            f"Threshold ordering broken: 0 <= {minority} <= {strong} <= 1 required.",
+        )
+    bucket = ConsensusBucket()
+    for f in findings:
+        m = metadata.get(f.id)
+        if m is None:
+            m = ConsensusMetadata(
+                finding_id=f.id, consensus_strength=0.0,
+                dissent_count=0, scorers=(), mean_score=0.0,
+            )
+        if m.consensus_strength > strong:
+            bucket.strong.append((f, m))
+        elif m.consensus_strength > minority:
+            bucket.findings.append((f, m))
+        else:
+            bucket.minority.append((f, m))
+    # Strongest first inside each bucket.
+    for lst in (bucket.strong, bucket.findings, bucket.minority):
+        lst.sort(key=lambda pair: pair[1].consensus_strength, reverse=True)
+    return bucket
+
+
+def parse_findings_response(text: str, *, source: str) -> list[Finding]:
+    """Parse a member's structured-findings response into Finding objects.
+
+    Accepts either a fenced ```json``` block or a bare JSON array. Each
+    item must be `{id: str, text: str}` (the `source` is set from the
+    `source` arg so we can attribute findings to their author). Items
+    missing required keys are skipped silently — extraction is best-
+    effort, never raises.
+    """
+    array = _extract_json_array(text)
+    if not array:
+        return []
+    try:
+        parsed = json.loads(array)
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(parsed, list):
+        return []
+    out: list[Finding] = []
+    for item in parsed:
+        if not isinstance(item, dict):
+            continue
+        fid = item.get("id")
+        txt = item.get("text")
+        if not fid or not txt:
+            continue
+        out.append(Finding(id=str(fid), source=source, text=str(txt).strip()))
+    return out
+
+
+def parse_scores_response(text: str, *, scorer: str) -> list[FindingScore]:
+    """Parse a member's scoring response into FindingScore objects.
+
+    Each item must be `{finding_id, score, agree, reason}`. Scores are
+    clamped to 1..10; non-numeric scores or out-of-range values cause
+    the item to be skipped (defensive — never poison aggregates).
+    """
+    array = _extract_json_array(text)
+    if not array:
+        return []
+    try:
+        parsed = json.loads(array)
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(parsed, list):
+        return []
+    out: list[FindingScore] = []
+    for item in parsed:
+        if not isinstance(item, dict):
+            continue
+        fid = item.get("finding_id") or item.get("id")
+        score = item.get("score")
+        if not fid or not isinstance(score, (int, float)):
+            continue
+        score_int = int(score)
+        if not 1 <= score_int <= 10:
+            continue
+        out.append(FindingScore(
+            finding_id=str(fid), scorer=scorer, score=score_int,
+            agree=bool(item.get("agree", True)),
+            reason=str(item.get("reason", "")).strip(),
+        ))
+    return out
+
+
+def _extract_json_array(text: str) -> str:
+    """Best-effort JSON-array extraction from a model response."""
+    if not text:
+        return ""
+    fenced = _JSON_BLOCK.search(text)
+    if fenced:
+        return fenced.group(1)
+    bare = _BARE_ARRAY.search(text)
+    if bare:
+        return bare.group(1)
+    return ""
+
+
+def anonymize_findings(findings: list[Finding]) -> dict[str, Finding]:
+    """Return `{anon_label: Finding}` map so scorers see neutral labels.
+
+    Labels are `Finding-A`, `Finding-B`, … in input order. The author
+    mapping must be kept out of the prompt — keep it server-side only.
+    """
+    out: dict[str, Finding] = {}
+    for idx, f in enumerate(findings):
+        label = f"Finding-{chr(ord('A') + idx)}"
+        out[label] = f
+    return out
+
+
+def anonymize_responses(
+    responses: Iterable[tuple[str, str]],
+    *,
+    persona_labels: dict[str, str] | None = None,
+) -> tuple[dict[str, str], dict[str, str]]:
+    """Anonymize deliberation responses for the peer-review round (Phase 5).
+
+    `responses` is an iterable of ``(source, text)`` pairs where ``source``
+    is the canonical `provider:model` identifier. Returns:
+
+      - ``anon_text``: ``{Response-A: <body>}`` map fed into the prompt.
+      - ``label_to_source``: ``{Response-A: provider:model}`` map kept
+        server-side so the orchestrator can de-anonymize at synthesis time.
+
+    Empty / whitespace-only texts are skipped — they leak nothing and
+    would clutter the prompt. Input order is preserved so determinism
+    holds for tests (Iron-Law neutrality §peer-review: anonymization
+    strips identity, not order; deterministic A/B labels avoid
+    accidental cross-run reidentification when the same artefact is
+    re-run).
+
+    Phase 6 Step 3a wires `persona_labels` so advisor-mode runs render
+    as ``Response A (Contrarian)`` while provider identity stays
+    stripped. ``persona_labels`` maps ``source`` → ``persona`` (e.g.
+    ``"anthropic:claude-opus-4-1" -> "Contrarian"``); sources missing
+    from the map render as bare ``Response A``. Plain-member runs pass
+    ``persona_labels=None`` and behave exactly like today.
+    """
+    anon_text: dict[str, str] = {}
+    label_to_source: dict[str, str] = {}
+    idx = 0
+    for source, text in responses:
+        if not text or not text.strip():
+            continue
+        base = f"Response-{chr(ord('A') + idx)}"
+        persona = (persona_labels or {}).get(source)
+        label = f"{base} ({persona})" if persona else base
+        anon_text[label] = text.strip()
+        label_to_source[label] = source
+        idx += 1
+    return anon_text, label_to_source