froid-loop 0.11.1__py3-none-any.whl

froid_loop/data/plugins/tea/tea_plugin.py

@@ -0,0 +1,258 @@
+"""In-process brain for the bundled Test Architect Enterprise (TEA) plugin.
+
+The plugin's behaviour is mostly declarative — six ``[workflows.*]`` inject TEA
+sessions at ``post_dev_phase`` / ``pre_commit_gate``, and the generic
+workflow-overlay convention (``<name>_enabled`` / ``<name>_blocking``) turns the
+per-step settings into enable/blocking switches with no code. This module owns
+the two things that need logic:
+
+  * the **readiness gate** (``validate``) — fail the run fast, with an actionable
+    remediation message, when ``require_tea`` is on but the project has no TEA
+    install, so an operator who enabled the plugin without installing TEA learns
+    immediately instead of watching every injected session flail.
+  * **blocking-gate enforcement** (``on_pre_commit``) — when an operator marks a
+    gate step blocking (``trace_blocking`` / ``nfr_blocking`` / ``review_blocking``
+    = true), parse that gate's latest TEA artifact at commit time and, on a
+    FAIL/CONCERNS verdict, escalate the unit (``ctx.veto("pause", …)``) instead of
+    letting it land. ``pre_commit`` is the first vetoable stage *after* the
+    ``pre_commit_gate`` workflows have written their artifacts, and both fire
+    unconditionally on every path into a commit — review-converged, skip-review
+    (``review.trigger="recommended"`` with no follow-up recommended), and the
+    review-budget rescue — so the gates evaluate the exact tree about to commit.
+
+Enforcement is **fail-open by design**: if a gate has no blocking flag, no
+artifact, or an artifact that can't be parsed into a known verdict, the commit is
+never blocked. An unknown format must never wrongly stop a commit — only a
+confidently-parsed FAIL/CONCERNS on an operator-marked-blocking gate escalates.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from froid_loop.plugins.model import Plugin, PluginError
+
+if TYPE_CHECKING:
+    from froid_loop.plugins.context import HookContext
+
+# The gate steps that expose a ``*_blocking`` flag (the pre_commit_gate steps
+# an operator is likely to enforce). Generation steps (td/atdd/automate) stay
+# advisory by design and are deliberately absent — they are never gate-enforced.
+GATE_STEPS = ("trace", "nfr", "review")
+
+# Verdicts that escalate a blocking gate. PASS / WAIVED (an explicit human
+# approval to proceed) / an unknown-or-not-evaluated verdict never block.
+BLOCKING_VERDICTS = frozenset({"FAIL", "CONCERNS"})
+
+# Where each gate writes its decision, in probe order (first parseable wins).
+#   * "json"     — a TEA machine-readable file; read ``gate_status`` / ``decision``
+#   * "md_trace" — the trace report's ``## Gate Decision: <verdict>`` heading
+#   * "md_nfr"   — the NFR report's ``**Overall Status:** / **Gate Status:**`` line
+#   * "md_review"— the test-review report's ``**Recommendation**:`` line
+# Paths are relative to TEA's configured ``test_artifacts`` directory. trace
+# emits JSON for exactly this purpose, so it is preferred over its markdown.
+GATE_ARTIFACTS: dict[str, tuple[tuple[str, str], ...]] = {
+    "trace": (
+        ("json", "gate-decision.json"),
+        ("json", "e2e-trace-summary.json"),
+        ("md_trace", "traceability-matrix.md"),
+    ),
+    "nfr": (("md_nfr", "nfr-assessment.md"),),
+    "review": (("md_review", "test-review.md"),),
+}
+
+# Labels that precede a concrete verdict on a markdown gate line, per artifact.
+_MD_LABELS: dict[str, tuple[str, ...]] = {
+    "md_trace": ("gate decision",),
+    "md_nfr": ("gate status", "overall status", "overall_status"),
+}
+
+
+def _verdict_token(text: str) -> str | None:
+    """The canonical gate verdict named anywhere in ``text``, or None. CONCERNS /
+    FAIL are checked before PASS so a value line that pairs them (rare) errs toward
+    blocking; NOT_EVALUATED and anything unrecognized resolve to None (fail-open)."""
+    up = text.upper()
+    for token in ("CONCERNS", "FAIL", "WAIVED", "PASS"):
+        if token in up:
+            return token
+    return None
+
+
+def _review_token(line: str) -> str | None:
+    """Map the test-review report's recommendation vocabulary onto a gate verdict:
+    Block -> FAIL, Request Changes -> CONCERNS, Approve[/with Comments] -> PASS."""
+    low = line.lower()
+    if "block" in low:
+        return "FAIL"
+    if "request change" in low:
+        return "CONCERNS"
+    if "approve" in low:
+        return "PASS"
+    return None
+
+
+def _scan_markdown(text: str, labels: tuple[str, ...], normalize) -> str | None:
+    """First *concrete* labeled line that yields a verdict. Lines carrying ``{}``
+    placeholders or ``|`` table syntax are skipped — they are template scaffolding,
+    not a generated decision — so a real artifact's value line is what's read."""
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line or "{" in line or "}" in line or "|" in line:
+            continue
+        if any(label in line.lower() for label in labels):
+            verdict = normalize(line)
+            if verdict is not None:
+                return verdict
+    return None
+
+
+class TeaPlugin(Plugin):
+    """Trust-gated in-process plugin (loads only when "tea" is in
+    ``[plugins] enabled``). Owns the TEA readiness gate + blocking-gate
+    enforcement at commit."""
+
+    # a readiness failure is a deliberate config rejection raised from validate()
+    # (fails the run fast), not an isolated hook crash — so fail_closed stays off.
+    # Enforcement (on_pre_commit) is fail-open too: a parse failure must never
+    # wrongly block, so a raised handler isolating out is the safe outcome.
+    fail_closed = False
+
+    # ----------------------------------------------------------- validation
+
+    def validate(self, policy: Any) -> None:
+        """Readiness gate: with ``require_tea`` on, refuse to start unless TEA is
+        installed in the project (``_froid/tea/config.yaml`` present). Raising here
+        propagates through ``registry.validate`` so the run fails fast at startup
+        rather than launching six sessions that each invoke a missing workflow."""
+        if not self._require_tea():
+            return
+        config = self._tea_config_path(self._project_root())
+        if not config.is_file():
+            raise PluginError(
+                "plugin 'tea': the Test Architect Enterprise (TEA) module is not "
+                f"installed in this project (missing {config}). Install it with "
+                "`npx froid-plane install` and choose 'Test Architect', or set "
+                "require_tea = false under [plugins.tea] in .froid-loop/policy.toml "
+                "to run the TEA workflows advisory-only without it."
+            )
+
+    # --------------------------------------------------------- enforcement
+
+    def on_pre_commit(self, ctx: "HookContext") -> None:
+        """Blocking-gate enforcement. For each gate an operator marked blocking,
+        parse its latest TEA artifact under the configured ``test_artifacts`` dir
+        and, on a FAIL/CONCERNS verdict, ``pause``-veto so the unit escalates for
+        human review instead of committing.
+
+        Fail-open throughout: a gate with no blocking flag, no artifact, or an
+        unparseable artifact contributes nothing. Only confidently-parsed
+        blocking verdicts escalate. ``pre_commit`` honors only a ``pause`` veto
+        (a COMMITTING task has no legal move to DEFERRED), which is the right
+        "blocking gate failed" semantic — escalate-for-human."""
+        gates = [g for g in GATE_STEPS if bool(self.settings.get(f"{g}_blocking"))]
+        if not gates:
+            return  # nothing flagged blocking -> advisory only, no artifact read
+
+        # Resolve the tree TEA wrote into: the unit's worktree (where the
+        # pre_commit_gate sessions just ran), falling back to the repo root.
+        # Under isolation = none the two coincide.
+        root = ctx.worktree or ctx.repo_root
+        if not root:
+            return  # fail-open: no tree to inspect
+        artifacts_dir = self._artifacts_dir(Path(root))
+
+        verdicts: dict[str, str] = {}
+        failed: list[tuple[str, str]] = []
+        for gate in gates:
+            verdict = self._gate_verdict(gate, artifacts_dir)
+            if verdict is None:
+                continue  # fail-open: missing / unparseable / not-evaluated
+            verdicts[gate] = verdict
+            if verdict in BLOCKING_VERDICTS:
+                failed.append((gate, verdict))
+
+        if verdicts:
+            # breadcrumb for the operator / journal: what each gate decided.
+            ctx.shared.setdefault("tea_gates", {}).update(verdicts)
+        if failed:
+            detail = ", ".join(f"{gate}={verdict}" for gate, verdict in failed)
+            ctx.veto(
+                "pause",
+                f"TEA blocking gate(s) failed for {ctx.story_key or 'unit'}: {detail}. "
+                f"Review the gate artifacts under {artifacts_dir}, resolve the "
+                "findings, then resume the run.",
+            )
+
+    # -------------------------------------------------------------- helpers
+
+    def _require_tea(self) -> bool:
+        return bool(self.settings.get("require_tea", True))
+
+    def _project_root(self) -> Path:
+        """The project root, resolved the way the engine resolves it: the run's
+        working directory (``froid-loop``'s ``--project`` defaults to cwd, and the
+        process is not chdir'd into a worktree at construction time). validate()
+        has no ``HookContext`` to read ``repo_root`` from, so cwd is the available
+        signal; ``on_pre_commit`` uses ``ctx.worktree`` / ``ctx.repo_root`` for the
+        authoritative per-unit root."""
+        return Path.cwd()
+
+    def _tea_config_path(self, root: Path) -> Path:
+        return root / "_froid" / "tea" / "config.yaml"
+
+    def _artifacts_dir(self, root: Path) -> Path:
+        """TEA's configured ``test_artifacts`` directory, resolved against ``root``.
+
+        Reads the ``test_artifacts`` line from ``_froid/tea/config.yaml`` (a light
+        line parse — no YAML dependency, and robust if the file is absent), expands
+        the ``{project-root}`` / ``{output_folder}`` tokens, and falls back to the
+        installer default. A relative value is joined onto ``root``."""
+        value = "{project-root}/_froid-output/test-artifacts"
+        config = self._tea_config_path(root)
+        try:
+            for raw in config.read_text(encoding="utf-8").splitlines():
+                line = raw.strip()
+                if line.startswith("test_artifacts:"):
+                    value = line.split(":", 1)[1].strip().strip("\"'")
+                    break
+        except OSError:
+            pass  # fail-open: use the default location
+        value = value.replace("{project-root}", str(root)).replace(
+            "{output_folder}", str(root / "_froid-output")
+        )
+        path = Path(value)
+        return path if path.is_absolute() else root / value
+
+    def _gate_verdict(self, gate: str, artifacts_dir: Path) -> str | None:
+        """The latest verdict for ``gate`` from its artifacts, or None. Probes each
+        candidate in order, returning the first that parses to a known verdict;
+        any read/parse error on a candidate is swallowed (fail-open) and the next
+        is tried."""
+        for kind, filename in GATE_ARTIFACTS.get(gate, ()):
+            path = artifacts_dir / filename
+            if not path.is_file():
+                continue
+            try:
+                verdict = self._parse_artifact(kind, path)
+            except Exception:  # nosec B112 - fail-open: a parse error never blocks
+                continue
+            if verdict is not None:
+                return verdict
+        return None
+
+    def _parse_artifact(self, kind: str, path: Path) -> str | None:
+        """Extract a gate verdict from one artifact, by kind."""
+        text = path.read_text(encoding="utf-8")
+        if kind == "json":
+            data = json.loads(text)
+            if isinstance(data, dict):
+                raw = data.get("gate_status") or data.get("decision")
+                if isinstance(raw, str):
+                    return _verdict_token(raw)
+            return None
+        if kind == "md_review":
+            return _scan_markdown(text, ("recommendation",), _review_token)
+        return _scan_markdown(text, _MD_LABELS[kind], lambda line: _verdict_token(line))

froid_loop/data/plugins/unity/plugin.toml

@@ -0,0 +1,140 @@
+# Bundled Unity game-engine plugin for froid-loop.
+#
+# This is the proof that the plugin framework is general enough to carry the
+# whole game-engine layer with no engine-specific code in core. Unity drives a
+# project whose dev/sweep cycle needs a live Editor + MCP bridge.
+#
+# Opt in from .froid-loop/policy.toml:
+#   [plugins]
+#   enabled = ["unity"]          # [python] module loads only when enabled
+#
+#   [plugins.unity]
+#   editor_mode = "shared"       # shared (live Editor, isolation=none)
+#                                # | per_worktree (one Editor per worktree, isolation=worktree)
+#   mcp = "ivanmurzak"           # ivanmurzak | coplaydev
+#
+# Override per project by copying this dir to .froid-loop/plugins/unity/ and
+# editing it (the project-local copy wins, and its dir becomes {scripts}).
+#
+# Scene auto-save guard: Unity-MCP GameObject tools mark scenes dirty but never
+# save, so a shared editor's scene sits chronically dirty — and that dirty state
+# is what raises the two run-stalling modal dialogs (scene-changed-on-disk reload,
+# and save-before-quit), which freeze the MCP dispatch loop. This plugin seeds an
+# editor-only auto-save guard (Assets/FroidLoop/Editor/, from unity_assets/) into
+# the project so no such modal ever appears. The seeded guard is committed into
+# the consumer project by story-finalize's `git add -A` — that is intended (the
+# guard travels with the repo). Disable with install_scene_guard = false.
+
+[plugin]
+name = "unity"
+version = "1.0.0"
+api_version = 1
+description = "Drive a Unity project whose dev/sweep cycle needs a live Editor + MCP bridge."
+author = "froid-loop"
+# MCP-generated skills are gitignored; seed them into per_worktree checkouts so
+# the agent's CLI can reach the worktree Editor's tools.
+seed_globs = [".claude/skills/*"]
+
+# The in-process module owns the engine glue: the readiness gate, per_worktree
+# Editor setup/teardown, MCP agent routing, Library priming, and the
+# editor_mode<->scm.isolation coupling validation. It hooks the engine's
+# lifecycle stages (pre_ready_gate / pre_worktree_setup / pre_worktree_teardown)
+# and vetoes (defers) the unit when the Editor can't be made ready. It also
+# quiesces the Editor around a failed-attempt rollback (pre_rollback /
+# post_rollback) so a git reset --hard can't leave a shared Editor showing a
+# run-freezing scene-changed-on-disk modal — best effort, never blocks the reset.
+# On pre_session it appends the scene-save discipline (unity_facts.md) to every
+# dev/review prompt, and (when dialog_probe is on) it launches + reaps a detached,
+# DETECT-ONLY modal-dialog probe (pre_run / post_run / pre_worktree_setup).
+[python]
+module = "unity_plugin.py"
+class = "UnityPlugin"
+
+[[settings]]
+key = "editor_mode"
+type = "select"
+options = ["shared", "per_worktree"]
+default = "shared"
+label = "Editor mode"
+help = "shared = agent works in place on the live Editor's checkout (requires scm.isolation = none); per_worktree = one managed Editor per worktree (requires scm.isolation = worktree)"
+
+[[settings]]
+key = "mcp"
+type = "select"
+options = ["ivanmurzak", "coplaydev"]
+default = "ivanmurzak"
+label = "Editor MCP"
+help = "which Editor MCP server the scripts target"
+
+[[settings]]
+key = "unity_path"
+type = "str"
+default = ""
+label = "Unity editor path"
+help = "Editor binary used to launch a per_worktree Editor; '' auto-detects. Ignored in shared mode."
+
+[[settings]]
+key = "ready_timeout_sec"
+type = "int"
+default = 600
+min = 1
+label = "Readiness timeout (sec)"
+help = "how long the readiness gate blocks for the Editor + MCP to come up"
+
+[[settings]]
+key = "ready_grace_sec"
+type = "int"
+default = -1
+label = "Readiness grace (sec)"
+help = "seconds to wait before the first readiness probe (-1 = auto: per_worktree waits for a cold Editor, shared does not)"
+
+[[settings]]
+key = "install_scene_guard"
+type = "bool"
+default = true
+label = "Install scene auto-save guard"
+help = "seed an editor-only auto-save guard into the project so chronically-dirty scenes never raise the run-stalling scene-changed-on-disk / save-before-quit modal dialogs. The seeded guard is committed into the consumer project by story-finalize's git add -A (intended). false disables seeding."
+
+[[settings]]
+key = "scene_guard_dir"
+type = "str"
+default = "Assets/FroidLoop/Editor"
+label = "Scene guard install dir"
+help = "project-relative dir the scene auto-save guard is seeded into (must live under the project's asset root, e.g. Assets/)"
+
+[[settings]]
+key = "quiesce_on_rollback"
+type = "bool"
+default = true
+label = "Quiesce Editor before rollback"
+help = "save open scenes + open an empty untitled scene via the MCP CLI before git reset, refresh assets after; best-effort, never blocks the rollback"
+
+[[settings]]
+key = "quiesce_timeout_sec"
+type = "int"
+default = 60
+min = 1
+label = "Rollback quiesce timeout (sec)"
+help = "overall budget for the pre/post-rollback quiesce helper; the loop hard-kills it past this so a wedged Editor can never stall a rollback"
+
+[[settings]]
+key = "dialog_probe"
+type = "bool"
+default = false
+label = "Detect-only modal-dialog probe"
+help = "launch a detached, DETECT-ONLY probe (unity_dialog_probe.py) that watches — via xdotool, X11/Linux only — for the run-freezing Unity modal dialogs and REPORTS them (JSONL + ATTENTION + notify-send). It never clicks or keys anything; it is the last-resort observability net for a modal the scene guard + prompt facts did not prevent. No-op where DISPLAY is unset or xdotool is absent (Windows/macOS out of scope). Off by default."
+
+[[settings]]
+key = "dialog_probe_interval_sec"
+type = "int"
+default = 5
+min = 1
+label = "Dialog probe poll interval (sec)"
+help = "how often the dialog probe polls xdotool for a visible Unity modal dialog"
+
+[[settings]]
+key = "dialog_probe_notify"
+type = "bool"
+default = true
+label = "Dialog probe desktop notification"
+help = "on a fresh detection, also fire a best-effort notify-send desktop notification (guarded by shutil.which); the JSONL + ATTENTION records are written regardless"

froid_loop/data/plugins/unity/unity_assets/FroidLoop.Unity.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "FroidLoop.Unity.Editor",
+    "rootNamespace": "FroidLoop.Unity.Editor",
+    "references": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

froid_loop/data/plugins/unity/unity_assets/FroidLoop.Unity.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d3183d5c02f900e680aa4d788779cd91
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

froid_loop/data/plugins/unity/unity_assets/SceneAutoSaveGuard.cs

@@ -0,0 +1,221 @@
+// froid-loop-scene-guard-version: 1.0.0
+//
+// Scene auto-save guard for froid-loop-driven Unity projects.
+//
+// Unity-MCP GameObject tools (com.ivanmurzak.unity.mcp) call MarkSceneDirty and
+// never save, so a project driven by the shared editor accumulates a chronically
+// dirty scene. That dirty state is what makes Unity raise the two run-stalling
+// modal dialogs:
+//   * "Scene '<name>' has been changed on disk. Reload the scene?" — pops when git
+//     or an agent rewrites the open dirty scene's .unity file on disk;
+//   * "Do you want to save the changes you made ...?" — pops on editor quit.
+// A modal dialog freezes EditorApplication.update, which the MCP plugin uses to
+// dispatch tool calls, so every subsequent MCP call times out and the run stalls.
+//
+// This guard fixes the root cause: it keeps loaded, on-disk scenes clean by
+// debounce-saving them shortly after they go dirty, and on quit it saves (or, for
+// an unsaveable untitled scene, discards) so no modal ever appears. Untitled scenes
+// are never saved automatically — that would pop a "Save As" modal, exactly what we
+// are avoiding.
+//
+// froid-loop seeds this file into consumer projects; story-finalize's `git add -A`
+// then commits it into the project — that is intended (the guard travels with the
+// repo so any editor opening it is protected). Toggle it from the FroidLoop menu.
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace FroidLoop.Unity.Editor
+{
+    [InitializeOnLoad]
+    internal static class SceneAutoSaveGuard
+    {
+        // EditorPrefs toggle (default ON) + its two menu items.
+        private const string EnabledPref = "FroidLoop.SceneAutoSaveGuard.Enabled";
+        private const string EnabledMenu = "FroidLoop/Scene Auto-Save Guard";
+        private const string SaveNowMenu = "FroidLoop/Save Open Scenes Now";
+
+        // Debounce window: each sceneDirtied event pushes the deadline out this far,
+        // so a burst of MCP edits collapses into a single save once they settle.
+        private const double DebounceSeconds = 5.0;
+
+        // The timeSinceStartup deadline for the pending save; < 0 means "nothing
+        // pending" — the cheap early-out the per-frame update handler checks first.
+        private static double s_dueAt = -1.0;
+
+        static SceneAutoSaveGuard()
+        {
+            EditorSceneManager.sceneDirtied += OnSceneDirtied;
+            EditorApplication.update += OnUpdate;
+            EditorApplication.wantsToQuit += OnWantsToQuit;
+            EditorApplication.quitting += OnQuitting;
+            // A scene can already be dirty from before this domain reload — an MCP
+            // tool dirtied it, then a recompile reloaded the domain and reset our
+            // pending state. Arm immediately so that dirty scene still gets flushed.
+            if (HasDirtyPathedScene())
+            {
+                Arm();
+            }
+        }
+
+        private static bool Enabled => EditorPrefs.GetBool(EnabledPref, true);
+
+        private static void Arm()
+        {
+            s_dueAt = EditorApplication.timeSinceStartup + DebounceSeconds;
+        }
+
+        private static void OnSceneDirtied(Scene scene)
+        {
+            Arm();
+        }
+
+        private static void OnUpdate()
+        {
+            // Cheap early-out: nothing pending is the overwhelmingly common case, so
+            // this handler must cost next to nothing when idle.
+            if (s_dueAt < 0.0)
+            {
+                return;
+            }
+            if (EditorApplication.timeSinceStartup < s_dueAt)
+            {
+                return;
+            }
+            if (!Enabled)
+            {
+                s_dueAt = -1.0; // toggled off while a save was pending — drop it
+                return;
+            }
+            // Never save mid-transition: entering/exiting play mode, compiling,
+            // importing/refreshing assets, building a player, or editing a prefab in
+            // isolation (the open scenes aren't the active editing target then).
+            // Re-arm and try again on a later frame.
+            if (EditorApplication.isPlayingOrWillChangePlaymode
+                || EditorApplication.isCompiling
+                || EditorApplication.isUpdating
+                || BuildPipeline.isBuildingPlayer
+                || PrefabStageUtility.GetCurrentPrefabStage() != null)
+            {
+                Arm();
+                return;
+            }
+            s_dueAt = -1.0;
+            SaveDirtyPathedScenes("auto-saved");
+        }
+
+        private static bool OnWantsToQuit()
+        {
+            // Even with the guard off, never block the quit — that would defeat the
+            // whole point (a frozen editor). Just don't touch the scenes.
+            if (Enabled)
+            {
+                SaveDirtyPathedScenes("auto-saved");
+                // A dirty *untitled* scene has no path to save to; leaving it would
+                // pop the "save changes before quitting?" modal we exist to prevent.
+                // Discard it by swapping in a fresh empty single scene.
+                string discarded = DirtyUntitledSceneNames();
+                if (discarded.Length > 0)
+                {
+                    Debug.LogWarning(
+                        "[SceneAutoSaveGuard] discarding unsaved untitled scene(s) on quit: "
+                            + discarded);
+                    EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+                }
+            }
+            // ALWAYS allow the quit to proceed.
+            return true;
+        }
+
+        private static void OnQuitting()
+        {
+            // Backstop: wantsToQuit already saved, but another handler in the quit
+            // chain may have re-dirtied a pathed scene after it. Save once more.
+            if (Enabled)
+            {
+                SaveDirtyPathedScenes("auto-saved");
+            }
+        }
+
+        [MenuItem(EnabledMenu, priority = 200)]
+        private static void ToggleEnabled()
+        {
+            bool now = !Enabled;
+            EditorPrefs.SetBool(EnabledPref, now);
+            Menu.SetChecked(EnabledMenu, now);
+            if (!now)
+            {
+                s_dueAt = -1.0; // cancel any pending save when the guard is disabled
+            }
+        }
+
+        [MenuItem(EnabledMenu, validate = true)]
+        private static bool ToggleEnabledValidate()
+        {
+            // Reflect the persisted toggle in the menu's checkmark each time it opens.
+            Menu.SetChecked(EnabledMenu, Enabled);
+            return true;
+        }
+
+        [MenuItem(SaveNowMenu, priority = 201)]
+        private static void SaveOpenScenesNow()
+        {
+            s_dueAt = -1.0; // immediate flush, bypassing the debounce
+            SaveDirtyPathedScenes("auto-saved");
+        }
+
+        private static bool HasDirtyPathedScene()
+        {
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                Scene scene = SceneManager.GetSceneAt(i);
+                if (scene.isDirty && !string.IsNullOrEmpty(scene.path))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        // Save every loaded scene that is dirty and has a path on disk. Untitled
+        // scenes (empty path) are always skipped so we never trigger a "Save As"
+        // modal. Returns the number saved; logs the paths when at least one saved.
+        private static int SaveDirtyPathedScenes(string verb)
+        {
+            var saved = new List<string>();
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                Scene scene = SceneManager.GetSceneAt(i);
+                if (scene.isDirty
+                    && !string.IsNullOrEmpty(scene.path)
+                    && EditorSceneManager.SaveScene(scene))
+                {
+                    saved.Add(scene.path);
+                }
+            }
+            if (saved.Count > 0)
+            {
+                Debug.Log(
+                    "[SceneAutoSaveGuard] " + verb + " " + saved.Count + " scene(s): "
+                        + string.Join(", ", saved));
+            }
+            return saved.Count;
+        }
+
+        private static string DirtyUntitledSceneNames()
+        {
+            var names = new List<string>();
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                Scene scene = SceneManager.GetSceneAt(i);
+                if (scene.isDirty && string.IsNullOrEmpty(scene.path))
+                {
+                    names.Add(string.IsNullOrEmpty(scene.name) ? "<untitled>" : scene.name);
+                }
+            }
+            return string.Join(", ", names);
+        }
+    }
+}

froid_loop/data/plugins/unity/unity_assets/SceneAutoSaveGuard.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 03213cb31364059c331c65ce16ba3356
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

froid_loop/data/plugins/unity/unity_assets/_folders/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3edfe262bc470b24adffcffcbeb3ff11
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

froid_loop/data/plugins/unity/unity_assets/_folders/FroidLoop.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9f46d91abc0bd668334c07a3ce41e1d2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant: