working pipelines with proper baselineees

baseline_scores.json

@@ -1,8 +1,8 @@
 {
   "scores": {
-    "workflow_A": 0.7,
-    "workflow_B": 0.563,
-    "workflow_C": 0.625
+    "workflow_A": 0.75,
+    "workflow_B": 0.613,
+    "workflow_C": 0.722
   },
-  "average": 0.6293
+  "average": 0.695
 }

inference.py

@@ -65,7 +65,8 @@ Available apps and key operations:
   jira:       get_issue, create_issue, update_status, set_priority, assign_owner,
               add_label, link_zendesk_ticket, close_issue, list_issues
   zendesk:    get_ticket, acknowledge_ticket, set_urgency, assign_agent,
-              escalate_to_jira, resolve_ticket, add_note, list_tickets
+              escalate_to_jira, resolve_ticket, add_note, list_tickets,
+              create_agent_profile
   salesforce: get_account, list_accounts, update_deal_stage, flag_churn_risk,
               assign_account_owner, log_interaction, get_opportunity
   workday:    get_employee, list_employees, provision_access, log_sla_event,
@@ -84,6 +85,7 @@ Example actions:
   {"app": "jira", "operation": "create_issue", "args": {"title": "Bug fix for ACME-001", "linked_zendesk": "ZD-001"}}
   {"app": "salesforce", "operation": "get_account", "args": {"account_id": "ACME-001"}}
   {"app": "workday", "operation": "log_sla_event", "args": {"ticket_id": "ZD-001", "sla_met": true}}
