diff --git a/project_history.toml b/project_history.toml
index addf3bf7..ca62e587 100644
--- a/project_history.toml
+++ b/project_history.toml
@@ -9,5 +9,5 @@ active = "main"
 
 [discussions.main]
 git_commit = ""
-last_updated = "2026-05-16T03:09:58"
+last_updated = "2026-05-16T04:26:42"
 history = []
diff --git a/scripts/fix_indent_v3.py b/scripts/fix_indent_v3.py
new file mode 100644
index 00000000..29e5eeae
--- /dev/null
+++ b/scripts/fix_indent_v3.py
@@ -0,0 +1,62 @@
+import ast
+import sys
+import re
+
+def transform():
+ file_path = "src/gui_2.py"
+ with open(file_path, "r", encoding="utf-8") as f:
+  lines = f.read().splitlines()
+ content = "\n".join(lines)
+ tree = ast.parse(content)
+ app_class = next((n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == "App"), None)
+ if not app_class:
+  print("App class not found")
+  return
+ render_methods = [
+  m for m in app_class.body 
+  if isinstance(m, ast.FunctionDef) and m.name.startswith("_render_") and m.name != "_render_window_if_open"
+ ]
+ render_methods.sort(key=lambda x: x.lineno, reverse=True)
+ extracted = []
+ for m in render_methods:
+  s_idx = m.lineno - 1
+  e_idx = m.end_lineno
+  if m.decorator_list: s_idx = m.decorator_list[0].lineno - 1
+  m_lines = lines[s_idx:e_idx]
+  func_name = m.name.lstrip("_")
+  processed = []
+  for l in m_lines:
+   processed.append(l[1:] if l.startswith(" ") else l)
+  def_line_idx = -1
+  for i, l in enumerate(processed):
+   if l.strip().startswith("def "):
+    def_line_idx = i
+    break
+  if def_line_idx != -1:
+   l = processed[def_line_idx]
+   l = l.replace(f"def {m.name}(", f"def {func_name}(", 1)
+   l = re.sub(r"\bself\b", "app: App", l, count=1)
+   processed[def_line_idx] = l
+  for i in range(def_line_idx + 1, len(processed)):
+   processed[i] = re.sub(r"(?<![a-zA-Z0-9_])self\.", "app.", processed[i])
+   processed[i] = re.sub(r"(?<![a-zA-Z0-9_])self(?![a-zA-Z0-9_:])", "app", processed[i])
+  extracted.append("\n".join(processed))
+  arg_names = [a.arg for a in m.args.args if a.arg != "self"]
+  kw_names = [a.arg for a in m.args.kwonlyargs]
+  call_args = ["self"] + arg_names + [f"{k}={k}" for k in kw_names]
+  orig_def_line = m_lines[0]
+  if m.decorator_list:
+   for l in m_lines:
+    if l.strip().startswith("def "):
+     orig_def_line = l
+     break
+  wrapper = [orig_def_line, f"  {func_name}({', '.join(call_args)})"]
+  lines[s_idx:e_idx] = wrapper
+ extracted.reverse()
+ final = "\n".join(lines) + "\n\n" + "\n\n".join(extracted) + "\n"
+ with open(file_path, "w", encoding="utf-8") as f:
+  f.write(final)
+ print(f"Successfully transformed {file_path}")
+
+if __name__ == "__main__":
+ transform()
diff --git a/scripts/gut_oop_final.py b/scripts/gut_oop_final.py
new file mode 100644
index 00000000..c3a3450e
--- /dev/null
+++ b/scripts/gut_oop_final.py
@@ -0,0 +1,48 @@
+from __future__ import annotations
+import ast
+import sys
+import re
+
+def gut_file(file_path: str) -> None:
+ """Removes delegation wrappers and fixes all calls in the file."""
+ with open(file_path, "r", encoding="utf-8") as f:
+  lines = f.read().splitlines()
+ content = "\n".join(lines)
+ tree = ast.parse(content)
+ app_class = next((n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == "App"), None)
+ if not app_class: return
+ 
+ # 1. Identify all _render_xxx methods that have module-level counterparts
+ render_methods = [
+  m for m in app_class.body
+  if isinstance(m, ast.FunctionDef) and m.name.startswith("_render_") and m.name != "_render_window_if_open"
+ ]
+ render_names = {m.name for m in render_methods}
+ 
+ # Process methods in reverse to keep line numbers valid
+ render_methods.sort(key=lambda x: x.lineno, reverse=True)
+ 
+ for m in render_methods:
+  s_idx = m.lineno - 1
+  e_idx = m.end_lineno
+  if m.decorator_list: s_idx = m.decorator_list[0].lineno - 1
+  del lines[s_idx:e_idx]
+
+ # 2. Fix all calls in the remaining lines
+ for i in range(len(lines)):
+  for m_name in render_names:
+   t_func = m_name.lstrip("_")
+   # Replace self._render_xxx( with render_xxx(self,
+   lines[i] = lines[i].replace(f"self.{m_name}(", f"{t_func}(self, ")
+   lines[i] = lines[i].replace(f"app.{m_name}(", f"{t_func}(app, ")
+   # Clean up (self, ) or (app, )
+   lines[i] = lines[i].replace("(self, )", "(self)")
+   lines[i] = lines[i].replace("(app, )", "(app)")
+
+ final_content = "\n".join(lines) + "\n"
+ with open(file_path, "w", encoding="utf-8") as f:
+  f.write(final_content)
+ print(f"Successfully GUTTED {file_path}")
+
+if __name__ == "__main__":
+ gut_file(sys.argv[1])
diff --git a/scripts/transform_render_methods.py b/scripts/transform_render_methods.py
index dcb8ee7f..6d15c51f 100644
--- a/scripts/transform_render_methods.py
+++ b/scripts/transform_render_methods.py
@@ -1,193 +1,92 @@
-#!/usr/bin/env python3
-"""
-AST-based transformer to extract App._render_xxx methods into module-level functions.
-
-Transformation:
- class App:
-  def _render_xxx(self, ...) -> ReturnType:
-   self.foo = bar
-   self.baz.qux()
-
- Becomes:
-
- def render_xxx(app: App, ...) -> ReturnType:
-  app.foo = bar
-  app.baz.qux()
-
- class App:
-  def _render_xxx(self, ...) -> ReturnType:
-   render_xxx(self, ...)
-"""
-
+from __future__ import annotations
 import ast
 import sys
