fix queue overwrite + pause toggle + resolved-path hint

Three fixes around the render queue UX, all driven by a stress test
against the Studio data the user actually had:

1. The "directory-only" output_override bug

   Picking a folder via the Output Path browse button stored a value
   like "/Users/me/Renders/" — a directory, no filename. The resolver
   used it as-is, so Blender treated the trailing slash as a folder
   and generated the filename itself (the .blend's name). Every Studio
   in a queue overwrote the same file.

   Fix: detect directory-like overrides (no {tokens} AND ends with /
   or has no extension) and join with a guaranteed-distinct fallback
   filename "{studio}_{frame:04d}.{ext}". So /r/ with Studios Hero,
   Wide, Detail now resolves to /r/Hero_0001.png, /r/Wide_0001.png,
   /r/Detail_0001.png — confirmed via MCP stress test against the
   user's real prefs.

   Tokens-bearing overrides ("/r/{studio}.{ext}") and explicit-file
   overrides ("/r/output.png") are still used as-is.

2. Resolved output path shown in the Stage panel

   New "→ <path>" hint under the Output Path field, computed via
   resolve_output_path(). Lets the user see where renders WILL land
   before they hit Render or Queue — would have caught the directory
   bug instantly. Wrapped in try/except so a resolver hiccup never
   takes down the whole panel draw.

3. Pause Render Queue toggle

   New StagePreferences.queue_paused BoolProperty + Pause/Auto-Process
   toggle button at the top of the queue panel. When paused,
   queue.monitor._tick() reaps finished workers and refreshes the UI
   but skips spawn_next() — the user must use Start Worker to process
   one job at a time, or untick to resume auto-processing. Addresses
   the "queueing auto-starts" complaint without changing the default
   behaviour.

5 new tests in test_render_path_shared.py:
- directory_override_uses_studio_frame_filename
- directory_override_without_trailing_slash_still_treated_as_dir
- directory_override_distinct_per_studio (regression for the queue bug)
- override_with_extension_used_as_is
- override_with_tokens_used_as_is

Total suite: 167/168 (one pre-existing dirty-state reload flake).

Author: BlueLazyFish

stage/core/render.py

@@ -46,13 +46,67 @@
 }
 
 
+def _looks_like_directory(path: str) -> bool:
+    """True if this looks like a folder path the user picked via the browse
+    button rather than a full filename pattern.
+
+    Heuristic: no {tokens} AND (ends with a path separator OR has no extension).
+    A path with tokens is assumed intentional and used as-is. A path with an
+    extension and no tokens is a single-file output (one Studio scenario,
+    user accepts the overwrite if they queue multiple).
+    """
+    if not path:
+        return False
+    if "{" in path and "}" in path:
+        return False
+    if path.endswith(("/", "\\")):
+        return True
+    # No separator at end — check if there's a file extension on the leaf
+    leaf = path.rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
+    return "." not in leaf
+
+
+# Filename used when the user picks a folder via the browse button. Both
+# {studio} and {frame} are included so distinct Studios queued together
+# produce distinct files (the bug that motivated this whole helper) and
+# multi-frame animations don't overwrite themselves.
+_DIR_FALLBACK_FILENAME = "{studio}_{frame:04d}.{ext}"
+
+
+def _join_dir_and_filename(directory: str, filename: str) -> str:
+    """Concatenate, normalising the separator between them. Preserves the
+    leading '//' blend-relative prefix on the directory."""
+    if directory.endswith(("/", "\\")):
+        return directory + filename
+    return directory + "/" + filename
+
+
 def resolve_output_path(scene, studio, default_pattern: str, *, frozen_now=None) -> str:
     """Pure function: compute the expanded output path for this Studio.
 
+    Behaviour:
+      - Empty override: use default_pattern
+      - Override is a *directory* (no tokens, ends with / or no extension):
+          combine override (directory) with the default_pattern's filename
+          portion, so the user can pick a folder via the browse button
+          and still get distinct per-Studio filenames.
+      - Override has tokens or looks like a file: use override as-is.
+
     No side effects on the scene. Use this when you need to know where a
     render WOULD go without actually running the render.
     """
-    template = studio.output_override or default_pattern
+    override = studio.output_override
+    if not override:
+        template = default_pattern
+    elif _looks_like_directory(override):
+        # default_pattern's filename portion isn't safe to reuse here —
+        # if it's just "{frame}.{ext}" then every Studio collides on the
+        # same file. Use a guaranteed-distinct {studio}_{frame:04d}.{ext}
+        # template instead.
+        template = _join_dir_and_filename(override, _DIR_FALLBACK_FILENAME)
+    else:
+        template = override
+
     ctx = build_default_context(
         studio_name=studio.name,
         blend_path=bpy.data.filepath,

stage/prefs.py

@@ -92,6 +92,18 @@ class StagePreferences(AddonPreferences):
     # forward across versions.
     user_templates: CollectionProperty(type=UserTemplate)
 
+    # Render queue — when paused, the monitor timer doesn't auto-spawn the
+    # next worker even if PENDING jobs exist. User has to hit "Start Worker"
+    # to kick a single job, or untick Pause to resume auto-processing.
+    queue_paused: BoolProperty(
+        name="Pause Render Queue",
+        description=(
+            "Don't auto-start workers when jobs are queued. Use Start Worker "
+            "to process one job manually, or untick to resume auto-processing"
+        ),
+        default=False,
+    )
+
     # Logging
     log_level: EnumProperty(
         name="Log Level",

stage/queue/monitor.py

@@ -35,6 +35,18 @@ def _tag_redraw() -> None:
                 area.tag_redraw()
 
 
+def _is_queue_paused() -> bool:
+    """True if the user has ticked Pause Render Queue in addon prefs.
+    Returns False on any lookup error (no prefs entry, etc.) so the queue
+    keeps running rather than silently stalling."""
+    try:
+        from ..prefs import get_prefs
+        prefs = get_prefs(bpy.context)
+        return bool(prefs and prefs.queue_paused)
+    except Exception:
+        return False
+
+
 def _tick() -> float:
     """Single timer iteration. Returns POLL_INTERVAL_SECONDS so the timer
     fires again, or None to stop."""
@@ -43,10 +55,13 @@ def _tick() -> float:
         if finished_job_id is not None:
             _log.info("Queue: job %d finished", finished_job_id)
 
-        # Spawn next pending job if no worker is currently busy
-        spawned = queue_worker.spawn_next()
-        if spawned is not None:
-            _log.info("Queue: spawned worker for job %d", spawned)
+        # Auto-spawn unless the user has paused the queue. Pause respects
+        # the existing worker — a job that's already running keeps going;
+        # we just don't pick up the next one.
+        if not _is_queue_paused():
+            spawned = queue_worker.spawn_next()
+            if spawned is not None:
+                _log.info("Queue: spawned worker for job %d", spawned)
 
         _tag_redraw()
     except Exception as e:

stage/ui/n_panel.py

@@ -114,10 +114,26 @@ def draw(self, context):
                 icon='GROUP',
             )
 
-            # Output Path — label on its own line so the field gets full width
+            # Output Path — label on its own line so the field gets full width.
+            # Below the field we show the resolved path (after template
+            # expansion + directory-fallback rules) so the user can see
+            # exactly where a render would land before they click Render
+            # or Queue. Empty override = falls back to the addon-prefs
+            # default pattern shown above.
             col = details.column(align=True)
             col.label(text="Output Path:")
             col.prop(active, "output_override", text="")
+            try:
+                from ..core.render import resolve_output_path
+                from ..prefs import get_default_output_pattern
+                resolved = resolve_output_path(
+                    context.scene, active,
+                    get_default_output_pattern(context),
+                )
+                hint = col.row()
+                hint.label(text=f"→ {resolved}", icon='FILE_TICK')
+            except Exception:
+                pass
 
             # Facet capture toggles — what this Studio remembers
             fcol = details.column(align=True)

stage/ui/queue_panel.py

@@ -17,6 +17,7 @@
 import bpy
 from bpy.types import Panel
 
+from ..prefs import get_prefs
 from ..queue import db as queue_db
 from ..queue import worker as queue_worker
 
@@ -80,6 +81,20 @@ def draw(self, context):
         # Toolbar — control
         col = layout.column(align=True)
         col.label(text="Control:")
+
+        # Pause toggle drives auto-spawn behaviour in queue.monitor.
+        # When paused the user must hit Start Worker to process one job.
+        prefs = get_prefs(context)
+        if prefs is not None:
+            paused = prefs.queue_paused
+            row = col.row(align=True)
+            row.prop(
+                prefs, "queue_paused",
+                text="Paused" if paused else "Auto-Process",
+                icon='PAUSE' if paused else 'PLAY',
+                toggle=True,
+            )
+
         row = col.row(align=True)
         row.enabled = queue_worker.is_worker_alive()
         row.operator("stage.queue_cancel_active", icon='CANCEL')

tests/blender/test_render_path_shared.py

@@ -79,6 +79,70 @@ def test_resolve_output_path_preserves_blender_relative_prefix():
     assert "Hero" in path
 
 
+# --- directory-like override fallback (the queue overwrite bug) ----------
+
+
+def test_directory_override_uses_studio_frame_filename():
+    """User picks a folder — result is <folder>/<studio>_<frame>.<ext>
+    so distinct Studios produce distinct files (no shared filename)."""
+    scene = _fresh_scene()
+    studio = _make_studio(scene, "Hero", output_override="/Users/me/Renders/")
+
+    path = resolve_output_path(
+        scene, studio,
+        default_pattern="{blendname}/{studio}/{frame}.{ext}",
+    )
+    assert path == "/Users/me/Renders/Hero_0001.png", f"unexpected: {path}"
+
+
+def test_directory_override_without_trailing_slash_still_treated_as_dir():
+    """A leaf with no extension reads as a folder, even without trailing slash."""
+    scene = _fresh_scene()
+    studio = _make_studio(scene, "Hero", output_override="/Users/me/Renders")
+
+    path = resolve_output_path(
+        scene, studio, default_pattern="ignored",
+    )
+    assert path == "/Users/me/Renders/Hero_0001.png", f"unexpected: {path}"
+
+
+def test_directory_override_distinct_per_studio():
+    """Two Studios with the same folder override must resolve to distinct files."""
+    scene = _fresh_scene()
+    a = _make_studio(scene, "Hero", output_override="/r/")
+    b = _make_studio(scene, "Wide", output_override="/r/")
+
+    pa = resolve_output_path(scene, a, default_pattern="ignored")
+    pb = resolve_output_path(scene, b, default_pattern="ignored")
+    assert pa != pb, "distinct studios must produce distinct output paths"
+    assert "Hero" in pa
+    assert "Wide" in pb
+
+
+def test_override_with_extension_used_as_is():
+    """`.png` leaf means the user is intentionally writing one file —
+    don't second-guess them."""
+    scene = _fresh_scene()
+    studio = _make_studio(scene, "Hero", output_override="/r/output.png")
+
+    path = resolve_output_path(
+        scene, studio, default_pattern="{studio}/{frame}.{ext}",
+    )
+    assert path == "/r/output.png", f"expected as-is, got {path}"
+
+
+def test_override_with_tokens_used_as_is():
+    """Override containing {tokens} is intentional — use it directly
+    even if it doesn't have a file extension."""
+    scene = _fresh_scene()
+    studio = _make_studio(
+        scene, "Hero", output_override="/r/{studio}_{frame:04d}.{ext}",
+    )
+
+    path = resolve_output_path(scene, studio, default_pattern="ignored")
+    assert path == "/r/Hero_0001.png", f"unexpected expansion: {path}"
+
+
 def test_foreground_and_subprocess_paths_match():
     """The whole point of extracting core/render.resolve_output_path —
     foreground and subprocess MUST produce identical paths for the same