diff --git a/api_hook_client.py b/api_hook_client.py
index 32ef359..496c0cb 100644
--- a/api_hook_client.py
+++ b/api_hook_client.py
@@ -1,5 +1,5 @@
 from __future__ import annotations
-import requests
+import requests # type: ignore[import-untyped]
 import json
 import time
 from typing import Any
@@ -23,7 +23,7 @@ class ApiHookClient:
     time.sleep(0.1)
   return False
 
- def _make_request(self, method: str, endpoint: str, data: dict | None = None, timeout: float | None = None) -> dict | None:
+ def _make_request(self, method: str, endpoint: str, data: dict[str, Any] | None = None, timeout: float | None = None) -> dict[str, Any] | None:
   url = f"{self.base_url}{endpoint}"
   headers = {'Content-Type': 'application/json'}
   last_exception = None
@@ -38,7 +38,8 @@ class ApiHookClient:
     else:
      raise ValueError(f"Unsupported HTTP method: {method}")
     response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
-    return response.json()
+    res_json = response.json()
+    return res_json if isinstance(res_json, dict) else None
    except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
     last_exception = e
     if attempt < self.max_retries:
@@ -55,49 +56,51 @@ class ApiHookClient:
     raise ValueError(f"Failed to decode JSON from response for {endpoint}: {response.text}") from e
   if last_exception:
    raise last_exception
+  return None
 
- def get_status(self) -> dict:
+ def get_status(self) -> dict[str, Any]:
   """Checks the health of the hook server."""
   url = f"{self.base_url}/status"
   try:
    response = requests.get(url, timeout=5.0)
    response.raise_for_status()
-   return response.json()
+   res = response.json()
+   return res if isinstance(res, dict) else {}
   except Exception:
    raise requests.exceptions.ConnectionError(f"Could not reach /status at {self.base_url}")
 
- def get_project(self) -> dict | None:
+ def get_project(self) -> dict[str, Any] | None:
   return self._make_request('GET', '/api/project')
 
- def post_project(self, project_data: dict) -> dict | None:
+ def post_project(self, project_data: dict[str, Any]) -> dict[str, Any] | None:
   return self._make_request('POST', '/api/project', data={'project': project_data})
 
- def get_session(self) -> dict | None:
+ def get_session(self) -> dict[str, Any] | None:
   res = self._make_request('GET', '/api/session')
   return res
 
- def get_mma_status(self) -> dict | None:
+ def get_mma_status(self) -> dict[str, Any] | None:
   """Retrieves current MMA status (track, tickets, tier, etc.)"""
   return self._make_request('GET', '/api/gui/mma_status')
 
- def push_event(self, event_type: str, payload: dict) -> dict | None:
+ def push_event(self, event_type: str, payload: dict[str, Any]) -> dict[str, Any] | None:
   """Pushes an event to the GUI's AsyncEventQueue via the /api/gui endpoint."""
   return self.post_gui({
     "action": event_type,
     "payload": payload
    })
 
- def get_performance(self) -> dict | None:
+ def get_performance(self) -> dict[str, Any] | None:
   """Retrieves UI performance metrics."""
   return self._make_request('GET', '/api/performance')
 
- def post_session(self, session_entries: list) -> dict | None:
+ def post_session(self, session_entries: list[Any]) -> dict[str, Any] | None:
   return self._make_request('POST', '/api/session', data={'session': {'entries': session_entries}})
 
- def post_gui(self, gui_data: dict) -> dict | None:
+ def post_gui(self, gui_data: dict[str, Any]) -> dict[str, Any] | None:
   return self._make_request('POST', '/api/gui', data=gui_data)
 
- def select_tab(self, tab_bar: str, tab: str) -> dict | None:
+ def select_tab(self, tab_bar: str, tab: str) -> dict[str, Any] | None:
   """Tells the GUI to switch to a specific tab in a tab bar."""
   return self.post_gui({
     "action": "select_tab",
@@ -105,7 +108,7 @@ class ApiHookClient:
     "tab": tab
    })
 
- def select_list_item(self, listbox: str, item_value: str) -> dict | None:
+ def select_list_item(self, listbox: str, item_value: str) -> dict[str, Any] | None:
   """Tells the GUI to select an item in a listbox by its value."""
   return self.post_gui({
     "action": "select_list_item",
@@ -113,7 +116,7 @@ class ApiHookClient:
     "item_value": item_value
    })
 
