Fix custom_script execution + add templates for expression/function kinds

- custom_script now uses exec-style (assign to `result`) matching the
  built-in templates — previously auto-wrapped in def compute() which
  had no return statement, causing state and channel vars to silently fail
- function kind unchanged: auto-wraps body as def compute(x,t); use return
- Add SCRIPT_TEMPLATES for expression, function, custom_script kinds;
  shown automatically when user switches to a script kind (replacing stale
  code from previous kind)
- New channels default to template when no saved code exists

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

2 files changed, 48 insertions, 14 deletions

diff --git a/ui/code_templates.py b/ui/code_templates.py
index 0863e62..32332e9 100644
--- a/ui/code_templates.py
+++ b/ui/code_templates.py
@@ -1,18 +1,24 @@
 """
 ui/code_templates.py
 
-Python code templates for built-in derived channel kinds.
-Shown as read-only previews in the UI; clicking "Edit as Custom Script"
-converts the channel to custom_script kind with the template pre-filled.
+Code templates for derived channel kinds.
 
-Templates use the enhanced expression namespace:
-  x      — list of source values in order
-  <name> — each source's channel_id as a named variable
+BUILTIN_TEMPLATES — shown as read-only previews for built-in kinds.
+  "Edit as Custom Script" copies the template into custom_script.
+  Uses exec-style: assign to `result`.
+
+SCRIPT_TEMPLATES — default starter code shown when user picks a script kind.
+  expression  → single Python expression (no assignment)
+  function    → auto-wrapped as def compute(x, t): ... use return
+  custom_script → exec-style block, assign to `result`
+
+Namespace available in all kinds:
+  x      — list of source values in source order
+  <name> — each source's channel_id as a named variable (same as x[i])
   t      — elapsed time (seconds)
   math   — Python math module
   vars   — shared SignalProcessor._script_vars dict (read/write)
   state  — per-channel persistent dict (survives between evaluations)
-  result — assign the computed value here (expression-style exec)
 """
 
 BUILTIN_TEMPLATES: dict = {
@@ -68,3 +74,26 @@ result = x[0] - x[1]
 result = sum(x)
 """,
 }
+
+
+# Default starter code shown when user selects a script kind
+SCRIPT_TEMPLATES: dict = {
+
+    "expression": "x[0]",
+
+    "function": """\
+# Function body — use 'return' to output the value.
+# Named source vars, t, math, vars, state all available.
+offset = vars.get("offset", 0)
+return x[0] - offset
+""",
+
+    "custom_script": """\
+# Assign computed value to 'result'.
+# Named source vars, t, math, vars, state all available.
+
+# Example: running zero-offset
+zero = vars.get("zero", 0)
+result = x[0] - zero
+""",
+}
diff --git a/ui/windows/channels_window.py b/ui/windows/channels_window.py
index 266432b..597b0b2 100644
--- a/ui/windows/channels_window.py
+++ b/ui/windows/channels_window.py
@@ -618,8 +618,8 @@ _KIND_HELP = {
         "Example:\n    offset = vars.get('zero', 0)\n    return x[0] - offset"
     ),
     "custom_script": (
-        "Full Python.  Must define:  def compute(x, t): ...\n"
-        "Available globals: x, signal names, t, math, vars, state"
+        "Multi-line Python block.  Assign computed value to result.\n"
+        "Available: x, signal names, t, math, vars, state"
     ),
 }
 
@@ -758,9 +758,11 @@ class DerivedBlock(QFrame):
             from ui.code_templates import BUILTIN_TEMPLATES
             txt = BUILTIN_TEMPLATES.get(self.dc.kind, "")
         elif self.dc.kind == "expression":
-            txt = self.dc.expression
+            from ui.code_templates import SCRIPT_TEMPLATES
+            txt = self.dc.expression or SCRIPT_TEMPLATES.get("expression", "")
         else:
-            txt = self.dc.script
+            from ui.code_templates import SCRIPT_TEMPLATES
+            txt = self.dc.script or SCRIPT_TEMPLATES.get(self.dc.kind, "")
         self._code.setPlainText(txt)
         code_lay.addWidget(self._code)
         # "Edit as Custom Script" button — only visible for built-in kinds
@@ -875,16 +877,19 @@ class DerivedBlock(QFrame):
         # expression kind: label-only, no code injection (single-line expr)
 
     def _on_kind(self, idx: int):
-        from ui.code_templates import BUILTIN_TEMPLATES
+        from ui.code_templates import BUILTIN_TEMPLATES, SCRIPT_TEMPLATES
         k = _ALL_KINDS[idx]
         self.dc.kind = k
         self._help.setText(_KIND_HELP.get(k, ""))
         if k in ("derivative", "second_derivative") and not self._src_combos:
             self._add_src()
         if k in _BUILTIN:
-            # Reset to bare template first; _update_vars_hint will prepend comment
+            # Reset to bare template; _update_vars_hint will prepend variable comment
             self._code.setPlainText(BUILTIN_TEMPLATES.get(k, ""))
-        self._update_vars_hint()  # also injects variable comment into code
+        elif k in _SCRIPT:
+            # Show starter template for script kinds (always replace on kind switch)
+            self._code.setPlainText(SCRIPT_TEMPLATES.get(k, ""))
+        self._update_vars_hint()
         self._update_visibility()
 
     def _on_wrt_changed(self, idx: int):