create-leafmesh 2.4.0__tar.gz → 2.4.1__tar.gz

{create_leafmesh-2.4.0 → create_leafmesh-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-leafmesh
-Version: 2.4.0
+Version: 2.4.1
 Summary: Project scaffolding + cloud-deploy tool for LeafMesh
 License-Expression: MIT
 Requires-Python: >=3.10

{create_leafmesh-2.4.0 → create_leafmesh-2.4.1}/create_leafmesh/__init__.py

@@ -1,3 +1,3 @@
 """create-leafmesh — Project scaffolding + cloud-deploy tool for LeafMesh."""
 
-__version__ = "2.4.0"
+__version__ = "2.4.1"

{create_leafmesh-2.4.0 → create_leafmesh-2.4.1}/create_leafmesh/templates/_inspire/configs/config.yaml

@@ -405,6 +405,11 @@ agents:
     # optimization_strategy: "performance"  # "performance" | "cost" | "speed"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"greeting": "", "user_input": "", "detected_sentiment": "", "status": "", "user_message": "", "request_type": ""}
       You are a friendly assistant. Given the user's message,
       greet them warmly and summarize what they need help with.
       Return a clear, structured JSON summary with keys:
@@ -640,6 +645,11 @@ agents:
       - data-handling
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"findings": [], "query": "", "analysis": {}, "report": {}, "status": ""}
       You are a research analyst. Analyze the provided data thoroughly.
       Use available tools to gather additional information.
       Return structured findings with confidence scores.
@@ -730,6 +740,11 @@ agents:
     wait_for_timeout: 120
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"recommendations": [], "risk_assessment": "", "priority_score": 0, "next_steps": [], "status": ""}
       You are a strategic advisor. Analyze the processed data and research
       findings provided. Produce actionable recommendations with priority
       scoring. Identify risks and suggest concrete next steps.
@@ -1209,6 +1224,11 @@ agents:
     communication_type: "chain"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"action": "", "record_id": "", "subject_id": "", "category": "", "severity": "", "severity_score": 0, "notes": "", "requires_review": false, "recorded_at_utc": "", "window_days": 0, "record_count": 0, "by_category": {}, "by_severity": {}, "avg_severity_score": 0, "max_severity_score": 0, "reported_at_utc": ""}
       For mode=record: classify the observation. Return JSON:
         - category: short snake_case category
         - severity: info | low | medium | high | critical

create_leafmesh-2.4.1/create_leafmesh/templates/_inspire/validate_config.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""validate_config.py — pre-flight checks for a LeafMesh project config.
+
+Run from the project root BEFORE `python main.py`:
+
+    python validate_config.py            # checks configs/config.yaml
+    python validate_config.py path/to/other.yaml
+
+Catches, with file/line context where possible:
+  1. YAML syntax errors (bad indentation, tabs, missing colons)
+  2. can_call / entry_point / wait_for targets that don't exist
+  3. conditions referencing yields the calling agent never returns
+     (human agents may only use the SDK's human-response meta fields)
+  4. yields ↔ prompt contract mismatches on LLM agents — the SDK
+     refuses to boot when the prompt's JSON keys have NO overlap with
+     the declared yields (the "Hello!" silent-fallback class)
+  5. timeout fallback messages that match none of the gate's routes
+  6. one wake_up per agent + 5-field cron shape
+
+Exit code 0 = clean, 1 = problems found.
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("PyYAML required: pip install PyYAML")
+    sys.exit(2)
+
+HUMAN_META = frozenset({
+    "from_agent", "human_data", "human_decision", "human_initiated",
+    "human_message", "original_webhook_data", "source_agent", "timestamp",
+})
+COND_RE = re.compile(r"calling_agent_response\.([A-Za-z_][\w]*)")
+CRON_RE = re.compile(r"^\s*\S+\s+\S+\s+\S+\s+\S+\s+\S+\s*$")
+
+problems: list[str] = []
+
+
+def err(msg: str) -> None:
+    problems.append(msg)
+    print(f"  ✗ {msg}")
+
+
+def load(path: Path) -> dict | None:
+    raw = path.read_text(encoding="utf-8")
+    for i, line in enumerate(raw.splitlines(), 1):
+        if "\t" in line.split("#")[0]:
+            err(f"{path}:{i}: TAB character in YAML indentation — use spaces")
+    raw = raw.replace("{{project_name}}", "validate-check")
+    raw = re.sub(r"\{\{\w+\}\}", "0", raw)
+    try:
+        return yaml.safe_load(raw)
+    except yaml.YAMLError as e:
+        mark = getattr(e, "problem_mark", None)
+        loc = f" at line {mark.line + 1}, column {mark.column + 1}" if mark else ""
+        err(f"{path}: YAML parse failed{loc}: "
+            f"{getattr(e, 'problem', e)} — check indentation around that line")
+        return None
+
+
+def is_human(a: dict) -> bool:
+    return a.get("agent_type") == "human" or bool(a.get("is_human_powered"))
+
+
+def cond_fires_for_message(cond: str, message: str) -> bool:
+    def atom(expr: str) -> bool:
+        m = re.match(r"\s*calling_agent_response\.(\w+)\s*([!=]=)\s*'([^']*)'\s*$", expr)
+        if not m:
+            return False
+        field, op, val = m.groups()
+        if field != "human_message":
+            return False
+        return (message == val) if op == "==" else (message != val)
+    return any(all(atom(x) for x in part.split(" and "))
+               for part in cond.split(" or "))
+
+
+def main() -> int:
+    target = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("configs/config.yaml")
+    if not target.exists():
+        print(f"config not found: {target}")
+        return 1
+
+    print(f"Validating {target} ...")
+    cfg = load(target)
+    if cfg is None:
+        return 1
+    agents = cfg.get("agents") or {}
+    names = set(agents.keys())
+
+    # 2. targets exist
+    for n, a in agents.items():
+        if not isinstance(a, dict):
+            err(f"agent '{n}' is not a mapping — check indentation under it")
+            continue
+        for cc in a.get("can_call") or []:
+            if isinstance(cc, dict) and cc.get("agent") not in names:
+                err(f"{n}: can_call → '{cc.get('agent')}' does not exist")
+        wf = a.get("wait_for")
+        if wf:
+            for tok in re.findall(r"[A-Za-z_][\w]*", str(wf)):
+                if tok not in names and tok not in ("AND", "OR", "and", "or"):
+                    err(f"{n}: wait_for references unknown agent '{tok}'")
+    for ep in cfg.get("entry_points") or []:
+        if isinstance(ep, dict) and ep.get("target") not in names:
+            err(f"entry_point '{ep.get('name')}' → '{ep.get('target')}' does not exist")
+
+    # 3. conditions vs yields / human meta
+    for n, a in agents.items():
+        if not isinstance(a, dict):
+            continue
+        yields = set((a.get("yields") or {}).keys())
+        human = is_human(a)
+        for cc in a.get("can_call") or []:
+            if not isinstance(cc, dict) or not cc.get("condition"):
+                continue
+            for ref in COND_RE.findall(str(cc["condition"])):
+                if human and ref not in HUMAN_META:
+                    err(f"{n}→{cc.get('agent')}: human gate condition uses "
+                        f"'{ref}' — human responses only deliver "
+                        f"{sorted(HUMAN_META)[:3]}... (use human_message)")
+                elif not human and ref not in yields and ref not in HUMAN_META:
+                    err(f"{n}→{cc.get('agent')}: condition uses '{ref}' "
+                        f"which is not in {n}'s yields")
+
+    # 4. yields ↔ prompt contract (LLM agents)
+    for n, a in agents.items():
+        if not isinstance(a, dict) or a.get("agent_type") != "llm":
+            continue
+        yields = set((a.get("yields") or {}).keys())
+        prompt = a.get("prompt") or ""
+        if not yields or not prompt:
+            continue
+        mentioned = {k for k in yields if re.search(rf'["\-\s]{re.escape(k)}["\s]*:', prompt)}
+        if not mentioned:
+            err(f"{n}: prompt mentions NONE of its {len(yields)} yields keys — "
+                f"the SDK will refuse to boot. Add an OUTPUT CONTRACT line "
+                f"listing them, e.g.\n      OUTPUT CONTRACT — respond with "
+                f"ONLY valid JSON containing exactly these keys:\n      "
+                + "{" + ", ".join(f'"{k}": ...' for k in sorted(yields)) + "}")
+        elif len(mentioned) < len(yields):
+            print(f"  ⚠ {n}: prompt mentions {len(mentioned)}/{len(yields)} "
+                  f"yields keys (missing: {sorted(yields - mentioned)[:5]}...) — "
+                  f"boots, but enforce_yields retries are likelier")
+
+    # 5. timeout fallbacks route somewhere
+    for n, a in agents.items():
+        if not isinstance(a, dict) or not is_human(a):
+            continue
+        edges = [cc for cc in a.get("can_call") or [] if isinstance(cc, dict)]
+        fr = a.get("fallback_response") or {}
+        msg = str(fr.get("message", ""))
+        if not edges or not fr or not msg:
+            continue
+        if not any(not cc.get("condition")
+                   or cond_fires_for_message(str(cc["condition"]), msg)
+                   for cc in edges):
+            err(f"{n}: timeout fallback message {msg!r} matches no route — "
+                f"an unanswered approval would silently kill the flow")
+
+    # 6. cron shape
+    for n, a in agents.items():
+        if isinstance(a, dict) and a.get("wake_up") \
+                and not CRON_RE.match(str(a["wake_up"])):
+            err(f"{n}: wake_up {a['wake_up']!r} is not a 5-field cron")
+
+    if problems:
+        print(f"\n{len(problems)} problem(s) found — fix before running main.py")
+        return 1
+    print(f"OK — {len(names)} agents, "
+          f"{len(cfg.get('entry_points') or [])} entry points, all checks pass")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{create_leafmesh-2.4.0 → create_leafmesh-2.4.1}/create_leafmesh/templates/bd-proposals/configs/config.yaml

@@ -204,6 +204,11 @@ agents:
     wake_up: "0 6 * * *"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"mode": "", "rfp_id": "", "client_org": "", "practice_area": "", "due_date": "", "budget_range_cents": {}, "compliance_required": [], "deal_breakers": [], "document_count": 0, "requirements": [], "requirements_must_count": 0, "requirements_should_count": 0, "compliance_frameworks": [], "deliverables": [], "evaluation_criteria": {}, "pricing_constraints": {}, "key_dates": {}, "found_tags": {}, "completeness_score": 0, "extraction_complete": false, "discovered_count": 0, "discovered_rfps": [], "high_fit_count": 0, "high_fit_rfps": [], "skipped_duplicates": 0, "requires_partner_review": false, "swept_at_utc": ""}
       You are the firm's opportunity-intake specialist — the single
       role that owns everything between "an opportunity exists out
       there" and "the mesh starts working it".
@@ -351,6 +356,8 @@ agents:
         - query: string (corpus search query)
         - practice_areas: list
 
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+      {"similar_proposals": [], "reuse_score": 0, "matches": [], "best_match_proposal_id": "", "best_match_similarity": 0, "total_corpus_size": 0, "high_confidence_match": false, "reason": ""}
     enforce_yields: true
     enforce_yields_retry: 2
     knowledge:
@@ -397,6 +404,8 @@ agents:
         - sections: list
         - cited_past_proposals: list
 
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+      {"sections": [], "cited_past_proposals": []}
     enforce_yields: true
     enforce_yields_retry: 2
     knowledge:
@@ -448,6 +457,11 @@ agents:
     communication_type: "chain"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"mode": "", "rfp_id": "", "clearance": "", "reasons": [], "requires_legal_review": false, "partner_briefing": "", "clauses_reviewed": 0, "review": [], "severity_counts": {}, "unacceptable_clauses": [], "negotiable_clauses": [], "unmapped_clauses": [], "counter_proposals": [], "risk_score": 0, "requires_deal_desk_review": false}
       You are the firm's contracts reviewer — one legal-adjacent role
       with two responsibilities, dispatched by what you receive.
 
@@ -663,6 +677,11 @@ agents:
     communication_type: "chain"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"mode": "", "decision": "", "executive_summary": "", "what_we_did_well": [], "what_we_did_poorly": [], "competitor_intelligence": [], "learnings_for_library": [], "next_action_for_relationship": "", "confidence": 0, "competitor_queried": "", "horizon_days": 0, "signals": [], "top_competitors": [], "avg_impact_score": 0, "high_impact_count": 0, "intel_briefing": ""}
       You are the firm's competitive-intelligence analyst — you own
       both what we learn from every decision and the ledger of what
       competitors are doing.
@@ -754,6 +773,11 @@ agents:
     communication_type: "chain"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"rfp_id": "", "fit_strategic": 0, "fit_capability": 0, "fit_economics": 0, "fit_relationship": 0, "fit_competitive": 0, "overall_score": 0, "confidence": 0, "recommendation": "", "risk_flags": [], "win_themes": [], "requires_partner_review": false, "decision_briefing": ""}
       Score the fit on this RFP. Return JSON with these keys (all
       required; do not omit any):
         - fit_strategic: 0..1

create_leafmesh-2.4.1/create_leafmesh/templates/bd-proposals/validate_config.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""validate_config.py — pre-flight checks for a LeafMesh project config.
+
+Run from the project root BEFORE `python main.py`:
+
+    python validate_config.py            # checks configs/config.yaml
+    python validate_config.py path/to/other.yaml
+
+Catches, with file/line context where possible:
+  1. YAML syntax errors (bad indentation, tabs, missing colons)
+  2. can_call / entry_point / wait_for targets that don't exist
+  3. conditions referencing yields the calling agent never returns
+     (human agents may only use the SDK's human-response meta fields)
+  4. yields ↔ prompt contract mismatches on LLM agents — the SDK
+     refuses to boot when the prompt's JSON keys have NO overlap with
+     the declared yields (the "Hello!" silent-fallback class)
+  5. timeout fallback messages that match none of the gate's routes
+  6. one wake_up per agent + 5-field cron shape
+
+Exit code 0 = clean, 1 = problems found.
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("PyYAML required: pip install PyYAML")
+    sys.exit(2)
+
+HUMAN_META = frozenset({
+    "from_agent", "human_data", "human_decision", "human_initiated",
+    "human_message", "original_webhook_data", "source_agent", "timestamp",
+})
+COND_RE = re.compile(r"calling_agent_response\.([A-Za-z_][\w]*)")
+CRON_RE = re.compile(r"^\s*\S+\s+\S+\s+\S+\s+\S+\s+\S+\s*$")
+
+problems: list[str] = []
+
+
+def err(msg: str) -> None:
+    problems.append(msg)
+    print(f"  ✗ {msg}")
+
+
+def load(path: Path) -> dict | None:
+    raw = path.read_text(encoding="utf-8")
+    for i, line in enumerate(raw.splitlines(), 1):
+        if "\t" in line.split("#")[0]:
+            err(f"{path}:{i}: TAB character in YAML indentation — use spaces")
+    raw = raw.replace("{{project_name}}", "validate-check")
+    raw = re.sub(r"\{\{\w+\}\}", "0", raw)
+    try:
+        return yaml.safe_load(raw)
+    except yaml.YAMLError as e:
+        mark = getattr(e, "problem_mark", None)
+        loc = f" at line {mark.line + 1}, column {mark.column + 1}" if mark else ""
+        err(f"{path}: YAML parse failed{loc}: "
+            f"{getattr(e, 'problem', e)} — check indentation around that line")
+        return None
+
+
+def is_human(a: dict) -> bool:
+    return a.get("agent_type") == "human" or bool(a.get("is_human_powered"))
+
+
+def cond_fires_for_message(cond: str, message: str) -> bool:
+    def atom(expr: str) -> bool:
+        m = re.match(r"\s*calling_agent_response\.(\w+)\s*([!=]=)\s*'([^']*)'\s*$", expr)
+        if not m:
+            return False
+        field, op, val = m.groups()
+        if field != "human_message":
+            return False
+        return (message == val) if op == "==" else (message != val)
+    return any(all(atom(x) for x in part.split(" and "))
+               for part in cond.split(" or "))
+
+
+def main() -> int:
+    target = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("configs/config.yaml")
+    if not target.exists():
+        print(f"config not found: {target}")
+        return 1
+
+    print(f"Validating {target} ...")
+    cfg = load(target)
+    if cfg is None:
+        return 1
+    agents = cfg.get("agents") or {}
+    names = set(agents.keys())
+
+    # 2. targets exist
+    for n, a in agents.items():
+        if not isinstance(a, dict):
+            err(f"agent '{n}' is not a mapping — check indentation under it")
+            continue
+        for cc in a.get("can_call") or []:
+            if isinstance(cc, dict) and cc.get("agent") not in names:
+                err(f"{n}: can_call → '{cc.get('agent')}' does not exist")
+        wf = a.get("wait_for")
+        if wf:
+            for tok in re.findall(r"[A-Za-z_][\w]*", str(wf)):
+                if tok not in names and tok not in ("AND", "OR", "and", "or"):
+                    err(f"{n}: wait_for references unknown agent '{tok}'")
+    for ep in cfg.get("entry_points") or []:
+        if isinstance(ep, dict) and ep.get("target") not in names:
+            err(f"entry_point '{ep.get('name')}' → '{ep.get('target')}' does not exist")
+
+    # 3. conditions vs yields / human meta
+    for n, a in agents.items():
+        if not isinstance(a, dict):
+            continue
+        yields = set((a.get("yields") or {}).keys())
+        human = is_human(a)
+        for cc in a.get("can_call") or []:
+            if not isinstance(cc, dict) or not cc.get("condition"):
+                continue
+            for ref in COND_RE.findall(str(cc["condition"])):
+                if human and ref not in HUMAN_META:
+                    err(f"{n}→{cc.get('agent')}: human gate condition uses "
+                        f"'{ref}' — human responses only deliver "
+                        f"{sorted(HUMAN_META)[:3]}... (use human_message)")
+                elif not human and ref not in yields and ref not in HUMAN_META:
+                    err(f"{n}→{cc.get('agent')}: condition uses '{ref}' "
+                        f"which is not in {n}'s yields")
+
+    # 4. yields ↔ prompt contract (LLM agents)
+    for n, a in agents.items():
+        if not isinstance(a, dict) or a.get("agent_type") != "llm":
+            continue
+        yields = set((a.get("yields") or {}).keys())
+        prompt = a.get("prompt") or ""
+        if not yields or not prompt:
+            continue
+        mentioned = {k for k in yields if re.search(rf'["\-\s]{re.escape(k)}["\s]*:', prompt)}
+        if not mentioned:
+            err(f"{n}: prompt mentions NONE of its {len(yields)} yields keys — "
+                f"the SDK will refuse to boot. Add an OUTPUT CONTRACT line "
+                f"listing them, e.g.\n      OUTPUT CONTRACT — respond with "
+                f"ONLY valid JSON containing exactly these keys:\n      "
+                + "{" + ", ".join(f'"{k}": ...' for k in sorted(yields)) + "}")
+        elif len(mentioned) < len(yields):
+            print(f"  ⚠ {n}: prompt mentions {len(mentioned)}/{len(yields)} "
+                  f"yields keys (missing: {sorted(yields - mentioned)[:5]}...) — "
+                  f"boots, but enforce_yields retries are likelier")
+
+    # 5. timeout fallbacks route somewhere
+    for n, a in agents.items():
+        if not isinstance(a, dict) or not is_human(a):
+            continue
+        edges = [cc for cc in a.get("can_call") or [] if isinstance(cc, dict)]
+        fr = a.get("fallback_response") or {}
+        msg = str(fr.get("message", ""))
+        if not edges or not fr or not msg:
+            continue
+        if not any(not cc.get("condition")
+                   or cond_fires_for_message(str(cc["condition"]), msg)
+                   for cc in edges):
+            err(f"{n}: timeout fallback message {msg!r} matches no route — "
+                f"an unanswered approval would silently kill the flow")
+
+    # 6. cron shape
+    for n, a in agents.items():
+        if isinstance(a, dict) and a.get("wake_up") \
+                and not CRON_RE.match(str(a["wake_up"])):
+            err(f"{n}: wake_up {a['wake_up']!r} is not a 5-field cron")
+
+    if problems:
+        print(f"\n{len(problems)} problem(s) found — fix before running main.py")
+        return 1
+    print(f"OK — {len(names)} agents, "
+          f"{len(cfg.get('entry_points') or [])} entry points, all checks pass")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{create_leafmesh-2.4.0 → create_leafmesh-2.4.1}/create_leafmesh/templates/bench-management/configs/config.yaml

@@ -276,6 +276,9 @@ agents:
          Prefer one person per opportunity: a person matched to two
          opportunities is a double-booking conflict that forces
          engagement-lead review.
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+      {"matches": [], "unmatched_people": [], "unmatched_opportunities": [], "skills_gaps": [], "staffing_briefing": "", "plan_id": "", "assignments": [], "conflicts": [], "requires_engagement_lead_review": false}
     enforce_yields: true
     enforce_yields_retry: 2
     knowledge:
@@ -320,6 +323,11 @@ agents:
     communication_type: "chain"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"idle_2w": [], "idle_4w": [], "avg_idle_weeks": 0, "recommendations": [], "plan_id": "", "employee_id": "", "current_level": "", "target_role_6mo": "", "skill_bets": [], "internal_projects": [], "certifications": [], "retention_risk_score": 0, "employee_facing_narrative": "", "confidence": 0}
       You are the talent development lead. One role, three
       responsibilities:
 
@@ -545,6 +553,11 @@ agents:
     communication_type: "chain"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"review_id": "", "resource_id": "", "period": "", "composite_score": 0, "overall_rating": "", "strengths": [], "development_areas": [], "engagement_sample_size": 0, "avg_client_feedback": 0, "utilisation_pct": 0, "skill_growth_count": 0, "peer_feedback_count": 0, "requires_calibration": false, "requires_manager_signoff": false, "generated_at_utc": "", "plan_id": ""}
       Draft the performance review. Return JSON with these keys:
         - strengths: list of 3-5 documented strengths (each tied to
             a specific engagement or skill growth)
@@ -611,6 +624,11 @@ agents:
     communication_type: "chain"
 
     prompt: |
+
+
+      OUTPUT CONTRACT — respond with ONLY valid JSON containing exactly these keys:
+
+      {"action": "", "survey_id": "", "cohort": "", "cohort_size": 0, "questions": [], "launched_at_utc": "", "response_count": 0, "response_rate": 0, "avg_scores": {}, "engagement_index": 0, "themes": [], "open_text_count": 0, "requires_hrbp_review": false}
       For mode=analyse: given a survey's open-text responses, return
       JSON with key themes: list of {theme, frequency_pct, sentiment,
       sample_quote}. Anonymise — never quote a name or specific