+  {"app": "zendesk", "operation": "create_agent_profile", "args": {"employee_id": "EMP-NEW-001", "email": "jordan.riley@company.com", "name": "Jordan Riley"}}
 """
 
 WORKFLOW_NAMES = {
@@ -198,8 +200,14 @@ def run_workflow(workflow_id: str) -> float:
             history.append({"role": "user", "content": obs_text})
 
             # Trim history to avoid context overflow
+            # if len(history) > 20:
+            #     history = history[-20:]
+            # Trim history — always keep an even number so roles alternate correctly
             if len(history) > 20:
                 history = history[-20:]
+            # Ensure history starts with a user message (Gemma requires strict alternation)
+            if history and history[0]["role"] != "user":
+                history = history[1:]            
 
             try:
                 response = llm_client.chat.completions.create(

server/apps/jira.py

@@ -191,9 +191,13 @@ class JiraApp(BaseApp):
 
         assignee = (kwargs.get("assignee") or kwargs.get("owner")
                     or kwargs.get("assigned_to"))
+        # if not assignee:
+        #     return {"success": False,
+        #             "message": "Provide assignee / owner / assigned_to value"}
         if not assignee:
+            correct_field = self._drift.translate_field("assignee", self.APP_NAME)
             return {"success": False,
-                    "message": "Provide assignee / owner / assigned_to value"}
+                    "message": f"Missing assignee field. Use '{correct_field}' as the arg key for this episode."}
 
         rec["assignee"] = assignee
         self._assigned_issues.add(issue_id)
@@ -241,3 +245,247 @@ class JiraApp(BaseApp):
         return {"success": True, "data": compact,
                 "message": f"Found {len(compact)} {status} issues"
                            + (f" for {customer_id}" if customer_id else "")}
+# """Jira-like app — engineering ticket management."""
+
+# from typing import Dict, List, Optional
+# from server.apps.base_app import BaseApp
+# from server.schema_drift import SchemaDriftEngine
+
+
+# class JiraApp(BaseApp):
+#     APP_NAME = "jira"
+
+#     OPERATIONS = [
+#         "get_issue", "create_issue", "update_status", "set_priority",
+#         "assign_owner", "add_label", "link_zendesk_ticket", "close_issue", "list_issues",
+#     ]
+
+#     def __init__(self, drift: SchemaDriftEngine):
+#         super().__init__(drift)
+#         self._records: Dict[str, Dict] = {}
+#         # Workflow completion state tracking
+#         self._linked_issues: set = set()    # issue_ids linked to a Zendesk ticket
+#         self._assigned_issues: set = set()  # issue_ids with a non-null assignee
+#         self._bugs_checked: bool = False    # list_issues was called (Workflow C)
+
+#     # ------------------------------------------------------------------
+#     # BaseApp interface
+#     # ------------------------------------------------------------------
+
+#     def initialize(self, records: List[Dict]) -> None:
+#         self._records = {r["issue_id"]: r for r in records}
+#         self._linked_issues.clear()
+#         self._assigned_issues.clear()
+#         self._bugs_checked = False
+#         # Seed state from loaded data
+#         for issue_id, rec in self._records.items():
+#             if rec.get("assignee"):
+#                 self._assigned_issues.add(issue_id)
+#             if rec.get("linked_zendesk"):
+#                 self._linked_issues.add(issue_id)
+
+#     def execute(self, operation: str, args: Dict) -> Dict:
+#         method = getattr(self, f"_op_{operation}", None)
+#         if method is None:
+#             return {
+#                 "success": False,
+#                 "message": f"Unknown operation '{operation}'. Available: {', '.join(self.OPERATIONS)}",
+#             }
+#         try:
+#             return method(**args)
+#         except TypeError as exc:
+#             return {"success": False, "message": f"Bad args for '{operation}': {exc}"}
+
+#     def get_state_view(self, max_rows: int = 5) -> str:
+#         open_issues = [r for r in self._records.values()
+#                        if r.get("status") not in ("closed",)][:max_rows]
+#         if not open_issues:
+#             return "No open issues."
+#         lines = []
+#         for rec in open_issues:
+#             view = self._to_agent_view(rec)
+#             keep = ["issue_id", "title",
+#                     "priority", "severity", "urgency_level",
+#                     "assignee", "owner", "assigned_to",
+#                     "status", "state", "current_state",
+#                     "customer_id", "linked_zendesk"]
+#             compact = {k: v for k, v in view.items() if k in keep and v is not None}
+#             lines.append(str(compact))
+#         return "\n".join(lines)
+
+#     def count_open_items(self) -> int:
+#         return sum(1 for r in self._records.values() if r.get("status") != "closed")
+
+#     # ------------------------------------------------------------------
+#     # Workflow completion state checks
+#     # ------------------------------------------------------------------
+
+#     def has_linked_issue(self) -> bool:
+#         """True once any issue is linked to a Zendesk ticket (Workflow A step A2)."""
+#         return len(self._linked_issues) > 0
+
+#     def issue_assigned(self) -> bool:
+#         """True once JIRA-001 (primary bug) has an assignee (Workflow A step A4)."""
+#         return bool(self._records.get("JIRA-001", {}).get("assignee"))
+
+#     def bugs_checked(self) -> bool:
+#         """True once list_issues has been called (Workflow C step C3)."""
+#         return self._bugs_checked
+
+#     # ------------------------------------------------------------------
+#     # Operations
+#     # ------------------------------------------------------------------
+
+#     def _op_get_issue(self, issue_id: str) -> Dict:
+#         rec = self._records.get(issue_id)
+#         if not rec:
+#             return {"success": False, "message": f"Issue {issue_id} not found. Use list_issues to browse."}
+#         return {"success": True, "data": self._to_agent_view(rec),
+#                 "message": f"Retrieved {issue_id}"}
+
+#     def _op_create_issue(self, title: str, **kwargs) -> Dict:
+#         schema_error, schema_adapted = self._check_schema_drift(kwargs)
+#         if schema_error:
+#             return {
+#                 "success": False,
+#                 "schema_error": schema_error,
+#                 "message": (f"Schema error: field '{schema_error}' is not in the current schema. "
+#                             f"Check schema_hints for the correct field name."),
+#             }
+
+#         issue_id = f"JIRA-{len(self._records) + 1:03d}"
+#         # Accept both canonical and drifted names for priority / assignee
+#         priority = (kwargs.get("priority") or kwargs.get("severity")
+#                     or kwargs.get("urgency_level", "p2"))
+#         linked   = kwargs.get("linked_zendesk") or kwargs.get("zendesk_ticket")
+
+#         rec = {
+#             "issue_id":       issue_id,
+#             "title":          title,
+#             "priority":       priority,
+#             "assignee":       kwargs.get("assignee") or kwargs.get("owner") or kwargs.get("assigned_to"),
+#             "status":         "open",
+#             "reporter":       kwargs.get("reporter", "agent"),
+#             "customer_id":    kwargs.get("customer_id"),
+#             "linked_zendesk": linked,
+#             "labels":         [],
+#             "created_at":     "2026-04-21T09:00:00",
+#         }
+#         self._records[issue_id] = rec
+
+#         if linked:
+#             self._linked_issues.add(issue_id)
+#         if rec["assignee"]:
+#             self._assigned_issues.add(issue_id)
+
+#         return {
+#             "success": True,
+#             "data": {"issue_id": issue_id},
+#             "schema_adapted": schema_adapted,
+#             "message": f"Created {issue_id}: '{title}'"
+#                        + (f" linked to {linked}" if linked else ""),
+#         }
+
+#     def _op_update_status(self, issue_id: str, **kwargs) -> Dict:
+#         schema_error, schema_adapted = self._check_schema_drift(kwargs)
+#         if schema_error:
+#             return {"success": False, "schema_error": schema_error,
+#                     "message": f"Schema error: use current field name, not '{schema_error}'"}
+
+#         rec = self._records.get(issue_id)
+#         if not rec:
+#             return {"success": False, "message": f"Issue {issue_id} not found"}
+
+#         new_status = (kwargs.get("status") or kwargs.get("state")
+#                       or kwargs.get("current_state"))
+#         if not new_status:
+#             return {"success": False, "message": "Provide status/state/current_state value"}
+
+#         rec["status"] = new_status
+#         return {"success": True, "schema_adapted": schema_adapted,
+#                 "message": f"{issue_id} status → '{new_status}'"}
+
+#     def _op_set_priority(self, issue_id: str, **kwargs) -> Dict:
+#         schema_error, schema_adapted = self._check_schema_drift(kwargs)
+#         if schema_error:
+#             return {"success": False, "schema_error": schema_error,
+#                     "message": f"Schema error: '{schema_error}' is a stale field name"}
+
+#         rec = self._records.get(issue_id)
+#         if not rec:
+#             return {"success": False, "message": f"Issue {issue_id} not found"}
+
+#         new_priority = (kwargs.get("priority") or kwargs.get("severity")
+#                         or kwargs.get("urgency_level"))
+#         if not new_priority:
+#             return {"success": False,
+#                     "message": "Provide priority / severity / urgency_level value"}
+
+#         rec["priority"] = new_priority
+#         return {"success": True, "schema_adapted": schema_adapted,
+#                 "message": f"{issue_id} priority → '{new_priority}'"}
+
+#     def _op_assign_owner(self, issue_id: str, **kwargs) -> Dict:
+#         schema_error, schema_adapted = self._check_schema_drift(kwargs)
+#         if schema_error:
+#             hint = self._drift.translate_field("assignee", self.APP_NAME)
+#             return {"success": False, "schema_error": schema_error,
+#                     "message": f"Schema error: use '{hint}' instead of '{schema_error}'"}
+
+#         rec = self._records.get(issue_id)
+#         if not rec:
+#             return {"success": False, "message": f"Issue {issue_id} not found"}
+
+#         assignee = (kwargs.get("assignee") or kwargs.get("owner")
+#                     or kwargs.get("assigned_to"))
+#         if not assignee:
+#             correct_field = self._drift.translate_field("assignee", self.APP_NAME)
+#             return {"success": False,
+#                     "message": f"Missing assignee field. Use '{correct_field}' as the arg key for this episode."}
+
+#         rec["assignee"] = assignee
+#         self._assigned_issues.add(issue_id)
+#         return {"success": True, "schema_adapted": schema_adapted,
+#                 "message": f"{issue_id} assigned to '{assignee}'"}
+
+#     def _op_add_label(self, issue_id: str, label: str) -> Dict:
+#         rec = self._records.get(issue_id)
+#         if not rec:
+#             return {"success": False, "message": f"Issue {issue_id} not found"}
+#         rec.setdefault("labels", []).append(label)
+#         return {"success": True, "message": f"Added label '{label}' to {issue_id}"}
+
+#     def _op_link_zendesk_ticket(self, issue_id: str, zendesk_ticket_number: str) -> Dict:
+#         rec = self._records.get(issue_id)
+#         if not rec:
+#             return {"success": False, "message": f"Issue {issue_id} not found"}
+#         rec["linked_zendesk"] = zendesk_ticket_number
+#         self._linked_issues.add(issue_id)
+#         return {"success": True,
+#                 "message": f"Linked {issue_id} ↔ Zendesk {zendesk_ticket_number}"}
+
+#     def _op_close_issue(self, issue_id: str) -> Dict:
+#         rec = self._records.get(issue_id)
+#         if not rec:
+#             return {"success": False, "message": f"Issue {issue_id} not found"}
+#         rec["status"] = "closed"
+#         return {"success": True, "message": f"Closed {issue_id}"}
+
+#     def _op_list_issues(self, status: str = "open", customer_id: Optional[str] = None,
+#                         limit: int = 10) -> Dict:
+#         self._bugs_checked = True
+#         matching = [
+#             r for r in self._records.values()
+#             if (status == "all" or r.get("status") == status)
+#             and (customer_id is None or r.get("customer_id") == customer_id)
+#         ][:limit]
+#         drifted = [self._to_agent_view(r) for r in matching]
+#         keep = ["issue_id", "title", "priority", "severity", "urgency_level",
+#                 "assignee", "owner", "assigned_to",
+#                 "status", "state", "current_state",
+#                 "customer_id", "linked_zendesk"]
+#         compact = [{k: v for k, v in r.items() if k in keep and v is not None}
+#                    for r in drifted]
+#         return {"success": True, "data": compact,
+#                 "message": f"Found {len(compact)} {status} issues"
+#                            + (f" for {customer_id}" if customer_id else "")}

server/apps/salesforce.py

@@ -149,30 +149,31 @@ class SalesforceApp(BaseApp):
         }
 
     def _op_assign_account_owner(self, account_id: str, **kwargs) -> Dict:
-        schema_error, schema_adapted = self._check_schema_drift(kwargs)
-        if schema_error:
-            hint = self._drift.translate_field("owner", self.APP_NAME)
-            return {"success": False, "schema_error": schema_error,
-                    "message": f"Schema error: use '{hint}' not '{schema_error}'"}
-
-        rec = self._records.get(account_id)
-        if not rec:
-            return {"success": False, "message": f"Account {account_id} not found"}
-
-        new_owner = (kwargs.get("owner") or kwargs.get("owner_name")
-                     or kwargs.get("account_owner") or kwargs.get("rep_email"))
-        if not new_owner:
-            return {"success": False,
-                    "message": "Provide owner / owner_name / account_owner / rep_email"}
-
-        rec["owner"] = new_owner
-        rec["_team_assigned"] = True
-        if account_id == "ACME-003":
-            rec["_intervention_assigned"] = True
-
-        return {"success": True, "schema_adapted": schema_adapted,
-                "message": f"{account_id} owner → '{new_owner}'"}
-
+            schema_error, schema_adapted = self._check_schema_drift(kwargs)
+            if schema_error:
+                hint = self._drift.translate_field("owner", self.APP_NAME)
+                return {"success": False, "schema_error": schema_error,
+                        "message": f"Schema error: use '{hint}' not '{schema_error}'"}
+
+            rec = self._records.get(account_id)
+            if not rec:
+                return {"success": False, "message": f"Account {account_id} not found"}
+
+            new_owner = (kwargs.get("owner") or kwargs.get("owner_name")
+                        or kwargs.get("account_owner") or kwargs.get("rep_email"))
+            if not new_owner:
+                correct_field = self._drift.translate_field("owner", self.APP_NAME)
+                return {"success": False,
+                        "message": f"Missing owner field. Use '{correct_field}' as the arg key for this episode."}
+
+            rec["owner"] = new_owner
+            rec["_team_assigned"] = True
+            if account_id == "ACME-003":
+                rec["_intervention_assigned"] = True
+
+            return {"success": True, "schema_adapted": schema_adapted,
+                    "message": f"{account_id} owner → '{new_owner}'"}
+                    
     def _op_log_interaction(self, account_id: str, note: str = "") -> Dict:
         rec = self._records.get(account_id)
         if not rec:

server/apps/zendesk.py

@@ -236,3 +236,282 @@ class ZendeskApp(BaseApp):
             "message": f"Found {len(compact)} {state} tickets"
                        + (f" for {customer_id}" if customer_id else ""),
         }
+
+    def _op_create_agent_profile(self, employee_id: str, email: str,
+                                 name: Optional[str] = None, **kwargs) -> Dict:
+        """Create a Zendesk support agent profile (Workflow B step B4)."""
+        if employee_id in self._records:
+            return {"success": False,
+                    "message": f"Profile for {employee_id} already exists"}
+        profile = {
+            "ticket_number":     employee_id,
+            "title":             f"Agent profile — {name or employee_id}",
+            "urgency":           "p3",
+            "agent_email":       email,
+            "state":             "closed",
+            "customer_id":       None,
+            "_acknowledged":     False,
+            "_queried_accounts": [],
+            "_profile_created":  True,
+        }
+        self._records[employee_id] = profile
+        return {"success": True,
+                "message": f"Created Zendesk agent profile for {name or employee_id} ({email})"}
+# """Zendesk-like app — customer support ticket management."""
+
+# from typing import Dict, List, Optional
+# from server.apps.base_app import BaseApp
+# from server.schema_drift import SchemaDriftEngine
+
+
+# class ZendeskApp(BaseApp):
+#     APP_NAME = "zendesk"
+
+#     OPERATIONS = [
+#         "get_ticket", "acknowledge_ticket", "set_urgency", "assign_agent",
+#         "escalate_to_jira", "resolve_ticket", "add_note", "list_tickets","create_agent_profile",
+#     ]
+
+#     def __init__(self, drift: SchemaDriftEngine):
+#         super().__init__(drift)
+#         self._records: Dict[str, Dict] = {}
+
+#     # ------------------------------------------------------------------
+#     # BaseApp interface
+#     # ------------------------------------------------------------------
+
+#     def initialize(self, records: List[Dict]) -> None:
+#         self._records = {r["ticket_number"]: r for r in records}
+
+#     def execute(self, operation: str, args: Dict) -> Dict:
+#         method = getattr(self, f"_op_{operation}", None)
+#         if method is None:
+#             return {
+#                 "success": False,
+#                 "message": f"Unknown operation '{operation}'. Available: {', '.join(self.OPERATIONS)}",
+#             }
+#         try:
+#             return method(**args)
+#         except TypeError as exc:
+#             return {"success": False, "message": f"Bad args for '{operation}': {exc}"}
+
+#     def get_state_view(self, max_rows: int = 5) -> str:
+#         open_tickets = [r for r in self._records.values()
+#                         if r.get("state") not in ("resolved", "closed")][:max_rows]
+#         if not open_tickets:
+#             return "No open tickets."
+#         lines = []
+#         for rec in open_tickets:
+#             view = self._to_agent_view(rec)
+#             keep = ["ticket_number", "title",
+#                     "urgency", "priority", "impact_level",
+#                     "agent_email", "handler", "assigned_agent",
+#                     "state", "ticket_state", "resolution_status",
+#                     "customer_id"]
+#             compact = {k: v for k, v in view.items() if k in keep and v is not None}
+#             lines.append(str(compact))
+#         return "\n".join(lines)
+
+#     def count_open_items(self) -> int:
+#         return sum(1 for r in self._records.values()
+#                    if r.get("state") not in ("resolved", "closed"))
+
+#     # ------------------------------------------------------------------
+#     # Workflow completion state checks
+#     # ------------------------------------------------------------------
+
+#     def ticket_acknowledged(self) -> bool:
+#         """True once ZD-001 has been acknowledged (Workflow A step A1)."""
+#         return bool(self._records.get("ZD-001", {}).get("_acknowledged"))
+
+#     def support_queried(self, account_id: str) -> bool:
+#         """True once tickets for account_id were listed (Workflow C step C2)."""
+#         return account_id in self._records.get("ZD-001", {}).get("_queried_accounts", []) or \
+#                any(account_id in r.get("_queried_accounts", []) for r in self._records.values())
+
+#     def profile_created(self) -> bool:
+#         """True once a new agent profile was created (Workflow B step B4)."""
+#         return any(r.get("_profile_created") for r in self._records.values())
+
+#     # ------------------------------------------------------------------
+#     # Operations
+#     # ------------------------------------------------------------------
+
+#     def _op_get_ticket(self, ticket_number: str, customer_id: Optional[str] = None) -> Dict:
+#         # If customer_id provided, look up all tickets for that customer
+#         if customer_id:
+#             matching = [r for r in self._records.values()
+#                         if r.get("customer_id") == customer_id]
+#             # Mark as queried for Workflow C
+#             for r in matching:
+#                 r.setdefault("_queried_accounts", [])
+#                 if customer_id not in r["_queried_accounts"]:
+#                     r["_queried_accounts"].append(customer_id)
+#             if not matching:
+#                 return {"success": True, "data": [],
+#                         "message": f"No tickets found for customer {customer_id}"}
+#             return {
+#                 "success": True,
+#                 "data": [self._to_agent_view(r) for r in matching[:5]],
+#                 "message": f"Found {len(matching)} tickets for {customer_id}",
+#             }
+
+#         rec = self._records.get(ticket_number)
+#         if not rec:
+#             return {"success": False,
+#                     "message": f"Ticket {ticket_number} not found. Use list_tickets to browse."}
+#         rec.setdefault("_queried_accounts", [])
+#         cid = rec.get("customer_id")
+#         if cid and cid not in rec["_queried_accounts"]:
+#             rec["_queried_accounts"].append(cid)
+
+#         return {"success": True, "data": self._to_agent_view(rec),
+#                 "ticket": rec,
+#                 "message": f"Retrieved {ticket_number}"}
+
+#     def _op_acknowledge_ticket(self, ticket_number: str) -> Dict:
+#         rec = self._records.get(ticket_number)
+#         if not rec:
+#             return {"success": False, "message": f"Ticket {ticket_number} not found"}
+#         rec["_acknowledged"] = True
+#         if rec.get("state") == "new":
+#             rec["state"] = "open"
+#         return {"success": True, "ticket": rec,
+#                 "message": f"Acknowledged {ticket_number} — status → open"}
+
+#     def _op_set_urgency(self, ticket_number: str, **kwargs) -> Dict:
+#         schema_error, schema_adapted = self._check_schema_drift(kwargs)
+#         if schema_error:
+#             hint = self._drift.translate_field("urgency", self.APP_NAME)
+#             return {"success": False, "schema_error": schema_error,
+#                     "message": f"Schema error: use '{hint}' not '{schema_error}'"}
+
+#         rec = self._records.get(ticket_number)
+#         if not rec:
+#             return {"success": False, "message": f"Ticket {ticket_number} not found"}
+
+#         new_urgency = (kwargs.get("urgency") or kwargs.get("priority")
+#                        or kwargs.get("impact_level"))
+#         if not new_urgency:
+#             return {"success": False,
+#                     "message": "Provide urgency / priority / impact_level value"}
+
+#         rec["urgency"] = new_urgency
+#         return {"success": True, "schema_adapted": schema_adapted,
+#                 "message": f"{ticket_number} urgency → '{new_urgency}'"}
+
+#     def _op_assign_agent(self, ticket_number: str, **kwargs) -> Dict:
+#         schema_error, schema_adapted = self._check_schema_drift(kwargs)
+#         if schema_error:
+#             hint = self._drift.translate_field("agent_email", self.APP_NAME)
+#             return {"success": False, "schema_error": schema_error,
+#                     "message": f"Schema error: use '{hint}' not '{schema_error}'"}
+
+#         rec = self._records.get(ticket_number)
+#         # For Workflow B profile creation: allow creating a new agent entry
+#         if not rec:
+#             # Create a minimal profile record for the new agent
+#             email = (kwargs.get("agent_email") or kwargs.get("handler")
+#                      or kwargs.get("assigned_agent"))
+#             if not email:
+#                 return {"success": False, "message": f"Ticket {ticket_number} not found"}
+#             # Create a synthetic profile ticket
+#             profile_rec = {
+#                 "ticket_number":    ticket_number,
+#                 "title":            "Agent profile",
+#                 "urgency":          "p3",
+#                 "agent_email":      email,
+#                 "state":            "closed",
+#                 "customer_id":      None,
+#                 "_acknowledged":    False,
+#                 "_queried_accounts": [],
+#                 "_profile_created": True,
+#             }
+#             self._records[ticket_number] = profile_rec
+#             return {"success": True, "schema_adapted": schema_adapted,
+#                     "message": f"Created Zendesk profile for agent '{email}'"}
+
+#         email = (kwargs.get("agent_email") or kwargs.get("handler")
+#                  or kwargs.get("assigned_agent"))
+#         if not email:
+#             return {"success": False,
+#                     "message": "Provide agent_email / handler / assigned_agent value"}
+
+#         rec["agent_email"] = email
+#         rec["_profile_created"] = True
+#         return {"success": True, "schema_adapted": schema_adapted,
+#                 "message": f"{ticket_number} assigned to '{email}'"}
+
+#     def _op_escalate_to_jira(self, ticket_number: str,
+#                               jira_issue_id: Optional[str] = None) -> Dict:
+#         rec = self._records.get(ticket_number)
+#         if not rec:
+#             return {"success": False, "message": f"Ticket {ticket_number} not found"}
+#         rec["state"] = "pending"
+#         rec["escalated_to_jira"] = jira_issue_id or "pending"
+#         return {"success": True,
+#                 "message": f"{ticket_number} escalated to Jira"
+#                            + (f" ({jira_issue_id})" if jira_issue_id else "")}
+
+#     def _op_resolve_ticket(self, ticket_number: str) -> Dict:
+#         rec = self._records.get(ticket_number)
+#         if not rec:
+#             return {"success": False, "message": f"Ticket {ticket_number} not found"}
+#         rec["state"] = "resolved"
+#         return {"success": True, "message": f"{ticket_number} resolved"}
+
+#     def _op_add_note(self, ticket_number: str, note: str) -> Dict:
+#         rec = self._records.get(ticket_number)
+#         if not rec:
+#             return {"success": False, "message": f"Ticket {ticket_number} not found"}
+#         rec.setdefault("notes", []).append(note)
+#         return {"success": True, "message": f"Note added to {ticket_number}"}
+
+#     def _op_list_tickets(self, state: str = "open", customer_id: Optional[str] = None,
+#                          limit: int = 10) -> Dict:
+#         matching = [
+#             r for r in self._records.values()
+#             if (state == "all" or r.get("state") == state)
+#             and (customer_id is None or r.get("customer_id") == customer_id)
+#         ][:limit]
+#         # Mark accounts as queried
+#         if customer_id:
+#             for r in matching:
+#                 r.setdefault("_queried_accounts", [])
+#                 if customer_id not in r["_queried_accounts"]:
+#                     r["_queried_accounts"].append(customer_id)
+
+#         drifted = [self._to_agent_view(r) for r in matching]
+#         keep = ["ticket_number", "title",
+#                 "urgency", "priority", "impact_level",
+#                 "agent_email", "handler", "assigned_agent",
+#                 "state", "ticket_state", "resolution_status",
+#                 "customer_id"]
+#         compact = [{k: v for k, v in r.items() if k in keep and v is not None}
+#                    for r in drifted]
+#         return {
+#             "success": True,
+#             "data": compact,
+#             "message": f"Found {len(compact)} {state} tickets"
+#                        + (f" for {customer_id}" if customer_id else ""),
+#         }
+# def _op_create_agent_profile(self, employee_id: str, email: str,
+#                                  name: Optional[str] = None, **kwargs) -> Dict:
+#         """Create a Zendesk support agent profile (Workflow B step B4)."""
+#         if employee_id in self._records:
+#             return {"success": False,
+#                     "message": f"Profile for {employee_id} already exists"}
+#         profile = {
+#             "ticket_number":     employee_id,
+#             "title":             f"Agent profile — {name or employee_id}",
+#             "urgency":           "p3",
+#             "agent_email":       email,
+#             "state":             "closed",
+#             "customer_id":       None,
+#             "_acknowledged":     False,
+#             "_queried_accounts": [],
+#             "_profile_created":  True,
+#         }
+#         self._records[employee_id] = profile
+#         return {"success": True,
+#                 "message": f"Created Zendesk agent profile for {name or employee_id} ({email})"}