create-leafmesh 2.6.0__tar.gz → 2.6.2__tar.gz

create_leafmesh-2.6.2/MANIFEST.in

@@ -0,0 +1,11 @@
+# Source-distribution hygiene. The wheel is governed by
+# [tool.setuptools.exclude-package-data] in pyproject.toml; this file does the
+# same for the sdist so runtime cruft (stray logs, scratch data/out dirs,
+# bytecode caches) can never be shipped, regardless of working-tree state.
+global-exclude *.log
+global-exclude *.pyc
+prune create_leafmesh/templates/**/logs
+prune create_leafmesh/templates/**/data
+prune create_leafmesh/templates/**/out
+prune create_leafmesh/templates/**/__pycache__
+prune create_leafmesh/templates/**/.pytest_cache

{create_leafmesh-2.6.0 → create_leafmesh-2.6.2}/PKG-INFO

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

{create_leafmesh-2.6.0 → create_leafmesh-2.6.2}/create_leafmesh/__init__.py

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

{create_leafmesh-2.6.0 → create_leafmesh-2.6.2}/create_leafmesh/cli.py

@@ -12,6 +12,7 @@ from create_leafmesh.create import (
     get_template_prompts,
     list_templates,
 )
+from create_leafmesh.search import search_templates
 
 # ---------------------------------------------------------------------------
 # ANSI helpers (graceful fallback on terminals that don't support color)
@@ -155,7 +156,8 @@ def print_template_list(include_planned: bool = True) -> None:
             print(f"  {_c(_DIM, slug):<35s} {_c(_DIM, short)}")
         print()
 
-    print(_c(_DIM, "  Use: create-leafmesh <project_name> --template <slug>"))
+    print(_c(_DIM, "  Use:    create-leafmesh <project_name> --template <slug>"))
+    print(_c(_DIM, "  Search: create-leafmesh --search \"<keywords>\""))
     print()
 
 
@@ -194,6 +196,54 @@ def _grouped_templates() -> list[tuple[str, list[dict]]]:
     return display
 
 
+def _interactive_search(questionary, style) -> str | None:
+    """State 1 → state 2 bridge inside the TUI picker.
+
+    Prompt for keywords, run the fuzzy search, and — if anything matches —
+    auto-switch to a template-level selection (state 2). Returns a chosen
+    slug, or None to return to the category view (state 1).
+    """
+    ready = list_templates(include_planned=False)
+    query = questionary.text(
+        "Search templates (keywords — spelling needn't be exact):",
+        style=style,
+    ).ask()
+    if not query or not query.strip():
+        return None
+    query = query.strip()
+
+    matches = search_templates(ready, query)
+    if not matches:
+        print(f"\n  No templates matched '{query}'. "
+              f"Try a broader term (e.g. 'sales', 'finance', 'support').\n")
+        return None
+
+    # Auto-switch to state 2 — show the matching templates directly.
+    name_w = max((len(t.get("short_name", t["slug"])) for t, _ in matches),
+                 default=12) + 2
+    tpl_choices = []
+    for t, _score in matches:
+        short = t.get("short_name", t["slug"])
+        one = t.get("one_line", "")
+        tpl_choices.append(questionary.Choice(
+            title=f"{short.ljust(name_w)} — {one}", value=t["slug"]))
+    tpl_choices.append(questionary.Separator())
+    tpl_choices.append(questionary.Choice(title="← Back / new search",
+                                          value="__back__"))
+
+    chosen = questionary.select(
+        f"Matches for '{query}':",
+        choices=tpl_choices,
+        style=style,
+        instruction="(↑/↓ to move, Enter to select)",
+        use_indicator=True,
+    ).ask()
+
+    if chosen is None or chosen == "__back__":
+        return None
+    return chosen
+
+
 def _prompt_template_choice_interactive() -> str:
     """Arrow-key TUI picker — cascading category → template selection.
 
@@ -232,6 +282,8 @@ def _prompt_template_choice_interactive() -> str:
             label = f"{cat}  ({n} template{'s' if n != 1 else ''})"
             cat_choices.append(questionary.Choice(title=label, value=cat))
         cat_choices.append(questionary.Separator())
+        cat_choices.append(questionary.Choice(title="Search by keyword…",
+                                              value="__search__"))
         # NOTE: `value=None` causes questionary to fall back to the title
         # string (treats None as "unset"), which then crashes our
         # cat_to_items lookup with KeyError: 'Quit'. Use an explicit
@@ -250,6 +302,12 @@ def _prompt_template_choice_interactive() -> str:
             print("\n  Cancelled.\n")
             sys.exit(0)
 
+        if chosen_cat == "__search__":
+            slug = _interactive_search(questionary, style)
+            if slug:
+                return slug
+            continue  # no match / backed out → back to the category view
+
         # ── Step 2: pick a template in that category ─────────────────
         items = cat_to_items[chosen_cat]
         # Pad short_names so the one-liner column aligns nicely.
@@ -319,23 +377,47 @@ def _prompt_template_choice_fallback() -> str:
             )
             n += 1
     print()
-    print(_c(_DIM, f"  Type 1–{len(ready)}, a slug, or 'q' to quit."))
+    print(_c(_DIM, f"  Type 1–{len(ready)}, a slug, '/keywords' to search, "
+                   f"or 'q' to quit."))
     while True:
         try:
-            raw = input("  > ").strip().lower()
+            raw = input("  > ").strip()
         except EOFError:
             print()
             sys.exit(0)
         if not raw:
             continue
-        if raw in ("q", "quit", "exit"):
+        low = raw.lower()
+        if low in ("q", "quit", "exit"):
             print("\n  Cancelled.\n")
             sys.exit(0)
-        if raw in valid_indexes:
-            return valid_indexes[raw]
-        if raw in valid_slugs:
-            return raw
-        print(f"  Invalid choice. Type 1–{len(ready)}, a slug, or 'q'.")
+        # Search: '/keywords' or 's keywords'  → auto-switch to matches (state 2)
+        if raw.startswith("/") or low.startswith("s ") or low.startswith("search "):
+            query = (raw[1:] if raw.startswith("/")
+                     else raw.split(None, 1)[1] if " " in raw else "")
+            query = query.strip()
+            if not query:
+                print("  Type '/' followed by keywords, e.g. '/cold email'.")
+                continue
+            matches = search_templates(ready, query)
+            if not matches:
+                print(f"  No matches for '{query}'. Try a broader term.")
+                continue
+            print()
+            print(f"  Matches for '{query}':")
+            for t, _score in matches:
+                short = t.get("short_name", t["slug"])
+                print(f"    {_c(_BOLD, short.ljust(name_w))}"
+                      f"{_c(_DIM, t.get('one_line', ''))}")
+                print(f"      {_c(_DIM, 'slug: ' + t['slug'])}")
+            print(_c(_DIM, "  → type the slug above to use one."))
+            continue
+        if low in valid_indexes:
+            return valid_indexes[low]
+        if low in valid_slugs:
+            return low
+        print(f"  Invalid choice. Type 1–{len(ready)}, a slug, "
+              f"'/keywords' to search, or 'q'.")
 
 
 def prompt_template_choice() -> str:
@@ -499,6 +581,56 @@ def _print_template_describe(slug: str) -> int:
     return 0
 
 
+def _run_search(query: str) -> int:
+    """`--search` — fuzzy keyword search that lands straight on templates.
+
+    This is the non-interactive expression of the two-state model: rather than
+    show business areas (state 1), a search jumps directly to the matching
+    template(s) (state 2), ready to scaffold.
+    """
+    query = (query or "").strip()
+    if not query:
+        print("\n  Provide search keywords, e.g. "
+              "create-leafmesh --search 'cold email'\n")
+        return 2
+
+    # Search ready templates first; only widen to planned ones if nothing hits.
+    ready = list_templates(include_planned=False)
+    matches = search_templates(ready, query)
+    if not matches:
+        matches = search_templates(list_templates(include_planned=True), query)
+
+    if not matches:
+        print(f"\n  No templates matched {_c(_BOLD, query)}.")
+        print(f"  Run {_c(_BOLD, 'create-leafmesh --list')} to browse all "
+              f"templates,")
+        print(f"  or try a broader term (e.g. 'sales', 'finance', 'support').\n")
+        return 1
+
+    print()
+    print(_c(_BOLD, f"  Search results for '{query}':"))
+    print()
+    name_w = max((len(t.get("short_name", t["slug"])) for t, _ in matches),
+                 default=12) + 2
+    for t, _score in matches:
+        short = t.get("short_name", t["slug"])
+        one = t.get("one_line", "")
+        status = t.get("status", "ready")
+        tag = "" if status == "ready" else _c(_DIM, f"  ({status})")
+        print(f"  {_c(_BOLD, short.ljust(name_w))}{_c(_DIM, '· ' + t['slug'])}{tag}")
+        if one:
+            print(f"  {_c(_DIM, '  ' + one)}")
+        print()
+
+    top = matches[0][0]
+    print(_c(_DIM, "  Scaffold the top match:"))
+    print(f"    create-leafmesh <project_name> --template "
+          f"{_c(_BOLD, top['slug'])}")
+    print(_c(_DIM, f"  Details:  create-leafmesh --describe {top['slug']}"))
+    print()
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="create-leafmesh",
@@ -508,6 +640,7 @@ examples:
   create-leafmesh my-project --template incident-triage    Create with explicit template
   create-leafmesh my-project                               Interactive picker
   create-leafmesh --list                                   Show available templates
+  create-leafmesh --search "cold email"                    Find a template by keyword
   create-leafmesh --describe payment-authorization         Show template details
         """,
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -525,6 +658,11 @@ examples:
         "--list", dest="list_templates", action="store_true",
         help="List available templates and exit",
     )
+    parser.add_argument(
+        "--search", default=None, metavar="QUERY",
+        help="Search templates by keyword (fuzzy; spelling needn't be exact) "
+             "and show matches",
+    )
     parser.add_argument(
         "--describe", default=None, metavar="SLUG",
         help="Show details for one template and exit",
@@ -536,6 +674,8 @@ examples:
     if args.list_templates:
         print_template_list()
         return 0
+    if args.search:
+        return _run_search(args.search)
     if args.describe:
         return _print_template_describe(args.describe)
 

create_leafmesh-2.6.2/create_leafmesh/search.py

@@ -0,0 +1,157 @@
+"""Semi-semantic template search — dependency-free keyword + fuzzy matching.
+
+The CLI surfaces templates in two states:
+
+    state 1  →  business areas   (the category-grouped picker)
+    state 2  →  a template       (a specific, scaffoldable template)
+
+Search is the bridge between them. The user types loose keywords — no exact
+spelling required — and a match auto-switches the UI from state 1 to state 2
+by surfacing the matching template(s) directly.
+
+Matching is deliberately offline and simple (no ML / embedding deps): each
+template owns a `keywords:` synonym list in `_registry.yaml` alongside its
+name / one-liner / description / industries text. We tokenise the query and
+score every template by:
+
+    * whole-query phrase hits against the synonym list   (strongest signal)
+    * exact token overlap                                (strong)
+    * substring overlap                                  (medium)
+    * fuzzy ratio via difflib                            (catches typos)
+
+Keyword/name fields ("primary") outweigh the description ("secondary"), so a
+synonym someone deliberately added always beats an incidental word in prose.
+"""
+
+from __future__ import annotations
+
+import difflib
+import re
+from typing import Any
+
+_TOKEN_RE = re.compile(r"[a-z0-9]+")
+
+# Tokens too generic to carry signal — they appear across most descriptions
+# and would otherwise reward every template equally.
+_STOPWORDS = frozenset({
+    "the", "a", "an", "and", "or", "for", "to", "of", "in", "on", "with",
+    "team", "agent", "agents", "ops", "operation", "operations", "system",
+    "management", "manager", "automation", "automate", "automated",
+})
+
+
+def _tokens(text: str) -> list[str]:
+    return _TOKEN_RE.findall(text.lower())
+
+
+def _contiguous_sublist(needle: list[str], haystack: list[str]) -> bool:
+    """True if `needle` appears as a contiguous run of whole tokens in
+    `haystack`. Token-boundary aware so a short phrase like "po" can't match
+    inside a word like "support" (the classic raw-substring false positive)."""
+    if not needle or len(needle) > len(haystack):
+        return False
+    for i in range(len(haystack) - len(needle) + 1):
+        if haystack[i:i + len(needle)] == needle:
+            return True
+    return False
+
+
+def _keyword_phrases(t: dict[str, Any]) -> list[str]:
+    """The comma-separated `keywords:` scalar, split into phrases."""
+    raw = str(t.get("keywords", "") or "")
+    return [p.strip().lower() for p in raw.split(",") if p.strip()]
+
+
+def _corpus(t: dict[str, Any]) -> tuple[str, str, list[str]]:
+    """Return (primary_text, secondary_text, keyword_phrases) for a template."""
+    primary = " ".join(
+        str(t.get(k, "") or "")
+        for k in ("slug", "short_name", "full_name", "one_line",
+                  "category", "industries", "keywords")
+    )
+    secondary = str(t.get("description", "") or "")
+    return primary.lower(), secondary.lower(), _keyword_phrases(t)
+
+
+def score_template(t: dict[str, Any], query: str) -> float:
+    """Score one template against a free-text query. Higher == better match."""
+    query = (query or "").strip().lower()
+    if not query:
+        return 0.0
+    q_tokens = [tok for tok in _tokens(query) if tok not in _STOPWORDS]
+    if not q_tokens:
+        # Query was all stopwords — fall back to raw tokens so it still does
+        # *something* rather than silently scoring zero.
+        q_tokens = _tokens(query)
+    if not q_tokens:
+        return 0.0
+
+    primary_text, secondary_text, phrases = _corpus(t)
+    primary_tokens = set(_tokens(primary_text))
+    secondary_tokens = set(_tokens(secondary_text))
+    all_tokens = primary_tokens | secondary_tokens
+    q_all_tokens = _tokens(query)
+
+    score = 0.0
+
+    # ── Whole-query phrase hits — the strongest signal. "cold email" should
+    #    map straight to outbound-sdr because that phrase is in its synonyms.
+    #    Matching is token-boundary aware: a synonym's tokens must appear as a
+    #    contiguous run in the query (or vice versa), so a 2-letter alias like
+    #    "po" can't match inside "support". ──
+    for ph in phrases:
+        ph_tokens = _tokens(ph)
+        if not ph_tokens:
+            continue
+        if q_all_tokens == ph_tokens:
+            score += 12.0
+        elif (_contiguous_sublist(ph_tokens, q_all_tokens)
+              or _contiguous_sublist(q_all_tokens, ph_tokens)):
+            score += 6.0
+
+    # ── Per-token scoring. ──
+    for qt in q_tokens:
+        if qt in primary_tokens:
+            score += 3.0
+        elif qt in secondary_tokens:
+            score += 1.5
+        elif len(qt) >= 4 and any(qt in tok for tok in all_tokens):
+            score += 1.0
+        else:
+            # Fuzzy match — catches spelling variants / typos the user warned
+            # about ("recuiting" → "recruiting", "warehous" → "warehouse").
+            # Only fuzz against PRIMARY tokens (keywords + names): fuzzing the
+            # description introduces cross-template noise (every template has
+            # *some* prose word ~0.82 from a typo).
+            best = 0.0
+            for tok in primary_tokens:
+                if abs(len(tok) - len(qt)) > 3:
+                    continue
+                r = difflib.SequenceMatcher(None, qt, tok).ratio()
+                if r > best:
+                    best = r
+            if best >= 0.82:
+                # A near-exact fuzzy hit (e.g. "recuiting" → "recruiting",
+                # ratio ~0.95) is a strong signal — weight it close to an
+                # exact token so a single-word typo still clears the floor.
+                score += best * 3.0
+
+    return score
+
+
+def search_templates(
+    templates: list[dict[str, Any]],
+    query: str,
+    *,
+    limit: int = 6,
+    min_score: float = 2.5,
+) -> list[tuple[dict[str, Any], float]]:
+    """Rank templates against a query.
+
+    Returns [(template, score), …] sorted best-first, capped at `limit`,
+    dropping anything below `min_score`.
+    """
+    scored = [(t, score_template(t, query)) for t in templates]
+    scored = [(t, s) for t, s in scored if s >= min_score]
+    scored.sort(key=lambda ts: (-ts[1], ts[0].get("slug", "")))
+    return scored[:limit]

{create_leafmesh-2.6.0 → create_leafmesh-2.6.2}/create_leafmesh/templates/_registry.yaml

@@ -41,6 +41,7 @@ templates:
     trust_lead: "human-review gate on sensitive requests; hash-chained audit terminus; default-deny on reviewer timeout"
     complexity: "low"
     decision_tree_path: "start_from_scratch"
+    keywords: "blank, scratch, empty, minimal, tutorial, hello world, boilerplate, skeleton, custom, build your own, getting started, starter kit, none of these fit, from zero, poc, prototype, experiment, sandbox, learn, demo mesh, base template, foundation, new project, greenfield, custom agency, build my own mesh"
     description: >
       The template to pick when none of the business templates fit —
       a minimal, working 3-agent mesh whose configs/config.yaml is
@@ -70,6 +71,7 @@ templates:
     trust_lead: "GTM sign-off on strategy shifts; campaign approval before send (spend + brand); human reviews every reply; hash-chained audit"
     complexity: "high"
     decision_tree_path: "outbound_demand_generation"
+    keywords: "outbound, sdr, bdr, cold email, cold outreach, cold calling, demand generation, demand gen, lead generation, lead gen, prospecting, sequences, cadence, apollo, instantly, emailbison, lemlist, smartlead, salesloft, outreach io, sales development, gtm, go to market, pipeline generation, book meetings, appointment setting, sequencer, drip campaign, email outreach, outreach automation, sales emails, email campaigns, multichannel outreach, linkedin outreach, account based marketing, abm, lead enrichment, deliverability, mailbox warmup, reply handling, sdr team"
     description: >
       An autonomous outbound sales-development operation. A GTM head
       agent researches the onboarded company (SERP/Surfer tools) and
@@ -99,6 +101,7 @@ templates:
     trust_lead: "tech-lead sign-off before any code is written AND before merge; an independent QA agent re-runs the tests (no self-marked homework) and files bugs to Jira; bounded rework; hash-chained audit"
     complexity: "high"
     decision_tree_path: "autonomous_development"
+    keywords: "engineering, software development, coding, developer, programmer, software engineer, jira, github, gitlab, pull request, pr, claude agent, claude code, autonomous coding, coding agent, ai engineer, sdlc, tech lead, qa testing, test automation, build features, feature development, ship code, dev team, sprint, tickets, backlog, acceptance criteria, bug fixing, write code, code review, refactor, ci cd, merge, product owner, devops"
     description: >
       A Jira-driven autonomous software-development squad. A product-owner
       agent grooms a raw request into a well-formed ticket (testable
@@ -134,6 +137,7 @@ templates:
     trust_lead: "regulator visibility (high) — every action audited, exception-routed to Controller"
     complexity: "high"
     decision_tree_path: "finance_automation"
+    keywords: "finance, accounting, accounts payable, ap, accounts receivable, ar, invoice, invoices, invoicing, vendor invoices, ocr invoice, reconciliation, reconcile, cash application, dunning, close cycle, month end close, financial close, gl, general ledger, journal entries, accruals, bookkeeping, controller, cfo, fraud check, duplicate detection, three way match, po matching, erp, netsuite, quickbooks, sap, expense, billing, payment processing, audit trail, ap automation, ar automation, finance team, back office"
     description: >
       Accounts payable + accounts receivable + close-cycle automation.
       Multi-entry: invoices land via email, vendor portal, ERP webhook,
@@ -156,6 +160,7 @@ templates:
     trust_lead: "compliance by construction — bias signal + out-of-band offer are hard HRBP gates; weekly EEOC 4/5ths audit; hash-chained WORM"
     complexity: "medium"
     decision_tree_path: "talent_pipeline"
+    keywords: "recruiting, recruitment, hiring, talent, talent acquisition, talent pipeline, candidates, applicants, ats, applicant tracking, interview scheduling, interview loop, candidate screening, resume, cv, sourcing, sourcer, screening, offer letter, offer management, salary band, hr, human resources, hrbp, headcount, hiring manager, recruiter, eeoc, bias check, diversity hiring, people ops, hr ops, job openings, job posting, requisition, onboarding, greenhouse, lever, workday, linkedin recruiter"
     description: >
       End-to-end recruiting team. Multi-entry: req filed in ATS,
       referral submitted, LinkedIn-InMail reply, scheduled pipeline
@@ -183,11 +188,12 @@ templates:
     one_line: "Ticket → triage → sentiment → KB → draft → QA → escalation."
     industries: ["saas", "services", "any with support"]
     roi_cells: ["supp × saas"]
-    agent_count: 14
+    agent_count: 15
     cron_count: 0
     trust_lead: "customer visibility — sentiment-aware, escalation default-deny on low confidence"
     complexity: "medium"
     decision_tree_path: "support_triage"
+    keywords: "customer support, support, help desk, helpdesk, tickets, ticketing, support tickets, triage, customer service, customer queries, customer care, cx, knowledge base, kb, kb articles, macros, deflection, escalation, csat, sla, zendesk, intercom, freshdesk, gorgias, kustomer, slack support, email support, chat support, live chat, whatsapp support, phone support, omnichannel support, agent assist, tier 1, tier 2, complaints, service desk, contact center, support team"
     description: >
       Reactive support team. Multi-entry: Slack/email/chat/phone/web
       channels each fire ticket.opened. Team: triage · sentiment ·
@@ -204,11 +210,12 @@ templates:
     one_line: "Health score → risk → playbook → QBR → renewal — proactive."
     industries: ["saas"]
     roi_cells: ["cs × saas"]
-    agent_count: 15
+    agent_count: 16
     cron_count: 1
     trust_lead: "customer visibility — high — save-play actions HITL-gated"
     complexity: "high"
     decision_tree_path: "retention_motion"
+    keywords: "customer success, retention, churn, churn prevention, churn risk, renewal, renewals, renewal forecast, health score, account health, qbr, qbr deck, ebr, csm, csm team, account management, save play, playbooks, success plans, upsell, expansion, expansion revenue, nps, customer health, proactive outreach, onboarding customers, telemetry, adoption, success manager, post sales, gainsight, totango, net revenue retention, nrr"
     description: >
       Proactive (NOT reactive) retention team. Multi-entry:
       product-telemetry signal, billing event, support escalation
@@ -235,6 +242,7 @@ templates:
     trust_lead: "internal — risky tunes HITL-gated by SRE"
     complexity: "medium"
     decision_tree_path: "cloud_cost"
+    keywords: "infrastructure, cloud cost, cost optimization, cost management, finops, cloud finops, aws, gcp, azure, ec2, s3 cost, right sizing, instance right sizing, autoscaling, reserved instances, spot instances, savings plan, commitment discounts, cloud spend, billing optimization, sre, devops, iac, terraform drift, cost anomaly, cost allocation, tagging, platform engineering, cloud bill, cloud waste, spend optimization, kubernetes cost, optimize spend"
     description: >
       Continuous cloud-cost optimization. Multi-entry: cost-anomaly
       alert, scheduled right-size sweep, IaC commit triggers drift
@@ -260,6 +268,7 @@ templates:
     trust_lead: "customer — pipeline-health monitor on adaptive routing"
     complexity: "medium"
     decision_tree_path: "inbound_sales"
+    keywords: "inbound sales, lead scoring, lead routing, lead management, lead distribution, round robin routing, sales, marketing handoff, mql, sql, marketing qualified, sales qualified, lead handoff, lead nurture, nurture sequences, lead enrichment, lead qualification, sequences, crm, salesforce, hubspot, marketo, pardot, revops, ae, sdr handoff, demo request, web form leads, pipeline routing, pipeline management, deal routing, inbound leads, sales engagement, sales ops"
     description: >
       Inbound-sales team. Multi-entry: web-form submit, demo request,
       event-list ingest, partner-lead handoff, scheduled
@@ -276,11 +285,12 @@ templates:
     one_line: "RFP → past-proposal → draft → pricing → compliance."
     industries: ["services"]
     roi_cells: ["bd × services"]
-    agent_count: 14
+    agent_count: 15
     cron_count: 0
     trust_lead: "customer — legal compliance reviewer + practice-lead HITL on pricing"
     complexity: "medium"
     decision_tree_path: "proposal_factory"
+    keywords: "business development, bd, proposals, proposal automation, rfp, rfp response, rfp automation, rfq response, bids, bidding, bid response, tenders, tender response, govcon, capture management, win themes, win proposals, proposal writing, proposal library, pricing, pricing strategy, compliance review, engagement, sow, statement of work, redline, contracts review, presales, presales engineering, solutioning, response writing, loopio, responsive, qvidian"
     description: >
       RFP-response team. Multi-entry: RFP email, RFP portal upload,
       partner-referred opportunity. Team: RFP ingester · past-proposal
@@ -296,11 +306,12 @@ templates:
     one_line: "RFQ → cost calc → discount policy → approval → quote."
     industries: ["goods", "services"]
     roi_cells: ["price × goods"]
-    agent_count: 13
+    agent_count: 14
     cron_count: 0
     trust_lead: "customer + regulator (margin policy) — discount approval HITL-gated"
     complexity: "medium"
     decision_tree_path: "dynamic_pricing"
+    keywords: "quote to cash, cpq, cpq automation, pricing, price quoting, quote, quoting, quote generation, rfq, discount, discount governance, deal desk, deal desk approval, margin, margin protection, quotes, order forms, configure price quote, contracts, redline, sales quote, pricing approval, approval workflow, q2c, price calculation, pricing engine, discount approval, deal approval, salesforce cpq, dealhub, quoting team, sales operations"
     description: >
       RFQ-to-quote team. Multi-entry: RFQ email, sales-rep request,
       CPQ event, competitor-price-change webhook. Team: RFQ ingester ·
@@ -322,11 +333,12 @@ templates:
     one_line: "Brief → context → research → analysis → draft → QA."
     industries: ["services", "saas (PS arm)"]
     roi_cells: ["util × services", "hours × services"]
-    agent_count: 18
+    agent_count: 19
     cron_count: 1
     trust_lead: "customer — engagement-lead HITL on final delivery"
     complexity: "high"
     decision_tree_path: "consulting_engagement"
+    keywords: "professional services, consulting, delivery, client delivery, billable, billable hours, engagement, engagement management, deliverables, deliverable production, client deliverables, client work, research, research reports, analysis, reports, consulting reports, slide decks, ps arm, professional services automation, psa, utilization, consultant, project delivery, qa review, sme review, agency work, agency delivery, advisory, delivery team"
     description: >
       Billable-delivery team — covers both "more output per head" and
       "fewer hours per job" ROI angles in a single mesh. Multi-entry:
@@ -343,11 +355,12 @@ templates:
     one_line: "Forecast → skills match → allocate → idle-detect."
     industries: ["services"]
     roi_cells: ["bench × services"]
-    agent_count: 11
+    agent_count: 12
     cron_count: 0
     trust_lead: "internal — staffing-partner HITL on allocation conflicts"
     complexity: "medium"
     decision_tree_path: "staff_utilization"
+    keywords: "bench, bench management, bench optimization, resource management, resource allocation, staffing, staffing decisions, allocation, utilization, utilization rate, billable utilization, capacity planning, capacity management, skills matching, skills inventory, resource planning, staff allocation, project staffing, talent deployment, idle resources, reskilling, resourcing, people allocation, resource manager, staffing partner, consultant allocation"
     description: >
       Continuous resource-allocation team. Multi-entry: new project
       kickoff, person rolls off engagement, weekly bench review.
@@ -373,6 +386,7 @@ templates:
     trust_lead: "internal — planner HITL on conflict / major change"
     complexity: "medium"
     decision_tree_path: "factory_planning"
+    keywords: "production planning, production scheduling, manufacturing, manufacturing planning, scheduling, factory, demand sensing, demand forecasting, capacity planning, mrp, mps, master production schedule, materials planning, shop floor, shop floor scheduling, plant, plant scheduling, production schedule, master scheduler, supply planning, line scheduling, line balancing, build plan, make plan, make to order, planner"
     description: >
       Production-planning team. Multi-entry: demand signal arrives,
       capacity change event, scheduled re-optimization wake-up. Team:
@@ -394,6 +408,7 @@ templates:
     trust_lead: "internal — QA-manager HITL on batch-release decisions"
     complexity: "medium"
     decision_tree_path: "quality_systems"
+    keywords: "quality, qa, quality assurance, quality inspection, quality control, qc, yield, yield optimization, yield improvement, scrap reduction, defect detection, defect tracking, root cause, root cause analysis, corrective action, corrective and preventive action, capa, spc, spc charts, statistical process control, manufacturing quality, batch release, batch quality, inspection, inspection automation, six sigma, qa inspector, quality team"
     description: >
       Quality-inspection team. Multi-entry: vision-system event,
       SPC-out-of-control signal, customer complaint webhook,
@@ -415,6 +430,7 @@ templates:
     trust_lead: "internal — reliability-engineer HITL on shutdown / unscheduled work"
     complexity: "medium"
     decision_tree_path: "asset_reliability"
+    keywords: "predictive maintenance, maintenance, condition based maintenance, preventive maintenance, asset management, asset reliability, condition monitoring, equipment monitoring, failure prediction, vibration analysis, work order, work order management, iiot, iot sensors, sensors, reliability, reliability engineer, cmms, downtime, downtime reduction, maintenance scheduling, equipment, repair, technician dispatch, machine health, maintenance team"
     description: >
       Condition-based maintenance team. Multi-entry: IIoT sensor
       anomaly, work order filed, scheduled inspection, parts-arrived
@@ -436,6 +452,7 @@ templates:
     trust_lead: "internal + safety — ops-supervisor HITL on damage / exception; humanoid actions audit-trailed"
     complexity: "high"
     decision_tree_path: "physical_operations"
+    keywords: "warehouse, warehouse operations, supply chain, supply chain operations, logistics, logistics automation, fulfillment, order fulfillment, picking, packing, shipping, pick pack ship, inventory, inventory management, wms, wms integration, humanoid, humanoid robots, robotics, robotics fulfillment, distribution, distribution center, dc operations, 3pl, third party logistics, cycle count, cycle counting, ecommerce fulfillment, returns, warehouse team"
     description: >
       Warehouse-operations team — introduces the humanoid actor kind
       for physical work. Multi-entry: order placed, returns received,
@@ -453,11 +470,12 @@ templates:
     one_line: "Order intake → inventory check → supplier sourcing → PO → goods receipt."
     industries: ["goods", "services"]
     roi_cells: ["procurement × goods"]
-    agent_count: 11
+    agent_count: 12
     cron_count: 1
     trust_lead: "operations-manager HITL on order approval; po-approver HITL before formal PO issuance; hash-chained audit on every state change"
     complexity: "high"
     decision_tree_path: "procure_to_pay"
+    keywords: "procurement, purchasing, purchasing automation, procure to pay, p2p, purchase order, po, po generation, supplier, supplier management, supplier onboarding, sourcing, strategic sourcing, vendor management, vendor sourcing, vendor onboarding, goods receipt, supply chain, buyer, requisition, purchase requisition, three way match, trade compliance, tariff, erp, sap procurement, coupa, ariba, spend management, spend control, procurement team"
     description: >
       Procure-to-pay team — order intake + compliance screening in a
       single LLM pass, then inventory check, supplier sourcing,
@@ -487,6 +505,7 @@ templates:
     trust_lead: "brand + legal visibility — compliance gates publish; legal HITL on regulated claims; CMO on budget > 50K and crises"
     complexity: "high"
     decision_tree_path: "campaign_growth"
+    keywords: "marketing, marketing operations, marketing automation, campaign, campaign management, growth, growth marketing, content, content marketing, content creation, copywriting, creative, brand, brand campaigns, advertising, ad campaigns, paid ads, attribution, marketing attribution, performance marketing, cmo, cmo office, social media, social media marketing, publishing, demand generation, seo, email marketing, hubspot marketing, marketo, content team"
     description: >
       Marketing team — campaign briefs land via many channels (form,
       email, product-launch, competitor signal, crisis). Team: