rushti 2.2.3__tar.gz → 2.3.0__tar.gz

{rushti-2.2.3/src/rushti.egg-info → rushti-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rushti
-Version: 2.2.3
+Version: 2.3.0
 Summary: RushTI - Parallel TM1 TurboIntegrator Process Execution
 Author-email: nicolasbisurgi <nbisurgi@cubewise.com>, Marius Wirtz <mwirtz@cubewise.com>
 Maintainer: Cubewise CODE

{rushti-2.2.3 → rushti-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rushti"
-version = "2.2.3"
+version = "2.3.0"
 description = "RushTI - Parallel TM1 TurboIntegrator Process Execution"
 readme = "README.md"
 license = "MIT"

{rushti-2.2.3 → rushti-2.3.0}/src/rushti/__init__.py

@@ -5,7 +5,7 @@ This package provides tools for executing TM1 TI processes in parallel
 with dependency management, checkpoint/resume support, and execution logging.
 """
 
-__version__ = "2.2.3"
+__version__ = "2.3.0"
 __app_name__ = "RushTI"
 
 # Core exports for programmatic use

{rushti-2.2.3 → rushti-2.3.0}/src/rushti/cli.py

@@ -249,11 +249,14 @@ Examples:
   %(prog)s -t tasks.txt -w 4 -r 2 -o results.csv
   %(prog)s --tasks tasks.json --max-workers 8 --retries 3
   %(prog)s --tm1-instance tm1srv01 --workflow Sample --max-workers 4
+  %(prog)s --tm1-instance tm1srv01 --workflow Sample_Optimal_Mode --mode opt
 
 Configuration:
   Default values can be set in settings.ini (see settings.ini.template).
   Settings precedence: CLI args > JSON task file > settings.ini > defaults
-  File format is auto-detected (--mode is deprecated for file sources).
+  File sources auto-detect the mode (--mode is ignored). Cube reads
+  (--tm1-instance) cannot, and default to norm; pass --mode opt to honour
+  the 'predecessors' measure.
         """,
     )
 
@@ -286,7 +289,7 @@ Configuration:
         dest="execution_mode",
         choices=["norm", "opt"],
         default=None,
-        help="[Deprecated] Execution mode is now auto-detected from file content. This option is kept for backwards compatibility but ignored.",
+        help="Execution mode: norm or opt. Auto-detected (and ignored) for file sources. For cube reads (--tm1-instance) it defaults to norm; pass 'opt' to honour the 'predecessors' measure.",
     )
 
     parser.add_argument(

{rushti-2.2.3 → rushti-2.3.0}/src/rushti/dashboard.py

@@ -234,16 +234,26 @@ def _prepare_dashboard_data(
             }
         )
 
-    # Build per-task aggregate data (across all runs)
+    # Build per-task aggregate data (across all runs). Each row carries
+    # both ``process`` (may be empty for chore rows) and ``chore`` so the
+    # dashboard can render a unified "Task target" column with a kind
+    # indicator. ``task_target``/``task_kind`` are the canonical fields
+    # for display; the raw kind fields stay populated for backward
+    # compatibility with downstream consumers.
     task_data: Dict[str, Dict[str, Any]] = {}
     for tr in task_results:
         sig = tr["task_signature"]
+        process_val = tr.get("process") or ""
+        chore_val = tr.get("chore") or ""
         if sig not in task_data:
             task_data[sig] = {
                 "task_signature": sig,
                 "task_id": tr["task_id"],
                 "instance": tr["instance"],
-                "process": tr["process"],
+                "process": process_val,
+                "chore": chore_val,
+                "task_target": chore_val or process_val,
+                "task_kind": "chore" if chore_val else "process",
                 "durations": [],
                 "successes": 0,
                 "total": 0,
@@ -263,6 +273,9 @@ def _prepare_dashboard_data(
                 "task_id": data["task_id"],
                 "instance": data["instance"],
                 "process": data["process"],
+                "chore": data["chore"],
+                "task_target": data["task_target"],
+                "task_kind": data["task_kind"],
                 "executions": data["total"],
                 "success_rate": (
                     round(data["successes"] / data["total"] * 100, 1) if data["total"] > 0 else 0
@@ -290,10 +303,15 @@ def _prepare_dashboard_data(
     outliers = []
     for tr in task_results:
         if tr["duration_seconds"] is not None:
+            process_val = tr.get("process") or ""
+            chore_val = tr.get("chore") or ""
             outliers.append(
                 {
                     "task_id": tr["task_id"],
-                    "process": tr["process"],
+                    "process": process_val,
+                    "chore": chore_val,
+                    "task_target": chore_val or process_val,
+                    "task_kind": "chore" if chore_val else "process",
                     "instance": tr["instance"],
                     "run_id": tr["run_id"],
                     "duration": round(tr["duration_seconds"], 2),
@@ -308,10 +326,15 @@ def _prepare_dashboard_data(
     failures = []
     for tr in task_results:
         if tr["status"] != "Success":
+            process_val = tr.get("process") or ""
+            chore_val = tr.get("chore") or ""
             failures.append(
                 {
                     "task_id": tr["task_id"],
-                    "process": tr["process"],
+                    "process": process_val,
+                    "chore": chore_val,
+                    "task_target": chore_val or process_val,
+                    "task_kind": "chore" if chore_val else "process",
                     "instance": tr["instance"],
                     "run_id": tr["run_id"],
                     "duration": round(tr["duration_seconds"], 2) if tr["duration_seconds"] else 0,
@@ -322,13 +345,18 @@ def _prepare_dashboard_data(
     # Slim task_results for JS (only fields needed for interactive filtering)
     slim_task_results = []
     for tr in task_results:
+        process_val = tr.get("process") or ""
+        chore_val = tr.get("chore") or ""
         slim_task_results.append(
             {
                 "run_id": tr["run_id"],
                 "task_id": tr["task_id"],
                 "task_signature": tr["task_signature"],
                 "instance": tr["instance"],
-                "process": tr["process"],
+                "process": process_val,
+                "chore": chore_val,
+                "task_target": chore_val or process_val,
+                "task_kind": "chore" if chore_val else "process",
                 "status": tr["status"],
                 "duration_seconds": tr["duration_seconds"],
                 "error_message": tr.get("error_message"),
@@ -578,6 +606,11 @@ def generate_dashboard(
         .status-partial {{ color: #D97706; font-weight: 600; }}
         .high-cv {{ background: #FFF7ED; }}
         .duration-slow {{ color: #DC2626; font-weight: 600; }}
+        .kind-tag {{
+            display: inline-block; padding: 1px 5px; border-radius: 4px;
+            font-size: 0.7rem; font-weight: 700; color: #475569;
+            background: #E2E8F0; margin-right: 4px;
+        }}
 
         /* Accordion */
         .accordion {{ margin-bottom: 20px; }}
@@ -752,7 +785,7 @@ def generate_dashboard(
                 <thead><tr>
                     <th onclick="sortTaskTable(0)">Task ID <span class="sort-arrow"></span></th>
                     <th onclick="sortTaskTable(1)">Instance <span class="sort-arrow"></span></th>
-                    <th onclick="sortTaskTable(2)">Process <span class="sort-arrow"></span></th>
+                    <th onclick="sortTaskTable(2)">Task target <span class="sort-arrow"></span></th>
                     <th onclick="sortTaskTable(3)">Avg (s) <span class="sort-arrow"></span></th>
                     <th onclick="sortTaskTable(4)">Min (s) <span class="sort-arrow"></span></th>
                     <th onclick="sortTaskTable(5)">Max (s) <span class="sort-arrow"></span></th>
@@ -768,7 +801,7 @@ def generate_dashboard(
             <h3>Top 10 Slowest Executions <span class="help-icon">?<span class="help-tip">How to read: These are the 10 longest-running individual task executions across the selected runs. The "vs Median" column tells you how many times slower each one was compared to the typical task — a high multiplier (e.g., 5×) means that execution was significantly slower than usual and may be worth investigating. Check whether the same task appears multiple times — if so, it is a consistent bottleneck.</span></span></h3>
             <table id="outlierTable">
                 <thead><tr>
-                    <th>Task ID</th><th>Process</th><th>Instance</th>
+                    <th>Task ID</th><th>Task target</th><th>Instance</th>
                     <th>Run</th><th>Duration (s)</th><th>vs Median</th><th>Status</th>
                 </tr></thead>
                 <tbody id="outlierTableBody"></tbody>
@@ -779,7 +812,7 @@ def generate_dashboard(
             <h3>Failed Processes <span class="help-icon">?<span class="help-tip">How to read: Every task execution that did not succeed is listed here. Look for patterns — does the same task fail repeatedly across runs? That points to a systemic issue. If failures are scattered across different tasks, the problem may be environmental (server load, connectivity). Hover over the Error column to see the full error message for each failure.</span></span></h3>
             <table id="failureTable">
                 <thead><tr>
-                    <th>Task ID</th><th>Process</th><th>Instance</th>
+                    <th>Task ID</th><th>Task target</th><th>Instance</th>
                     <th>Run</th><th>Duration (s)</th><th>Error</th>
                 </tr></thead>
                 <tbody id="failureTableBody"></tbody>
@@ -1260,14 +1293,14 @@ def generate_dashboard(
         // Also store a lookup for tooltip labels
         const sigLabel = {{}};
         relevant.forEach(tr => {{
-            if (!sigLabel[tr.task_signature]) sigLabel[tr.task_signature] = tr.process;
+            if (!sigLabel[tr.task_signature]) sigLabel[tr.task_signature] = tr.task_target || tr.process || tr.chore;
         }});
 
         const datasets = runs.map((run, idx) => {{
             const runTasks = relevant.filter(tr => tr.run_id === run.run_id);
             return {{
                 label: formatDate(run.start_time),
-                data: runTasks.map(t => ({{ x: sigIndex[t.task_signature], y: t.duration_seconds || 0, _sig: t.task_signature, _task: t.task_id, _proc: t.process }})),
+                data: runTasks.map(t => ({{ x: sigIndex[t.task_signature], y: t.duration_seconds || 0, _sig: t.task_signature, _task: t.task_id, _proc: t.task_target || t.process || t.chore }})),
                 backgroundColor: RUN_COLORS[idx % RUN_COLORS.length] + '80',
                 borderColor: RUN_COLORS[idx % RUN_COLORS.length],
                 pointRadius: 3,
@@ -1470,7 +1503,10 @@ def generate_dashboard(
             const sig = tr.task_signature;
             if (!taskData[sig]) {{
                 taskData[sig] = {{
-                    task_id: tr.task_id, instance: tr.instance, process: tr.process,
+                    task_id: tr.task_id, instance: tr.instance,
+                    process: tr.process, chore: tr.chore,
+                    task_target: tr.task_target || tr.process || tr.chore,
+                    task_kind: tr.task_kind || (tr.chore ? 'chore' : 'process'),
                     durations: [], successes: 0, total: 0
                 }};
             }}
@@ -1492,7 +1528,7 @@ def generate_dashboard(
     }}
 
     function applyTaskSort(rows) {{
-        const fields = ['task_id', 'instance', 'process', 'avg', 'mn', 'mx', 'stdDev', 'successRate', 'total'];
+        const fields = ['task_id', 'instance', 'task_target', 'avg', 'mn', 'mx', 'stdDev', 'successRate', 'total'];
         const field = fields[taskTableSortCol];
         rows.sort((a, b) => {{
             const av = a[field], bv = b[field];
@@ -1556,10 +1592,12 @@ def generate_dashboard(
         tbody.innerHTML = pageRows.map(r => {{
             const cvClass = r.cv > 0.5 ? 'high-cv' : '';
             const statusCls = r.successRate < 100 ? 'status-fail' : 'status-success';
+            const kindTag = r.task_kind === 'chore' ? '[C]' : '[P]';
+            const target = r.task_target || r.process || r.chore || '';
             return `<tr class="${{cvClass}}">
                 <td class="mono">${{r.task_id}}</td>
                 <td>${{r.instance}}</td>
-                <td>${{r.process}}</td>
+                <td><span class="kind-tag">${{kindTag}}</span> ${{target}}</td>
                 <td class="mono">${{r.avg.toFixed(2)}}</td>
                 <td class="mono">${{r.mn.toFixed(2)}}</td>
                 <td class="mono">${{r.mx.toFixed(2)}}</td>
@@ -1585,9 +1623,11 @@ def generate_dashboard(
         tbody.innerHTML = sorted.map(o => {{
             const statusCls = o.status === 'Success' ? 'status-success' : 'status-fail';
             const vsMedian = o.duration_seconds - median;
+            const kindTag = o.task_kind === 'chore' || o.chore ? '[C]' : '[P]';
+            const target = o.task_target || o.process || o.chore || '';
             return `<tr>
                 <td class="mono">${{o.task_id}}</td>
-                <td>${{o.process}}</td>
+                <td><span class="kind-tag">${{kindTag}}</span> ${{target}}</td>
                 <td>${{o.instance}}</td>
                 <td class="mono">${{o.run_id}}</td>
                 <td class="mono duration-slow">${{o.duration_seconds.toFixed(2)}}</td>
@@ -1613,15 +1653,19 @@ def generate_dashboard(
         }}
 
         panel.style.display = 'block';
-        tbody.innerHTML = filtered.map(f => `<tr>
+        tbody.innerHTML = filtered.map(f => {{
+            const kindTag = f.task_kind === 'chore' || f.chore ? '[C]' : '[P]';
+            const target = f.task_target || f.process || f.chore || '';
+            return `<tr>
             <td class="mono">${{f.task_id}}</td>
-            <td>${{f.process}}</td>
+            <td><span class="kind-tag">${{kindTag}}</span> ${{target}}</td>
             <td>${{f.instance}}</td>
             <td class="mono">${{f.run_id}}</td>
             <td class="mono">${{f.duration_seconds != null ? f.duration_seconds.toFixed(2) : '-'}}</td>
             <td style="max-width:300px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;"
                 title="${{(f.error_message || '').replace(/"/g, '&quot;')}}">${{f.error_message || '-'}}</td>
-        </tr>`).join('');
+        </tr>`;
+        }}).join('');
     }}
 
     function updateConfigDetails(runs) {{

{rushti-2.2.3 → rushti-2.3.0}/src/rushti/execution.py

@@ -24,6 +24,7 @@ from typing import Dict, List, Optional, Tuple, TYPE_CHECKING
 
 from TM1py import TM1Service
 from TM1py.Exceptions import TM1pyTimeout
+from TM1py.Objects import Chore
 
 from rushti.task import Task, OptimizedTask
 from rushti.dag import DAG
@@ -40,6 +41,11 @@ from rushti.messages import (
     MSG_PROCESS_NOT_EXISTS,
     MSG_PROCESS_PARAMS_INCORRECT,
     MSG_PROCESS_TIMEOUT,
+    MSG_CHORE_EXECUTE,
+    MSG_CHORE_SUCCESS,
+    MSG_CHORE_FAIL,
+    MSG_CHORE_NOT_EXISTS,
+    MSG_CHORE_REQUIRES_SINGLE_COMMIT,
 )
 from rushti.parsing import get_instances_from_tasks_file
 from rushti.exclusive import build_session_context
@@ -99,12 +105,17 @@ def _collect_task_stats(
         return
 
     with ctx.stats_data_lock:
+        # ``process`` is NOT NULL in SQLite; chore tasks write the empty
+        # string so the column constraint stays satisfied without making
+        # it nullable. The kind is unambiguous: rows with a non-empty
+        # ``chore`` are chore tasks, rows without are processes.
         stats_entry = {
             "run_id": ctx.execution_logger.run_id if ctx.execution_logger else "",
             "workflow": ctx.execution_logger.workflow if ctx.execution_logger else None,
             "task_id": task.id,
             "instance": task.instance_name,
-            "process": task.process_name,
+            "process": task.process_name or "",
+            "chore": getattr(task, "chore_name", None),
             "parameters": task.parameters if isinstance(task.parameters, dict) else {},
             "success": success,
             "start_time": start_time,
@@ -221,6 +232,39 @@ def setup_tm1_services(
     return tm1_services, tm1_preserve_connections
 
 
+def execute_chore_with_retries(tm1: TM1Service, task: Task, retries: int):
+    """Execute a TM1 chore with retry support.
+
+    Mirrors :func:`execute_process_with_retries` for the chore path.
+    Chore execution at the TM1 API boundary is binary: HTTP 204 = success
+    (no body to parse), any exception (typically HTTP 500 with a
+    "Chore execution failed" body) = failure.
+
+    Returns a 4-tuple shaped like the process variant for symmetry — the
+    ``status`` slot carries a short human-readable summary, ``error_log_file``
+    is always empty (chores write no per-execution error file), and
+    ``attempts`` is the 0-based attempt index of the result.
+
+    :raises Exception: re-raised on the final attempt when retries
+        exhausted, matching the process path's error propagation.
+    """
+    # Only retry when ``safe_retry`` is True. ``validate_tasks`` has
+    # already asserted the chore is SINGLE_COMMIT in that case so
+    # whole-chore retry cannot leak partial state.
+    effective_retries = retries if task.safe_retry else 0
+
+    for attempt in range(effective_retries + 1):
+        try:
+            tm1.chores.execute_chore(task.chore_name)
+            return True, "Completed", "", attempt
+        except Exception:
+            if attempt == effective_retries:
+                raise
+
+    # Defensive — loop body always returns or raises.
+    return False, "", "", effective_retries
+
+
 def execute_process_with_retries(tm1: TM1Service, task: Task, retries: int):
     for attempt in range(retries + 1):
         try:
@@ -296,12 +340,21 @@ def execute_task(
             return False
 
     if task.instance_name not in tm1_services:
+        # Reuse the process-flavoured "instance not in config" message —
+        # the chore name slots in as the task identity for context.
         msg = MSG_PROCESS_FAIL_INSTANCE_NOT_IN_CONFIG_FILE.format(
-            process_name=task.process_name, instance_name=task.instance_name
+            process_name=task.process_name or task.chore_name,
+            instance_name=task.instance_name,
         )
         logger.error(msg)
         return False
 
+    # Dispatch to chore branch for chore-kind tasks. Mutual exclusion
+    # guarantees that ``chore_name`` is set iff ``process_name`` is not,
+    # so the dispatch is unambiguous.
+    if getattr(task, "chore_name", None):
+        return _execute_chore_task(ctx, task, retries, tm1_services)
+
     tm1 = tm1_services[task.instance_name]
     # Execute it - include stage in log if present
     stage_info = f" [stage: {task.stage}]" if task.stage else ""
@@ -469,13 +522,128 @@ def execute_task(
         return False
 
 
+def _execute_chore_task(
+    ctx: ExecutionContext,
+    task: Task,
+    retries: int,
+    tm1_services: Dict[str, TM1Service],
+) -> bool:
+    """Execute a chore-kind task.
+
+    Parallel to the chore branch of :func:`execute_task` for processes.
+    Logs success/failure, records stats, and threads the chore identity
+    into the structured execution logger via the new ``chore=`` parameter.
+    """
+    tm1 = tm1_services[task.instance_name]
+    stage_info = f" [stage: {task.stage}]" if task.stage else ""
+    logger.info(
+        MSG_CHORE_EXECUTE.format(
+            chore_name=task.chore_name,
+            instance_name=task.instance_name,
+        )
+        + stage_info
+    )
+    start_time = datetime.now()
+
+    try:
+        success, status, _, attempts = execute_chore_with_retries(
+            tm1=tm1, task=task, retries=retries
+        )
+        end_time = datetime.now()
+        elapsed_time = end_time - start_time
+
+        if success:
+            logger.info(
+                MSG_CHORE_SUCCESS.format(
+                    chore=task.chore_name,
+                    instance=task.instance_name,
+                    retries=attempts,
+                    time=elapsed_time,
+                )
+            )
+
+            if ctx.execution_logger:
+                ctx.execution_logger.log_task_execution(
+                    task_id=task.id,
+                    instance=task.instance_name,
+                    process="",
+                    chore=task.chore_name,
+                    parameters={},
+                    success=True,
+                    start_time=start_time,
+                    end_time=end_time,
+                    retry_count=attempts,
+                )
+
+            _collect_task_stats(
+                ctx,
+                task,
+                success=True,
+                start_time=start_time,
+                end_time=end_time,
+                retry_count=attempts,
+            )
+            return True
+
+        # Unreachable in practice: chore execution returns True or raises.
+        # Guarded for symmetry with the process path.
+        return False
+
+    except Exception as e:
+        end_time = datetime.now()
+        elapsed_time = end_time - start_time
+        # ``attempts`` is the global ``retries`` ceiling when safe_retry
+        # is enabled and we exhausted the loop, else 0.
+        attempts = retries if task.safe_retry else 0
+        error = str(e)
+        logger.error(
+            MSG_CHORE_FAIL.format(
+                chore=task.chore_name,
+                instance=task.instance_name,
+                retries=attempts,
+                time=elapsed_time,
+                error=error,
+            )
+        )
+
+        if ctx.execution_logger:
+            ctx.execution_logger.log_task_execution(
+                task_id=task.id,
+                instance=task.instance_name,
+                process="",
+                chore=task.chore_name,
+                parameters={},
+                success=False,
+                start_time=start_time,
+                end_time=end_time,
+                retry_count=attempts,
+                error_message=error,
+            )
+
+        _collect_task_stats(
+            ctx,
+            task,
+            success=False,
+            start_time=start_time,
+            end_time=end_time,
+            retry_count=attempts,
+            error_message=error,
+        )
+        return False
+
+
 def verify_predecessors_ok(ctx: ExecutionContext, task: OptimizedTask) -> bool:
+    # Use the kind-appropriate identity for log messages — chore tasks
+    # have no process name and no parameters to render.
+    target = task.process_name or task.chore_name
+    parameters = task.parameters if task.process_name else {}
+
     for predecessor_id in task.predecessors:
         if predecessor_id not in ctx.task_execution_results:
             msg = MSG_PROCESS_ABORTED_UNCOMPLETE_PREDECESSOR.format(
                 instance=task.instance_name,
-                process=task.process_name,
-                parameters=task.parameters,
+                process=target,
+                parameters=parameters,
                 predecessor=predecessor_id,
             )
             logger.error(msg)
@@ -484,8 +652,8 @@ def verify_predecessors_ok(ctx: ExecutionContext, task: OptimizedTask) -> bool:
         if not ctx.task_execution_results[predecessor_id]:
             msg = MSG_PROCESS_ABORTED_FAILED_PREDECESSOR.format(
                 instance=task.instance_name,
-                process=task.process_name,
-                parameters=task.parameters,
+                process=target,
+                parameters=parameters,
                 predecessor=predecessor_id,
             )
             logger.error(msg)
@@ -495,21 +663,61 @@ def verify_predecessors_ok(ctx: ExecutionContext, task: OptimizedTask) -> bool:
 
 
 def validate_tasks(tasks: List[Task], tm1_services: Dict[str, TM1Service]) -> bool:
-    validated_tasks = []
+    validated_processes: List[str] = []
+    # Chore validation is keyed by (instance, chore_name) — chore names
+    # are scoped to a server and existence must be checked per-instance.
+    # safe_retry tasks additionally trigger a SINGLE_COMMIT check.
+    validated_chores: set = set()
+    safe_retry_chore_checked: set = set()
     validation_ok = True
 
     tasks = [task for task in tasks if isinstance(task, Task)]  # --> ignore Wait(s)
     for task in tasks:
+        tm1 = tm1_services[task.instance_name]
+
+        if getattr(task, "chore_name", None):
+            chore_key = (task.instance_name, task.chore_name)
+
+            # Existence check — dedup'd by (instance, chore_name).
+            if chore_key not in validated_chores:
+                validated_chores.add(chore_key)
+                if not tm1.chores.exists(task.chore_name):
+                    logger.error(
+                        MSG_CHORE_NOT_EXISTS.format(
+                            chore=task.chore_name, instance=task.instance_name
+                        )
+                    )
+                    validation_ok = False
+                    # Skip the safe_retry check — chore doesn't exist.
+                    continue
+
+            # SINGLE_COMMIT check — only fetched when safe_retry is True
+            # so we avoid the extra round-trip otherwise. Dedup'd
+            # independently so a mixed taskfile (some safe, some not)
+            # still triggers the fetch exactly once per chore.
+            if task.safe_retry and chore_key not in safe_retry_chore_checked:
+                safe_retry_chore_checked.add(chore_key)
+                chore = tm1.chores.get(task.chore_name)
+                if chore.execution_mode != Chore.SINGLE_COMMIT:
+                    logger.error(
+                        MSG_CHORE_REQUIRES_SINGLE_COMMIT.format(
+                            chore=task.chore_name,
+                            instance=task.instance_name,
+                            execution_mode=chore.execution_mode,
+                        )
+                    )
+                    validation_ok = False
+            continue
+
+        # Process branch (unchanged behaviour, slightly tidied).
         current_task = {
             "instance": task.instance_name,
             "process": task.process_name,
             "parameters": task.parameters.keys(),
         }
 
-        tm1 = tm1_services[task.instance_name]
-
         # avoid repeated validations
-        if current_task["process"] in validated_tasks:
+        if current_task["process"] in validated_processes:
             continue
 
         # check for process existence
@@ -518,7 +726,7 @@ def validate_tasks(tasks: List[Task], tm1_services: Dict[str, TM1Service]) -> bo
                 process=task.process_name, instance=task.instance_name
             )
             logger.error(msg)
-            validated_tasks.append(current_task["process"])
+            validated_processes.append(current_task["process"])
             validation_ok = False
             continue
 
@@ -540,7 +748,7 @@ def validate_tasks(tasks: List[Task], tm1_services: Dict[str, TM1Service]) -> bo
                 logger.error(msg)
                 validation_ok = False
 
-        validated_tasks.append(current_task["process"])
+        validated_processes.append(current_task["process"])
 
     return validation_ok