- def set_value(self, item: str, value: Any) -> dict | None:
+ def set_value(self, item: str, value: Any) -> dict[str, Any] | None:
   """Sets the value of a GUI item."""
   return self.post_gui({
     "action": "set_value",
@@ -144,7 +147,7 @@ class ApiHookClient:
   try:
   # Fallback for thinking/live/prior which are in diagnostics
    diag = self._make_request('GET', '/api/gui/diagnostics')
-   if item in diag:
+   if diag and item in diag:
     return diag[item]
     # Map common indicator tags to diagnostics keys
    mapping = {
@@ -153,7 +156,7 @@ class ApiHookClient:
     "prior_session_indicator": "prior"
    }
    key = mapping.get(item)
-   if key and key in diag:
+   if diag and key and key in diag:
     return diag[key]
   except Exception:
    pass
@@ -171,15 +174,15 @@ class ApiHookClient:
    return val
   try:
    diag = self._make_request('GET', '/api/gui/diagnostics')
-   if 'nodes' in diag and node_tag in diag['nodes']:
+   if diag and 'nodes' in diag and node_tag in diag['nodes']:
     return diag['nodes'][node_tag]
-   if node_tag in diag:
+   if diag and node_tag in diag:
     return diag[node_tag]
   except Exception:
    pass
   return None
 
- def click(self, item: str, *args: Any, **kwargs: Any) -> dict | None:
+ def click(self, item: str, *args: Any, **kwargs: Any) -> dict[str, Any] | None:
   """Simulates a click on a GUI button or item."""
   user_data = kwargs.pop('user_data', None)
   return self.post_gui({
@@ -190,7 +193,7 @@ class ApiHookClient:
     "user_data": user_data
    })
 
- def get_indicator_state(self, tag: str) -> dict:
+ def get_indicator_state(self, tag: str) -> dict[str, Any]:
   """Checks if an indicator is shown using the diagnostics endpoint."""
   # Mapping tag to the keys used in diagnostics endpoint
   mapping = {
@@ -201,24 +204,25 @@ class ApiHookClient:
   key = mapping.get(tag, tag)
   try:
    diag = self._make_request('GET', '/api/gui/diagnostics')
-   return {"tag": tag, "shown": diag.get(key, False)}
+   return {"tag": tag, "shown": diag.get(key, False) if diag else False}
   except Exception as e:
    return {"tag": tag, "shown": False, "error": str(e)}
 
- def get_events(self) -> list:
+ def get_events(self) -> list[Any]:
   """Fetches and clears the event queue from the server."""
   try:
-   return self._make_request('GET', '/api/events').get("events", [])
+   res = self._make_request('GET', '/api/events')
+   return res.get("events", []) if res else []
   except Exception:
    return []
 
- def wait_for_event(self, event_type: str, timeout: float = 5) -> dict | None:
+ def wait_for_event(self, event_type: str, timeout: float = 5) -> dict[str, Any] | None:
   """Polls for a specific event type."""
   start = time.time()
   while time.time() - start < timeout:
    events = self.get_events()
    for ev in events:
-    if ev.get("type") == event_type:
+    if isinstance(ev, dict) and ev.get("type") == event_type:
      return ev
    time.sleep(0.1) # Fast poll
   return None
@@ -232,14 +236,14 @@ class ApiHookClient:
    time.sleep(0.1) # Fast poll
   return False
 
- def reset_session(self) -> dict | None:
+ def reset_session(self) -> dict[str, Any] | None:
   """Simulates clicking the 'Reset Session' button in the GUI."""
   return self.click("btn_reset")
 
- def request_confirmation(self, tool_name: str, args: dict) -> Any:
+ def request_confirmation(self, tool_name: str, args: dict[str, Any]) -> Any:
   """Asks the user for confirmation via the GUI (blocking call)."""
   # Using a long timeout as this waits for human input (60 seconds)
   res = self._make_request('POST', '/api/ask',
    data={'type': 'tool_approval', 'tool': tool_name, 'args': args},
    timeout=60.0)
-  return res.get('response')
+  return res.get('response') if res else None
diff --git a/conductor/tracks/strict_static_analysis_and_typing_20260302/plan.md b/conductor/tracks/strict_static_analysis_and_typing_20260302/plan.md
index 37fefb2..6016193 100644
--- a/conductor/tracks/strict_static_analysis_and_typing_20260302/plan.md
+++ b/conductor/tracks/strict_static_analysis_and_typing_20260302/plan.md
@@ -10,11 +10,11 @@
 - [x] Task: Conductor - User Manual Verification 'Phase 1: Configuration' (Protocol in workflow.md)
 
 ## Phase 2: Core Library Typing Resolution
-- [ ] Task: Resolve `api_hook_client.py` and `models.py` Type Errors
-    - [ ] WHERE: `api_hook_client.py`, `models.py`, `events.py`
-    - [ ] WHAT: Add explicit type hints to all function arguments, return values, and complex dictionaries. Resolve `Any` bleeding.
-    - [ ] HOW: Surgical type annotations (`dict[str, Any]`, `list[str]`, etc.).
-    - [ ] SAFETY: Do not change runtime logic, only type signatures.
+- [x] Task: Resolve `api_hook_client.py` and `models.py` Type Errors
+    - [x] WHERE: `api_hook_client.py`, `models.py`, `events.py`
+    - [x] WHAT: Add explicit type hints to all function arguments, return values, and complex dictionaries. Resolve `Any` bleeding.
+    - [x] HOW: Surgical type annotations (`dict[str, Any]`, `list[str]`, etc.).
+    - [x] SAFETY: Do not change runtime logic, only type signatures.
 - [ ] Task: Resolve Conductor Subsystem Type Errors
     - [ ] WHERE: `conductor_tech_lead.py`, `dag_engine.py`, `orchestrator_pm.py`
     - [ ] WHAT: Enforce strict typing on track state, tickets, and DAG models.
diff --git a/events.py b/events.py
index f3e63e3..a033f71 100644
--- a/events.py
+++ b/events.py
@@ -11,9 +11,9 @@ class EventEmitter:
 
  def __init__(self) -> None:
   """Initializes the EventEmitter with an empty listener map."""
-  self._listeners: Dict[str, List[Callable]] = {}
+  self._listeners: Dict[str, List[Callable[..., Any]]] = {}
 
- def on(self, event_name: str, callback: Callable) -> None:
+ def on(self, event_name: str, callback: Callable[..., Any]) -> None:
   """
         Registers a callback for a specific event.
         
@@ -45,7 +45,7 @@ class AsyncEventQueue:
 
  def __init__(self) -> None:
   """Initializes the AsyncEventQueue with an internal asyncio.Queue."""
-  self._queue: asyncio.Queue = asyncio.Queue()
+  self._queue: asyncio.Queue[Tuple[str, Any]] = asyncio.Queue()
 
  async def put(self, event_name: str, payload: Any = None) -> None:
   """
diff --git a/models.py b/models.py
index 26d5a88..a52d3e2 100644
--- a/models.py
+++ b/models.py
@@ -49,9 +49,9 @@ class Ticket:
  def from_dict(cls, data: Dict[str, Any]) -> "Ticket":
   return cls(
    id=data["id"],
-   description=data.get("description"),
-   status=data.get("status"),
-   assigned_to=data.get("assigned_to"),
+   description=data.get("description", ""),
+   status=data.get("status", "todo"),
+   assigned_to=data.get("assigned_to", ""),
    target_file=data.get("target_file"),
    context_requirements=data.get("context_requirements", []),
    depends_on=data.get("depends_on", []),
@@ -97,7 +97,7 @@ class WorkerContext:
     """
  ticket_id: str
  model_name: str
- messages: List[dict]
+ messages: List[Dict[str, Any]]
 
 @dataclass
 class Metadata:
@@ -121,9 +121,9 @@ class Metadata:
   return cls(
    id=data["id"],
    name=data["name"],
-   status=data.get("status"),
-   created_at=datetime.fromisoformat(data['created_at']) if data.get('created_at') else None,
-   updated_at=datetime.fromisoformat(data['updated_at']) if data.get('updated_at') else None,
+   status=data.get("status", "todo"),
+   created_at=datetime.fromisoformat(data['created_at']) if data.get('created_at') else datetime.now(),
+   updated_at=datetime.fromisoformat(data['updated_at']) if data.get('updated_at') else datetime.now(),
   )
 
 @dataclass