-import argparse
-from pathlib import Path
-from typing import Optional
+import os
+import re
 
+def transform_file(file_path: str) -> None:
+ """
+  Refactors App._render_xxx methods to module-level functions for hot-reloading.
+  Now correctly renames 'self' to 'app' inside function bodies.
+ """
+ with open(file_path, "r", encoding="utf-8") as f:
+  content = f.read()
+ tree = ast.parse(content)
 
-class RenderMethodTransformer(ast.NodeTransformer):
- def __init__(self, class_name: str = "App", method_prefix: str = "_render"):
-  self.class_name = class_name
-  self.method_prefix = method_prefix
-  self.transformed_methods: list[str] = []
-  self.in_target_class = False
-  self.current_method: Optional[str] = None
-
- def visit_ClassDef(self, node: ast.ClassDef) -> ast.ClassDef:
-  if node.name == self.class_name:
-   self.in_target_class = True
-   self.current_method = None
-   node = self.generic_visit(node)
-   self.in_target_class = False
-   return node
-  return node
-
- def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
-  if not self.in_target_class:
+ class VariableRenamer(ast.NodeTransformer):
+  def visit_Name(self, node: ast.Name) -> ast.Name:
+   if node.id == "self":
+    node.id = "app"
    return node
 
-  if not node.name.startswith(self.method_prefix):
+ class RenderTransformer(ast.NodeTransformer):
+  def __init__(self):
+   self.new_functions = []
+  def visit_ClassDef(self, node: ast.ClassDef) -> ast.ClassDef:
+   if node.name != "App": return node
+   new_body = []
+   for item in node.body:
+    if isinstance(item, ast.FunctionDef) and item.name.startswith("_render_") and item.name != "_render_window_if_open":
+     func_name = item.name.lstrip("_")
+     # Transform body: rename 'self' to 'app'
+     renamer = VariableRenamer()
+     new_body_nodes = [renamer.visit(b) for b in item.body]
+     
+     new_func = ast.FunctionDef(
+      name=func_name,
+      args=item.args,
+      body=new_body_nodes,
+      decorator_list=item.decorator_list,
+      returns=item.returns
+     )
+     if new_func.args.args and new_func.args.args[0].arg == "self":
+      new_func.args.args[0].arg = "app"
+     self.new_functions.append(new_func)
+     
+     # Create delegation wrapper in class
+     wrapper_body = [
+      ast.Expr(
+       value=ast.Call(
+        func=ast.Name(id=func_name, ctx=ast.Load()),
+        args=[ast.Name(id="self", ctx=ast.Load())] + [ast.Name(id=a.arg, ctx=ast.Load()) for a in item.args.args[1:]],
+        keywords=[ast.keyword(arg=kw.arg, value=ast.Name(id=kw.arg, ctx=ast.Load())) for kw in item.args.kwonlyargs]
+       )
+      )
+     ]
+     item.body = wrapper_body
+     new_body.append(item)
+    else:
+     new_body.append(item)
+   node.body = new_body
    return node
 
