haybale-haystack 0.2.4__tar.gz → 0.3.0__tar.gz

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: haybale-haystack
-Version: 0.2.4
+Version: 0.3.0
 Summary: File-centric multi-graph manager
 License: MIT
 Keywords: graph-management
 Requires-Python: >=3.12
-Requires-Dist: haybale-graph-editor>=0.2.4
-Requires-Dist: haybale-studio>=0.2.4
-Requires-Dist: haywire-core>=0.2.4
-Requires-Dist: nicegui>=3.12.1
+Requires-Dist: haybale-graph-editor>=0.3.0
+Requires-Dist: haybale-studio>=0.3.0
+Requires-Dist: haywire-core>=0.3.0
+Requires-Dist: nicegui>=3.18.0
 Requires-Dist: toml>=0.10.2

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/README.md

@@ -7,7 +7,7 @@
 File-centric multi-graph manager
 
 ## Settings
-- **Haystack** — 
+- **Haystack** — Per-workspace settings for haystack scalars.
 
 ## Farmhands
 - **Close graph** — Close an open graph entry. NEVER deletes the file on disk.
@@ -21,12 +21,13 @@ File-centric multi-graph manager
 - **Stop graph** — Stop a running graph (bounded grace, then teardown).
 
 ## States
-- **Haystack State** — 
+- **Haystack State** — In-memory registry of open graphs, one entry per file path.
 
 ## Panels
-- **Edit Macro** — 
-- **Graph Settings** — 
-- **Load into Haystack** — 
+- **Edit Macro** — Open the document behind a macro placement, in its own editor tab.
+- **Graph Settings** — Renders the GraphRunSettings for the currently active graph.
+- **Load into Haystack** — Load a .haywire graph file into the Haystack (does not open an editor tab).
+- **Update Macro** — Send a modified instance's changes back to the macro it came from.
 
 ## Editors
 - **Haystack** — All open graphs. Click to switch; "+" to create a new graph.

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/OVERVIEW.md

@@ -3,7 +3,7 @@
 File-centric multi-graph manager
 
 ## Settings
-- **Haystack** — 
+- **Haystack** — Per-workspace settings for haystack scalars.
 
 ## Farmhands
 - **Close graph** — Close an open graph entry. NEVER deletes the file on disk.
@@ -17,12 +17,13 @@ File-centric multi-graph manager
 - **Stop graph** — Stop a running graph (bounded grace, then teardown).
 
 ## States
-- **Haystack State** — 
+- **Haystack State** — In-memory registry of open graphs, one entry per file path.
 
 ## Panels
-- **Edit Macro** — 
-- **Graph Settings** — 
-- **Load into Haystack** — 
+- **Edit Macro** — Open the document behind a macro placement, in its own editor tab.
+- **Graph Settings** — Renders the GraphRunSettings for the currently active graph.
+- **Load into Haystack** — Load a .haywire graph file into the Haystack (does not open an editor tab).
+- **Update Macro** — Send a modified instance's changes back to the macro it came from.
 
 ## Editors
 - **Haystack** — All open graphs. Click to switch; "+" to create a new graph.

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/QUICKREF.md

@@ -1,7 +1,7 @@
-# haybale-haystack — component index (v0.2.4)
+# haybale-haystack — component index (v0.3.0)
 
 ## setting
-- `haybale-haystack:setting:HaystackSettings` — Haystack — 
+- `haybale-haystack:setting:HaystackSettings` — Haystack — Per-workspace settings for haystack scalars.
 
 ## farmhand
 - `haybale-haystack:farmhand:close_graph` — Close graph — Close an open graph entry. NEVER deletes the file on disk.
@@ -15,12 +15,13 @@
 - `haybale-haystack:farmhand:stop_graph` — Stop graph — Stop a running graph (bounded grace, then teardown).
 
 ## state
-- `haybale-haystack:state:HaystackState` — Haystack State — 
+- `haybale-haystack:state:HaystackState` — Haystack State — In-memory registry of open graphs, one entry per file path.
 
 ## panel
-- `haybale-haystack:panel:EditMacroMenuPanel` — Edit Macro — 
-- `haybale-haystack:panel:GraphRunSettingsPanel` — Graph Settings — 
-- `haybale-haystack:panel:OpenInHaystackMenuPanel` — Load into Haystack — 
+- `haybale-haystack:panel:EditMacroMenuPanel` — Edit Macro — Open the document behind a macro placement, in its own editor tab.
+- `haybale-haystack:panel:GraphRunSettingsPanel` — Graph Settings — Renders the GraphRunSettings for the currently active graph.
+- `haybale-haystack:panel:OpenInHaystackMenuPanel` — Load into Haystack — Load a .haywire graph file into the Haystack (does not open an editor tab).
+- `haybale-haystack:panel:UpdateMacroMenuPanel` — Update Macro — Send a modified instance's changes back to the macro it came from.
 
 ## editor
 - `haybale-haystack:editor:HaystackEditor` — Haystack — All open graphs. Click to switch; "+" to create a new graph.

haybale_haystack-0.3.0/haybale_haystack/docs/haybale-haystack.panel.EditMacroMenuPanel.md

@@ -0,0 +1,18 @@
+# Edit Macro
+
+`haybale-haystack:panel:EditMacroMenuPanel` · kind: panel
+
+Open the document behind a macro placement, in its own editor tab.
+
+## Details
+
+- **surface**: `selection-macro`
+- **order**: `10`
+
+## Notes
+
+Open the document behind a macro placement, in its own editor tab.
+
+Only visible on a placement. Its interior is runtime state rebuilt from the
+template, so it cannot be edited in place; this row opens the document that
+can.

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/docs/haybale-haystack.panel.GraphRunSettingsPanel.md

@@ -2,6 +2,8 @@
 
 `haybale-haystack:panel:GraphRunSettingsPanel` · kind: panel
 
+Renders the GraphRunSettings for the currently active graph.
+
 ## Details
 
 - **surface**: `execution`

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/docs/haybale-haystack.panel.OpenInHaystackMenuPanel.md

@@ -2,6 +2,8 @@
 
 `haybale-haystack:panel:OpenInHaystackMenuPanel` · kind: panel
 
+Load a .haywire graph file into the Haystack (does not open an editor tab).
+
 ## Details
 
 - **surface**: `file`

haybale_haystack-0.3.0/haybale_haystack/docs/haybale-haystack.panel.UpdateMacroMenuPanel.md

@@ -0,0 +1,21 @@
+# Update Macro
+
+`haybale-haystack:panel:UpdateMacroMenuPanel` · kind: panel
+
+Send a modified instance's changes back to the macro it came from.
+
+## Details
+
+- **surface**: `selection-macro`
+- **order**: `30`
+
+## Notes
+
+Send a modified instance's changes back to the macro it came from.
+
+Only visible on a Group that was detached from a macro. The card becomes a
+placement of that macro again, and the macro opens in its own tab with the
+instance's contents, unsaved. Saving it updates every placement.
+
+Greyed out when the macro is not installed, cannot be edited in place, or
+has unsaved edits in its tab.

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/docs/haybale-haystack.setting.HaystackSettings.md

@@ -2,6 +2,8 @@
 
 `haybale-haystack:setting:HaystackSettings` · kind: setting
 
+Per-workspace settings for haystack scalars.
+
 ## Notes
 
 Per-workspace settings for haystack scalars.

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/docs/haybale-haystack.state.HaystackState.md

@@ -2,6 +2,8 @@
 
 `haybale-haystack:state:HaystackState` · kind: state
 
+In-memory registry of open graphs, one entry per file path.
+
 ## Notes
 
 In-memory registry of open graphs (one entry per file path)

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/editors/haystack_editor.py

@@ -6,6 +6,7 @@ from typing import Optional
 
 from nicegui import ui
 
+from haywire.core.access import AccessTier, LevelMode
 from haywire.ui import elements as hui
 from haywire.ui.editor import BaseEditor, SlotName, editor
 from haywire.core.session import (
@@ -19,29 +20,40 @@ from haywire.core.signals import (
     BroadcastClose,
     Close,
     GraphDataMutated,
+    GraphUnsavedChanged,
     Reveal,
     RevealGraphInstance,
+    Save,
 )
 from haywire.ui.modals import confirm_modal, pick_modal, rename_modal
 
 from haybale_graph_editor.state.edit_state import EditState
 from haybale_graph_editor.state.graph_app_state import GraphAppState
-from haybale_graph_editor.editors.graph_editor import GraphEditor
+from haybale_graph_editor.editors.graph_editor import GraphEditor, definition_path
 from haybale_graph_editor.editors.graph_save_as import open_graph_save_as_dialog
 
-from ..signals import HaystackReloaded, HaystackTeardown
-from ..state.haystack_state import HaystackState
-from ..graph_entry import EntryKind, GraphEntry
+from haybale_haystack.signals import HaystackReloaded, HaystackTeardown
+from haybale_haystack.state.haystack_state import HaystackState
+from haybale_haystack.graph_entry import EntryKind, GraphEntry
 
 logger = logging.getLogger(__name__)
 
 
+def _refused(context: "SessionContext", required: AccessTier, action: str) -> bool:
+    """Return whether the principal lacks ``required``, telling them ``"<action> needs <tier> access"``."""
+    if context.can_access(required):
+        return False
+    ui.notify(f"{action} needs {required.value} access", type="warning", position="top-right")
+    return True
+
+
 @editor(
     label="Haystack",
     icon=hui.icon.haystack,
     default_slot=SlotName.ACTION,
     description='All open graphs. Click to switch; "+" to create a new graph.',
     order=20,
+    requires=AccessTier.VIEW,
 )
 class HaystackEditor(BaseEditor):
     """
@@ -68,7 +80,7 @@ class HaystackEditor(BaseEditor):
     # Signal-bus subscriptions / draw
     # ------------------------------------------------------------------
 
-    @redraw_on(ActiveGraphMoved, GraphDataMutated, HaystackReloaded)
+    @redraw_on(ActiveGraphMoved, GraphDataMutated, GraphUnsavedChanged, HaystackReloaded)
     def _refresh_on_state_move(self, context: "SessionContext", event) -> None:
         """Empty body — the decorator triggers ``wrapper.redraw()`` after
         this returns, which re-runs ``draw`` and ``_render_list``."""
@@ -85,25 +97,36 @@ class HaystackEditor(BaseEditor):
         """
         self._on_haystack_teardown(context, event)
 
+    @react_on(Save)
+    def _on_save(self, context: "SessionContext", event: Save) -> None:
+        """Save the loaded haystack in place, or ask for a name when none is loaded."""
+        self._on_save_haystack_in_place(context)
+
     @react_on(RevealGraphInstance)
     def _on_reveal_graph_instance_reopen(
         self, context: "SessionContext", event: "RevealGraphInstance"
     ) -> None:
-        """Reopen a loaded-but-tabless graph so it can receive future selects.
+        """Bring forward the tab of the document holding ``event.graph_id``, opening it if needed.
 
-        Accepted gap: this only re-opens the tab via Reveal (idempotent —
-        find-or-add — even if a GraphEditor in this session also matched
-        and already self-revealed). It does NOT retroactively select the
-        node/edge in the freshly-constructed GraphEditor, which was not
-        alive to receive the original signal.
+        The graph may be the document's own or a Group or macro placement interior
+        in it, open or not. A tab this opens carries out the reveal when it draws
+        (``EditState.pending_reveal``); a tab already open carries it out itself.
         """
         graph_app_state = context.app_data[GraphAppState]
         for container in graph_app_state.all_containers():
-            if container.editor.graph.graph_id == event.graph_id:
+            graph = container.editor.graph
+            if graph.graph_id != event.graph_id and definition_path(graph, event.graph_id) is None:
+                continue
+            edit_state = context.data[EditState]
+            edit_state.pending_reveal = event
+            try:
                 context.session.publish(
                     Reveal(editor=GraphEditor, binding_id=container.binding_id, label=container.display_name)
                 )
-                return
+            finally:
+                # A tab already open draws nothing, so the reveal must not wait for a later draw.
+                edit_state.pending_reveal = None
+            return
 
     def _on_haystack_teardown(self, context: "SessionContext", signal: "HaystackTeardown") -> None:
         """Translate the teardown fact into local tab-close lifecycle commands.
@@ -129,7 +152,7 @@ class HaystackEditor(BaseEditor):
 
     # No on_focus override needed: @redraw_on fires regardless of active-tab
     # state, so backgrounded HaystackEditor instances stay current with
-    # ActiveGraphMoved / GraphDataMutated / HaystackReloaded.
+    # ActiveGraphMoved / GraphDataMutated / GraphUnsavedChanged / HaystackReloaded.
 
     def draw(self, context: "SessionContext", container: ui.element) -> None:
         with container:
@@ -144,13 +167,16 @@ class HaystackEditor(BaseEditor):
     # ------------------------------------------------------------------
 
     def _render_header(self, context: "SessionContext") -> None:
+        """Draw the title, unsaved dot and haystack actions; the actions are drawn only for edit."""
         title = self._get_active_haystack_name(context) or "Haystacks"
         hs = context.app_data[HaystackState]
         is_dirty = hs.is_haystack_dirty
-        # The dirty dot (when is_dirty=True) is rendered by panel_header
+        # The dirty dot (when is_dirty=True) is rendered by slot_header
         # itself between the icon and the title — we only add the save
         # icon and the overflow menu on the action side here.
-        with hui.panel_header(title, icon=hui.icon.haystack, is_dirty=is_dirty):
+        with hui.slot_header(title, icon=hui.icon.haystack, is_dirty=is_dirty):
+            if not context.can_edit():
+                return
             # Save icon — paired with the dirty dot; only when dirty.
             if is_dirty:
                 hui.icon_action(
@@ -203,7 +229,7 @@ class HaystackEditor(BaseEditor):
         app = context.app
         if app is None:
             with self._list_container:
-                ui.label("Graph manager not available").classes("text-xs hw-text-dim p-2 italic")
+                hui.hint("Graph manager not available").classes("p-2 italic")
             return
 
         hs = context.app_data[HaystackState]
@@ -212,7 +238,7 @@ class HaystackEditor(BaseEditor):
 
         with self._list_container:
             if not graphs:
-                ui.label("No graphs open").classes("text-xs hw-text-dim p-2 italic")
+                hui.hint("No graphs open").classes("p-2 italic")
             else:
                 for entry in graphs:
                     self._render_entry(entry, context)
@@ -221,14 +247,17 @@ class HaystackEditor(BaseEditor):
             # haystack and cannot be run, so it does not belong among the
             # entries the play controls and the TOML apply to.
             if macros:
-                ui.label("Macros").classes("text-xs hw-text-dim px-2 pt-2 pb-0.5 uppercase")
+                hui.section_label("Macros")
                 for entry in macros:
                     self._render_entry(entry, context)
 
-            self._render_add_bar(context)
+            if context.can_edit():
+                self._render_add_bar(context)
 
     def _render_entry(self, entry: "GraphEntry", context: "SessionContext") -> None:
         is_active = entry.graph is context.data[EditState].active_graph
+        can_edit = context.can_edit()
+        can_operate = context.can_access(AccessTier.OPERATE)
         is_unsaved = entry.unsaved or entry.path is None
         is_executing = entry.is_executing
 
@@ -261,9 +290,12 @@ class HaystackEditor(BaseEditor):
             # to run, so it carries its kind's icon instead of a control whose
             # only answer would be a refusal.
             if not entry.kind.is_executable():
-                ui.icon(hui.icon.node_source, size="16px").classes("hw-text-dim").tooltip(
+                ui.icon(hui.icon.macro, size="16px").classes("hw-text-dim").tooltip(
                     "A macro is run by placing it in a graph"
                 )
+            elif not can_operate:
+                # The row's execution border still shows a running graph.
+                pass
             elif is_executing:
                 hui.icon_action(
                     hui.icon.execution_stop,
@@ -293,7 +325,7 @@ class HaystackEditor(BaseEditor):
                     ui.label("not saved").classes("text-xs hw-text-warning-dim")
 
             # Save icon — paired with the dirty dot; only when unsaved.
-            if is_unsaved:
+            if is_unsaved and can_edit:
                 hui.icon_action(
                     hui.icon.save,
                     tooltip="Save",
@@ -301,7 +333,7 @@ class HaystackEditor(BaseEditor):
                 )
 
             # Overflow menu — hidden during execution
-            if not is_executing:
+            if can_edit and not is_executing:
                 with (
                     ui.button(icon="more_vert")
                     .props("flat round dense size=xs")
@@ -352,6 +384,9 @@ class HaystackEditor(BaseEditor):
 
     def _on_entry_save(self, binding_id: str, context: "SessionContext") -> None:
         """Save a graph; opens save-as dialog if untitled."""
+        if not context.can_edit():
+            ui.notify("Saving needs edit access", type="warning", position="top-right")
+            return
         app = context.app
         if app is None:
             ui.notify("Graph manager not available", type="warning")
@@ -393,6 +428,9 @@ class HaystackEditor(BaseEditor):
 
     def _on_entry_save_as(self, binding_id: str, context: "SessionContext") -> None:
         """Always open the save-as dialog."""
+        if not context.can_edit():
+            ui.notify("Saving needs edit access", type="warning", position="top-right")
+            return
         app = context.app
         if app is None:
             ui.notify("Graph manager not available", type="warning")
@@ -416,6 +454,8 @@ class HaystackEditor(BaseEditor):
 
     def _on_entry_rename(self, binding_id: str, context: "SessionContext") -> None:
         """Rename: inline edit for file-backed graphs, save-as for untitled."""
+        if _refused(context, AccessTier.EDIT, "Renaming"):
+            return
         entry = self._resolve_entry(binding_id, context)
         if entry is None:
             return
@@ -435,6 +475,8 @@ class HaystackEditor(BaseEditor):
         confirmation that warns about losing unsaved work. Clean entries
         get a milder confirm that calls out that the file stays on disk.
         """
+        if _refused(context, AccessTier.EDIT, "Removing"):
+            return
         entry = self._resolve_entry(binding_id, context)
         if entry is None:
             return
@@ -498,6 +540,8 @@ class HaystackEditor(BaseEditor):
             edit_state = context.data[EditState]
             edit_state.active_graph = None
             edit_state.active_graph_path = None
+            edit_state.active_route = None
+            context.level_mode = LevelMode.VIEW
             if session:
                 session.publish(ActiveGraphMoved())
 
@@ -552,6 +596,8 @@ class HaystackEditor(BaseEditor):
 
     def _on_new(self, context: "SessionContext") -> None:
         """Create a new unnamed graph and activate it."""
+        if _refused(context, AccessTier.EDIT, "A new graph"):
+            return
         app: IAppState = context.app
         session = context.session
         if app is None or session is None:
@@ -589,6 +635,8 @@ class HaystackEditor(BaseEditor):
 
     def _on_start_execution(self, binding_id: str, context: "SessionContext") -> None:
         """Start execution on a graph entry."""
+        if _refused(context, AccessTier.OPERATE, "Starting and stopping"):
+            return
         entry = self._resolve_entry(binding_id, context)
         if entry is None:
             return
@@ -603,6 +651,8 @@ class HaystackEditor(BaseEditor):
 
     def _on_stop_execution(self, binding_id: str, context: "SessionContext") -> None:
         """Stop execution on a graph entry."""
+        if _refused(context, AccessTier.OPERATE, "Starting and stopping"):
+            return
         entry = self._resolve_entry(binding_id, context)
         if entry is None:
             return
@@ -615,7 +665,10 @@ class HaystackEditor(BaseEditor):
     # ------------------------------------------------------------------
 
     def _on_save_haystack(self, context: "SessionContext") -> None:
-        """Save the current set of open graphs as a haystack ("Save As…")."""
+        """Save the current set of open graphs as a haystack ("Save As…"); refused below edit."""
+        if not context.can_edit():
+            ui.notify("Saving needs edit access", type="warning", position="top-right")
+            return
         app: IAppState = context.app
         if app is None:
             ui.notify("Graph manager not available", type="warning")
@@ -642,8 +695,11 @@ class HaystackEditor(BaseEditor):
 
         Falls through to :meth:`_on_save_haystack` (the Save-As modal) when
         no haystack is loaded — there's nothing to overwrite, so the user
-        has to name it.
+        has to name it. Refused below edit.
         """
+        if not context.can_edit():
+            ui.notify("Saving needs edit access", type="warning", position="top-right")
+            return
         active = self._get_active_haystack_name(context)
         if not active:
             self._on_save_haystack(context)
@@ -667,6 +723,8 @@ class HaystackEditor(BaseEditor):
 
     def _on_load_haystack(self, context: "SessionContext") -> None:
         """Load a haystack, replacing all currently open graphs."""
+        if _refused(context, AccessTier.EDIT, "Loading a haystack"):
+            return
         app: IAppState = context.app
         if app is None:
             ui.notify("Graph manager not available", type="warning")
@@ -731,6 +789,8 @@ class HaystackEditor(BaseEditor):
         a GraphEditor tab. The user opens it in an editor by selecting the
         new entry from the list once it appears.
         """
+        if _refused(context, AccessTier.EDIT, "Loading a graph"):
+            return
         app = context.app
         if app is None:
             ui.notify("Graph manager not available", type="warning")
@@ -790,6 +850,8 @@ class HaystackEditor(BaseEditor):
 
     def _on_rename_haystack(self, context: "SessionContext") -> None:
         """Open a modal to rename the current haystack."""
+        if _refused(context, AccessTier.EDIT, "Renaming"):
+            return
         old_name = self._get_active_haystack_name(context)
         if not old_name:
             ui.notify("No haystack is currently loaded", type="warning")

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/farmhands/graph_tools.py

@@ -59,7 +59,7 @@ def _compile_row(result) -> dict:
     "to pass to haystack_open_graph.",
     registry_id="list_graphs",
     annotations=_READ_ONLY,
-    access=AccessTier.VIEW,
+    requires=AccessTier.VIEW,
 )
 class HaystackListGraphsTool(Farmhand):
     async def run(self, ctx: FarmhandContext, limit: int = 100, offset: int = 0) -> dict:
@@ -101,7 +101,6 @@ class HaystackListGraphsTool(Farmhand):
     "graph_editor_add_node, then haystack_save_graph (it stays unsaved until you do).",
     registry_id="create_graph",
     annotations=_MUTATING,
-    access=AccessTier.EDIT,
 )
 class HaystackCreateGraphTool(Farmhand):
     async def run(self, ctx: FarmhandContext) -> dict:
@@ -126,7 +125,6 @@ class HaystackCreateGraphTool(Farmhand):
     "to see valid paths.",
     registry_id="open_graph",
     annotations=_MUTATING,
-    access=AccessTier.EDIT,
 )
 class HaystackOpenGraphTool(Farmhand):
     async def run(self, ctx: FarmhandContext, path: str) -> dict:
@@ -151,7 +149,6 @@ class HaystackOpenGraphTool(Farmhand):
     "binding_id, save_failed if the write itself fails.",
     registry_id="save_graph",
     annotations=_MUTATING,
-    access=AccessTier.EDIT,
 )
 class HaystackSaveGraphTool(Farmhand):
     async def run(self, ctx: FarmhandContext, binding_id: str, save_as: str | None = None) -> dict:
@@ -175,7 +172,6 @@ class HaystackSaveGraphTool(Farmhand):
     "binding_id, rename_failed if the rename itself fails (e.g. name collision).",
     registry_id="rename_graph",
     annotations=_MUTATING,
-    access=AccessTier.EDIT,
 )
 class HaystackRenameGraphTool(Farmhand):
     async def run(self, ctx: FarmhandContext, binding_id: str, new_name: str) -> dict:
@@ -196,7 +192,6 @@ class HaystackRenameGraphTool(Farmhand):
     "haystack_open_graph. Raises graph_not_found for an unknown binding_id.",
     registry_id="close_graph",
     annotations=_MUTATING,
-    access=AccessTier.EDIT,
 )
 class HaystackCloseGraphTool(Farmhand):
     async def run(self, ctx: FarmhandContext, binding_id: str) -> dict:
@@ -214,7 +209,7 @@ class HaystackCloseGraphTool(Farmhand):
     "when ok).",
     registry_id="compile_graph",
     annotations=_READ_ONLY,
-    access=AccessTier.VIEW,
+    requires=AccessTier.VIEW,
 )
 class HaystackCompileGraphTool(Farmhand):
     async def run(self, ctx: FarmhandContext, binding_id: str) -> dict:
@@ -231,7 +226,7 @@ class HaystackCompileGraphTool(Farmhand):
     "haystack_stop_graph when done.",
     registry_id="start_graph",
     annotations=ToolAnnotations(destructive_hint=True),
-    access=AccessTier.EDIT,
+    requires=AccessTier.OPERATE,
 )
 class HaystackStartGraphTool(Farmhand):
     async def run(self, ctx: FarmhandContext, binding_id: str) -> dict:
@@ -253,7 +248,7 @@ class HaystackStartGraphTool(Farmhand):
     "currently running.",
     registry_id="stop_graph",
     annotations=_MUTATING,
-    access=AccessTier.EDIT,
+    requires=AccessTier.OPERATE,
 )
 class HaystackStopGraphTool(Farmhand):
     async def run(self, ctx: FarmhandContext, binding_id: str) -> dict:

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/graph_entry.py

@@ -67,6 +67,11 @@ class GraphEntry(GraphContainer):
                       persisted in the haystack TOML under ``[graphs.run]``.
         kind:         Which category this entry belongs to. See
                       :class:`EntryKind`.
+        last_undo_availability: ``(can_undo, can_redo, undo_redo_count)`` as
+                      of the last validation result that changed saved state;
+                      ``None`` before the first. Lets the validation handler
+                      broadcast only when availability changes, counting an
+                      undo or redo in between as a change.
     """
 
     graph: "HaywireGraph"
@@ -77,6 +82,9 @@ class GraphEntry(GraphContainer):
     haystack: "Optional[HaystackState]" = field(default=None, repr=False)
     run_settings: GraphRunSettings = field(default_factory=GraphRunSettings)
     kind: EntryKind = EntryKind.GRAPH
+    last_undo_availability: Optional[tuple[bool, bool, int]] = field(default=None, repr=False)
+    _abandoned: list["Interpreter"] = field(default_factory=list, init=False, repr=False)
+    """Stopped Interpreters whose runner threads are still stuck in a node."""
 
     @property
     def binding_id(self) -> str:
@@ -119,6 +127,8 @@ class GraphEntry(GraphContainer):
         Returns a failed result for an entry whose :attr:`kind` is not
         executable, naming the reason: a macro document holds no EVENT node, so
         assembly would find nothing to run and the verdict would not say why.
+        Also refuses while a previous run of this graph is still stuck in a
+        node (its runner was abandoned by a stop).
         """
         if not self.kind.is_executable():
             return CompileResult(
@@ -131,6 +141,16 @@ class GraphEntry(GraphContainer):
         if self.is_executing:
             return CompileResult(ok=True, error=None)
 
+        self._abandoned = [interp for interp in self._abandoned if interp.has_abandoned_runners()]
+        if self._abandoned:
+            return CompileResult(
+                ok=False,
+                error=(
+                    f"a previous run of '{self.display_name}' is still stuck in a node; "
+                    "wait for it to finish or restart the studio"
+                ),
+            )
+
         library_state_container = get_library_state_container()
         interpreter = Interpreter(library_state_container=library_state_container)
         try:
@@ -169,9 +189,14 @@ class GraphEntry(GraphContainer):
             self.interpreter.stop_execution()
         except Exception as e:
             logger.warning(f"Error stopping execution on '{self.display_name}': {e}")
-        self.interpreter = None
+        self._retire_interpreter()
         logger.info(f"Execution stopped for graph '{self.display_name}'")
 
+    def _retire_interpreter(self) -> None:
+        interpreter, self.interpreter = self.interpreter, None
+        if interpreter is not None and interpreter.has_abandoned_runners():
+            self._abandoned.append(interpreter)
+
     def save(self, save_as: "Optional[Path]" = None) -> "Optional[str]":
         """Persist this entry via its owning HaystackState.
 

{haybale_haystack-0.2.4 → haybale_haystack-0.3.0}/haybale_haystack/haybale.toml

@@ -3,7 +3,7 @@
 # Edited in the studio's library overview — no reinstall, no reload.
 
 name = "haybale-haystack"
-version = "0.2.4"
+version = "0.3.0"
 label = "Haystack"
 description = "File-centric multi-graph manager"
 tags = ["graph-management"]

haybale_haystack-0.3.0/haybale_haystack/panels/__init__.py

@@ -0,0 +1,11 @@
+from haybale_haystack.panels.file_browser.menu.file import OpenInHaystackMenuPanel
+from haybale_haystack.panels.properties.introspect.graph_run_settings_panel import GraphRunSettingsPanel
+
+# Backwards-compat alias
+OpenInHaystackPanel = OpenInHaystackMenuPanel
+
+__all__ = [
+    "GraphRunSettingsPanel",
+    "OpenInHaystackMenuPanel",
+    "OpenInHaystackPanel",
+]