-  if node.name == "__init__" or node.name.startswith("__"):
-   return node
-
-  self.current_method = node.name
-  new_name = node.name[1:]  # Remove underscore prefix: _render_xxx -> render_xxx
-
-  self.transformed_methods.append(node.name)
-
-  new_func = ast.FunctionDef(
-   name=new_name,
-   args=ast.arguments(
-    posonlyargs=[],
-    args=[ast.arg(arg="app", annotation=ast.Name(id=self.class_name, ctx=ast.Load()))] + node.args.args,
-    kwonlyargs=node.args.kwonlyargs,
-    kw_defaults=node.args.kw_defaults,
-    defaults=node.args.defaults,
-   ),
-   body=[self._transform_body(body_item) for body_item in node.body],
-   decorator_list=node.decorator_list,
-   returns=node.returns,
-   type_comment=node.type_comment,
-  )
-
-  delegation_method = ast.FunctionDef(
-   name=node.name,
-   args=node.args,
-   body=[ast.Expr(value=ast.Call(
-    func=ast.Name(id=new_name, ctx=ast.Load()),
-    args=[ast.Name(id="self", ctx=ast.Load())] + [self._arg_to_expr(arg) for arg in node.args.args],
-    keywords=[ast.keyword(arg=arg.arg, value=ast.Name(id=arg.arg, ctx=ast.Load())) for arg in node.args.kwonlyargs]
-   ))],
-   decorator_list=node.decorator_list,
-   returns=node.returns,
-   type_comment=node.type_comment,
-  )
-
-  return ast.Module(body=[new_func, delegation_method], type_ignores=[])
-
- def _arg_to_expr(self, arg: ast.arg) -> ast.expr:
-  return ast.Name(id=arg.arg, ctx=ast.Load())
-
- def _transform_body(self, node: ast.AST) -> ast.AST:
-  return ast.NodeTransformer.generic_visit(self, node)
-
- def visit_Name(self, node: ast.Name) -> ast.Name:
-  if isinstance(node.ctx, ast.Load) and node.id == "self":
-   return ast.Name(id="app", ctx=node.ctx)
-  return node
-
- def visit_Attribute(self, node: ast.Attribute) -> ast.Attribute:
-  if isinstance(node.value, ast.Name) and node.value.id == "self":
-   new_value = ast.Name(id="app", ctx=node.value.ctx)
-   return ast.Attribute(value=new_value, attr=node.attr, ctx=node.ctx)
-  return self.generic_visit(node)
-
-
-class AppRenderExtractor(ast.NodeVisitor):
- def __init__(self, class_name: str = "App", method_prefix: str = "_render"):
-  self.class_name = class_name
-  self.method_prefix = method_prefix
-  self.in_target_class = False
-  self.methods: dict[str, dict] = {}
-
- def visit_ClassDef(self, node: ast.ClassDef) -> None:
-  if node.name == self.class_name:
-   self.in_target_class = True
-   self.generic_visit(node)
-   self.in_target_class = False
-
- def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
-  if not self.in_target_class:
-   return
-
-  if not node.name.startswith(self.method_prefix):
-   return
-
-  if node.name == "__init__" or node.name.startswith("__"):
-   return
-
-  args = [arg.arg for arg in node.args.args]
-  self.methods[node.name] = {
-   "line": node.lineno,
-   "end_line": node.end_lineno,
-   "args": args,
-   "has_return": any(isinstance(n, ast.Return) for n in ast.walk(node)),
-  }
-
-
-def extract_render_methods(source_path: str, class_name: str = "App", method_prefix: str = "_render") -> dict:
- with open(source_path, "r", encoding="utf-8") as f:
-  source = f.read()
-
- tree = ast.parse(source)
- extractor = AppRenderExtractor(class_name, method_prefix)
- extractor.visit(tree)
-
- return extractor.methods
-
-
-def transform_file(source_path: str, output_path: Optional[str] = None, class_name: str = "App", method_prefix: str = "_render") -> list[str]:
- with open(source_path, "r", encoding="utf-8") as f:
-  source = f.read()
-
- tree = ast.parse(source)
-
- transformer = RenderMethodTransformer(class_name, method_prefix)
+ transformer = RenderTransformer()
  new_tree = transformer.visit(tree)
+ for func in transformer.new_functions:
+  new_tree.body.append(func)
+ ast.fix_missing_locations(new_tree)
 
- result = ast.unparse(new_tree)
-
- if output_path:
-  with open(output_path, "w", encoding="utf-8", newline="") as f:
-   f.write(result)
+ if hasattr(ast, "unparse"):
+  raw_output = ast.unparse(new_tree)
+  lines = raw_output.splitlines()
+  new_lines = []
+  for line in lines:
+   match = re.match(r"^( +)(.*)", line)
+   if match:
+    spaces, rest = match.groups()
+    new_indent = " " * (len(spaces) // 4)
+    new_lines.append(new_indent + rest)
+   else:
+    new_lines.append(line)
+  final_content = "\n".join(new_lines)
+  with open(file_path, "w", encoding="utf-8") as f:
+   f.write(final_content)
+  print(f"Successfully transformed {file_path} with 1-space indentation and 'self'->'app' migration.")
  else:
-  print(result)
-
- return transformer.transformed_methods
-
-
-def main():
- parser = argparse.ArgumentParser(description="Transform App._render_xxx methods to module-level functions")
- parser.add_argument("source", help="Source Python file to transform")
- parser.add_argument("-o", "--output", help="Output file (default: stdout)")
- parser.add_argument("-c", "--cls", default="App", help="Class name to transform (default: App)")
- parser.add_argument("-p", "--prefix", default="_render", help="Method prefix to extract (default: _render)")
- parser.add_argument("--extract-only", action="store_true", help="Only extract method info, don't transform")
-
- args = parser.parse_args()
-
- if args.extract_only:
-  methods = extract_render_methods(args.source, args.cls, args.prefix)
-  print(f"Found {len(methods)} methods:")
-  for name, info in sorted(methods.items(), key=lambda x: x[1]["line"]):
-   print(f"  {name}: lines {info['line']}-{info['end_line']}, args={info['args']}")
- else:
-  transformed = transform_file(args.source, args.output, args.cls, args.prefix)
-  print(f"Transformed {len(transformed)} methods: {transformed}")
-
+  print("ast.unparse not available.")
 
 if __name__ == "__main__":
- main()
\ No newline at end of file
+ if len(sys.argv) < 2:
+  print("Usage: python scripts/transform_render_methods.py <file_path>")
+ else:
+  transform_file(sys.argv[1])
diff --git a/scripts/transform_render_methods_safe.py b/scripts/transform_render_methods_safe.py
index dc7d924e..950930e2 100644
--- a/scripts/transform_render_methods_safe.py
+++ b/scripts/transform_render_methods_safe.py
@@ -4,18 +4,20 @@ import sys
 import re
 
 def transform_file(file_path: str) -> None:
- """Refactors App._render_xxx methods to module-level functions."""
  with open(file_path, "r", encoding="utf-8") as f:
   lines = f.read().splitlines()
- tree = ast.parse("\n".join(lines))
+ content = "\n".join(lines)
+ tree = ast.parse(content)
  app_class = next((n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == "App"), None)
  if not app_class: return
+ 
  render_methods = [
   m for m in app_class.body
   if isinstance(m, ast.FunctionDef) and m.name.startswith("_render_") and m.name != "_render_window_if_open"
  ]
  render_names = {m.name for m in render_methods}
  render_methods.sort(key=lambda x: x.lineno, reverse=True)
+ 
  extracted = []
  for m in render_methods:
   s_idx = m.lineno - 1
@@ -23,41 +25,41 @@ def transform_file(file_path: str) -> None:
   if m.decorator_list: s_idx = m.decorator_list[0].lineno - 1
   m_lines = lines[s_idx:e_idx]
   func_name = m.name.lstrip("_")
-  processed = []
-  for l in m_lines:
-   processed.append(l[1:] if l.startswith(" ") else l)
+  
+  # 1. Out-dent
+  processed = [l[1:] if l.startswith(" ") else l for l in m_lines]
   def_line_idx = next((i for i, l in enumerate(processed) if l.strip().startswith("def ")), -1)
   if def_line_idx != -1:
    l = processed[def_line_idx]
    l = l.replace(f"def {m.name}(", f"def {func_name}(", 1)
    l = re.sub(r"\bself\b", "app: App", l, count=1)
    processed[def_line_idx] = l
+  
+  # 2. Redirect internal calls in this function's body
   for i in range(def_line_idx + 1, len(processed)):
    for m_name in render_names:
     t_func = m_name.lstrip("_")
-    # Replace self._render_xxx( with render_xxx(app, 
-    # then fix up (app, ) if it was empty.
     processed[i] = processed[i].replace(f"self.{m_name}(", f"{t_func}(app, ")
-    processed[i] = processed[i].replace(f"(app, )", "(app)")
+    processed[i] = processed[i].replace("(app, )", "(app)")
    processed[i] = re.sub(r"(?<![a-zA-Z0-9_])self\.", "app.", processed[i])
    processed[i] = re.sub(r"(?<![a-zA-Z0-9_])self(?![a-zA-Z0-9_:])", "app", processed[i])
+  
   extracted.append("\n".join(processed))
-  arg_names = [a.arg for a in m.args.args if a.arg != "self"]
-  kw_names = [a.arg for a in m.args.kwonlyargs]
-  call_args = ["self"] + arg_names + [f"{k}={k}" for k in kw_names]
-  orig_def_line = m_lines[0]
-  if m.decorator_list:
-   for l in m_lines:
-    if l.strip().startswith("def "):
-     orig_def_line = l
-     break
-  wrapper = [orig_def_line, f"  {func_name}({', '.join(call_args)})"]
-  lines[s_idx:e_idx] = wrapper
+  # REMOVE from class
+  del lines[s_idx:e_idx]
+
+ # 3. Redirect calls in remaining class methods
+ for i in range(len(lines)):
+  for m_name in render_names:
+   t_func = m_name.lstrip("_")
+   lines[i] = lines[i].replace(f"self.{m_name}(", f"{t_func}(self, ")
+   lines[i] = lines[i].replace("(self, )", "(self)")
+
  extracted.reverse()
- final = "\n".join(lines) + "\n\n" + "\n\n".join(extracted) + "\n"
+ final_content = "\n".join(lines) + "\n\n" + "\n\n".join(extracted) + "\n"
  with open(file_path, "w", encoding="utf-8") as f:
-  f.write(final)
- print(f"Transformed {file_path}")
+  f.write(final_content)
+ print(f"Successfully GUTTED {file_path}")
 
 if __name__ == "__main__":
- if len(sys.argv) > 1: transform_file(sys.argv[1])
+ transform_file(sys.argv[1])
diff --git a/src/gui_2.py b/src/gui_2.py
index 3ce74f90..97d4c4a6 100644
--- a/src/gui_2.py
+++ b/src/gui_2.py
@@ -630,30 +630,20 @@ class App:
    f.write(data)
    # ---------------------------------------------------------------- helpers
 
- def _render_text_viewer(self, label: str, content: str, text_type: str = 'text', force_open: bool = False) -> None:
-  render_text_viewer(self, label, content, text_type, force_open)
 
- def _render_heavy_text(self, label: str, content: str, id_suffix: str = "") -> None:
-  render_heavy_text(self, label, content, id_suffix)
     # ---------------------------------------------------------------- gui
 
- def _render_thinking_trace(self, segments: list[dict], entry_index: int, is_standalone: bool = False) -> None:
-  render_thinking_trace(self, segments, entry_index, is_standalone)
 
- def _render_selectable_label(self, label: str, value: str, width: float = 0.0, multiline: bool = False, height: float = 0.0, color: Optional[imgui.ImVec4] = None) -> None:
-  render_selectable_label(self, label, value, width, multiline, height, color)
 
- def _render_save_preset_modal(self) -> None:
-  render_save_preset_modal(self)
 
  def _gui_func(self) -> None:
   io = imgui.get_io()
   if io.key_ctrl and io.key_alt and io.keys_down[ord('R')]:
    self._trigger_hot_reload()
 
-  self._render_custom_title_bar()
-  self._render_shader_live_editor()
-  self._render_history_window()
+  render_custom_title_bar(self)
+  render_shader_live_editor(self)
+  render_history_window(self)
   pushed_prior_tint = False
   
   # Render background shader
@@ -670,7 +660,7 @@ class App:
    pushed_prior_tint = True
   
   try:
-   self._render_main_interface()
+   render_main_interface(self)
   except Exception as e:
    sys.stderr.write(f"ERROR in _gui_func: {e}\n")
    traceback.print_exc()
@@ -683,8 +673,6 @@ class App:
   if self.perf_profiling_enabled: self.perf_monitor.end_component("_gui_func")
   return
 
- def _render_main_interface(self) -> None:
-  render_main_interface(self)
 
  def _render_window_if_open(self, name: str, render_func: Callable[[], None], flag_condition: bool = True) -> None:
   """Helper to render a window only if its toggle is active."""
@@ -693,8 +681,6 @@ class App:
    self.show_windows[name] = bool(opened)
    if exp: render_func()
 
- def _render_custom_title_bar(self) -> None:
-  render_custom_title_bar(self)
 
  def _show_menus(self) -> None:
   """
@@ -799,8 +785,6 @@ class App:
     imgui.pop_style_color()
     imgui.pop_style_color()
 
- def _render_history_window(self) -> None:
-  render_history_window(self)
 
  def _handle_history_logic(self) -> None:
   """
@@ -861,38 +845,20 @@ class App:
    traceback.print_exc(file=sys.stderr)
    sys.stderr.flush()
  
- def _render_theme_panel(self) -> None:
-  render_theme_panel(self)
 
- def _render_shader_live_editor(self) -> None:
-  render_shader_live_editor(self)
 
 #region: Diangostics & Analytics
 
- def _render_usage_analytics_panel(self) -> None:
-  render_usage_analytics_panel(self)
 
- def _render_cache_panel(self) -> None:
-  render_cache_panel(self)
 
- def _render_diagnostics_panel(self) -> None:
-  render_diagnostics_panel(self)
  
- def _render_tool_analytics_panel(self) -> None:
-  render_tool_analytics_panel(self)
 
- def _render_token_budget_panel(self) -> None:
-  render_token_budget_panel(self)
  
- def _render_session_insights_panel(self) -> None:
-  render_session_insights_panel(self)
 
 #endregion: Diangostics & Analytics
 
 #region: Logging
 
- def _render_log_management(self) -> None:
-  render_log_management(self)
 
  def cb_load_prior_log(self, path: Optional[str] = None) -> None:
   if path is None:
@@ -906,20 +872,10 @@ class App:
 
 #region: Project Management
 
- def _render_project_settings_hub(self) -> None:
-  render_project_settings_hub(self)
 
- def _render_projects_panel(self) -> None:
-  render_projects_panel(self)
 
- def _render_paths_panel(self) -> None:
-  render_paths_panel(self)
 
- def _render_path_field(label: str, attr: str, key: str, tooltip: str):
-  render_path_field(self, label, attr, key, tooltip)
 
- def _render_external_tools_panel(self) -> None:
-  render_external_tools_panel(self)
 
  def _set_external_editor_default(self, editor_name: str) -> None:
   from src import models
@@ -960,66 +916,28 @@ class App:
 
 #region: AI Settings
 
- def _render_ai_settings_hub(self) -> None:
-  render_ai_settings_hub(self)
 
- def _render_rag_panel(self) -> None:
-  render_rag_panel(self)
 
- def _render_system_prompts_panel(self) -> None:
-  render_system_prompts_panel(self)
 
- def _render_agent_tools_panel(self) -> None:
-  render_agent_tools_panel(self)
 
- def _render_preset_manager_content(self, is_embedded: bool = False) -> None:
-  render_preset_manager_content(self, is_embedded)
 
- def _render_preset_manager_window(self, is_embedded: bool = False) -> None:
-  render_preset_manager_window(self, is_embedded)
 
- def _render_tool_preset_manager_content(self, is_embedded: bool = False) -> None:
-  render_tool_preset_manager_content(self, is_embedded)
  
- def _render_tool_preset_manager_window(self, is_embedded: bool = False) -> None:
-  render_tool_preset_manager_window(self, is_embedded)
 
- def _render_persona_editor_window(self, is_embedded: bool = False) -> None:
-  render_persona_editor_window(self, is_embedded)
 
- def _render_provider_panel(self) -> None:
-  render_provider_panel(self)
 
- def _render_persona_selector_panel(self) -> None:
-  render_persona_selector_panel(self)
 
 #endregion: AI Settings
 
 #region: Context Management
 
- def _render_files_and_media(self) -> None:
-  render_files_and_media(self)
 
- def _render_files_panel(self, height_override: float = 0) -> None:
-  render_files_panel(self, height_override)
 
- def _render_screenshots_panel(self, height_override: float = 0) -> None:
-  render_screenshots_panel(self, height_override)
 
- def _render_context_composition_panel(self) -> None:
-  render_context_composition_panel(self)
 
- def _render_ast_inspector_modal(self) -> None:
-  render_ast_inspector_modal(self)
 
- def _render_add_context_files_modal(self) -> None:
-  render_add_context_files_modal(self)
 
- def _render_save_workspace_profile_modal(self) -> None:
-  render_save_workspace_profile_modal(self)
 
- def _render_context_presets_panel(self) -> None:
-  render_context_presets_panel(self)
 
  def _populate_auto_slices(self, f_item: models.FileItem) -> None:
   """
@@ -1055,17 +973,9 @@ class App:
    slice_data['comment'] = name
    f_item.custom_slices.append(slice_data)
 
- def _render_context_screenshots(self) -> None:
-  render_context_screenshots(self)
 
- def _render_context_batch_actions(self, total_lines: int, total_ast: int) -> None:
-  render_context_batch_actions(self, total_lines, total_ast)
 
- def _render_context_files_table(self) -> None:
-  render_context_files_table(self)
 
- def _render_context_presets(self) -> None:
-  render_context_presets(self)
 
  def _update_context_file_stats(self) -> tuple[int, int]:
   if not hasattr(self, '_file_stats_cache'):         self._file_stats_cache = {}
@@ -1101,79 +1011,35 @@ class App:
 
 #region: Discussions
 
- def _render_discussion_hub(self) -> None:
-  render_discussion_hub(self)
 
- def _render_discussion_entries(self) -> None:
-  render_discussion_entries(self)
 
- def _render_discussion_entry(self, entry: dict, index: int) -> None:
-  render_discussion_entry(self, entry, index)
 
- def _render_discussion_entry_controls(self) -> None:
-  render_discussion_entry_controls(self)
 
- def _render_discussion_entry_read_mode(self, entry: dict, index: int) -> None:
-  render_discussion_entry_read_mode(self, entry, index)
 
- def _render_discussion_metadata(self) -> None:
-  render_discussion_metadata(self)
 
- def _render_discussion_panel(self) -> None:
-  render_discussion_panel(self)
 
- def _render_discussion_roles(self) -> None:
-  render_discussion_roles(self)
 
- def _render_discussion_selector(self) -> None:
-  render_discussion_selector(self)
 
- def _render_discussion_tab(self) -> None:
-  render_discussion_tab(self)
 
- def _render_takes_panel(self) -> None:
-  render_takes_panel(self)
 
- def _render_prior_session_view(self) -> None:
-  render_prior_session_view(self)
 
- def _render_thinking_indicator(self) -> None:
-  render_thinking_indicator(self)
 
- def _render_message_panel(self) -> None:
-  render_message_panel(self)
 
- def _render_synthesis_panel(self) -> None:
-  render_synthesis_panel(self)
 
- def _render_snapshot_tab(self) -> None:
-  render_snapshot_tab(self)
 
- def _render_response_panel(self) -> None:
-  render_response_panel(self)
 
 #endregion: Discussions
 
 #region: Operations Monitor
 
- def _render_operations_hub(self) -> None:
-  render_operations_hub(self)
 
- def _render_tool_calls_panel(self) -> None:
-  render_tool_calls_panel(self)
 
- def _render_comms_history_panel(self) -> None:
-  render_comms_history_panel(self)
 
 #endregion: Operations Monitor
 
 #region: Misc Tools
 
- def _render_text_viewer_window(self) -> None:
-  render_text_viewer_window(self)
 
- def _render_base_prompt_diff_modal(self) -> None:
-  render_base_prompt_diff_modal(self)
 
  def _close_vscode_diff(self) -> None:
   if hasattr(self, '_vscode_diff_process') and self._vscode_diff_process:
@@ -1183,8 +1049,6 @@ class App:
     pass
    self._vscode_diff_process = None
 
- def _render_patch_modal(self) -> None:
-  render_patch_modal(self)
 
  def _apply_pending_patch(self) -> None:
   if not self._pending_patch_text:
@@ -1230,18 +1094,12 @@ class App:
   except Exception as e:
    self._patch_error_message = str(e)
 
- def _render_external_editor_panel(self) -> None:
-  render_external_editor_panel(self)
 
- def _render_approve_script_modal(self) -> None:
-  render_approve_script_modal(self)
 
 #endregion: Misc Tools
 
 #region: Sanity Tests
 
- def _render_markdown_test(self) -> None:
-  render_markdown_test(self)
 
 #endregion: Sanity Tests
 
@@ -1269,53 +1127,21 @@ class App:
    self.active_tickets = new_tickets
    self._push_mma_state_update()
 
- def _render_ticket_queue(self) -> None:
-  render_ticket_queue(self)
 
- def _render_task_dag_panel(self) -> None:  # 4. Task DAG Visualizer
-  render_task_dag_panel(self)
 
- def _render_beads_tab(self) -> None:
-  render_beads_tab(self)
 
- def _render_mma_dashboard(self) -> None:
-  render_mma_dashboard(self)
 
- def _render_mma_focus_selector(self) -> None:
-  render_mma_focus_selector(self)
 
- def _render_mma_modals(self) -> None:
-  render_mma_modals(self)
 
- def _render_mma_track_summary(self) -> None:
-  render_mma_track_summary(self)
 
- def _render_mma_epic_planner(self) -> None:
-  render_mma_epic_planner(self)
 
- def _render_mma_conductor_setup(self) -> None:
-  render_mma_conductor_setup(self)
 
- def _render_mma_track_browser(self) -> None:
-  render_mma_track_browser(self)
 
- def _render_mma_global_controls(self) -> None:
-  render_mma_global_controls(self)
 
- def _render_mma_usage_section(self) -> None:
-  render_mma_usage_section(self)
 
- def _render_mma_ticket_editor(self) -> None:
-  render_mma_ticket_editor(self)
 
- def _render_mma_agent_streams(self) -> None:
-  render_mma_agent_streams(self)
 
- def _render_tier_stream_panel(self, tier_key: str, stream_key: str | None) -> None:
-  render_tier_stream_panel(self, tier_key, stream_key)
 
- def _render_track_proposal_modal(self) -> None:
-  render_track_proposal_modal(self)
 
  def request_patch_from_tier4(self, error: str, file_context: str) -> None:
   try: