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

{haybale_haystack-0.2.4 → haybale_haystack-0.3.1}/.gitignore

@@ -220,6 +220,8 @@ packages/haywire-core/src/haywire/_baked_docs/*
 # Haywire project config (user-local, not repo state)
 .haywire/
 
-# Local symlink to external dev project (machine-specific path)
+# Local symlinks to external dev projects (machine-specific paths)
 barn/haybale-visiongraph
+barn/haybale-spandrel
 
+assets/*

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: haybale-haystack
-Version: 0.2.4
+Version: 0.3.1
 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.1
+Requires-Dist: haybale-studio>=0.3.1
+Requires-Dist: haywire-core>=0.3.1
+Requires-Dist: nicegui>=3.18.0
 Requires-Dist: toml>=0.10.2

{haybale_haystack-0.2.4 → haybale_haystack-0.3.1}/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.1}/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.1}/haybale_haystack/QUICKREF.md

@@ -1,7 +1,7 @@
-# haybale-haystack — component index (v0.2.4)
+# haybale-haystack — component index (v0.3.1)
 
 ## 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.1/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.1}/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.1}/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.1/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.1}/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.1}/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.1}/haybale_haystack/editors/haystack_editor.py

@@ -6,7 +6,9 @@ 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.components.popup import Popup
 from haywire.ui.editor import BaseEditor, SlotName, editor
 from haywire.core.session import (
     IAppState,
@@ -19,29 +21,41 @@ 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.notices import GraphNotice, GraphNoticesChanged
 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):
     """
@@ -63,12 +77,16 @@ class HaystackEditor(BaseEditor):
     def __init__(self, wrapper):
         super().__init__(wrapper)
         self._list_container = None
+        self._dismissed_notices: set[tuple[str, str]] = set()
+        self._notice_popups: list[Popup] = []
 
     # ------------------------------------------------------------------
     # Signal-bus subscriptions / draw
     # ------------------------------------------------------------------
 
-    @redraw_on(ActiveGraphMoved, GraphDataMutated, HaystackReloaded)
+    @redraw_on(
+        ActiveGraphMoved, GraphDataMutated, GraphUnsavedChanged, HaystackReloaded, GraphNoticesChanged
+    )
     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 +103,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 +158,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 +173,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(
@@ -199,11 +231,12 @@ class HaystackEditor(BaseEditor):
         if self._list_container is None:
             return
         self._list_container.clear()
+        self._delete_notice_popups()
 
         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 +245,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 +254,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 +297,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,
@@ -277,6 +316,8 @@ class HaystackEditor(BaseEditor):
                     on_click=lambda eid=eid: self._on_start_execution(eid, context),
                 )
 
+            self._render_notices(eid, context)
+
             # Dirty dot — amber when unsaved, hidden when clean
             if is_unsaved:
                 ui.element("div").classes("w-2 h-2 rounded-full flex-shrink-0 bg-amber-400").style(
@@ -293,7 +334,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 +342,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")
@@ -332,6 +373,89 @@ class HaystackEditor(BaseEditor):
                             on_click=lambda eid=eid: self._on_entry_delete(eid, context),
                         )
 
+    # ------------------------------------------------------------------
+    # graph notices
+    # ------------------------------------------------------------------
+
+    def _delete_notice_popups(self) -> None:
+        for popup in self._notice_popups:
+            popup.delete()
+        self._notice_popups.clear()
+
+    def _visible_notices(self, binding_id: str, context: "SessionContext") -> list[GraphNotice]:
+        """Return the notices on a graph that this editor has not dismissed."""
+        posted = list(context.app_data[GraphAppState].notices(binding_id))
+        return [n for n in posted if (binding_id, n.key) not in self._dismissed_notices]
+
+    def _render_notices(self, binding_id: str, context: "SessionContext") -> None:
+        """Draw the notice icon, tinted warning, and the popup listing each notice and its action."""
+        notices = self._visible_notices(binding_id, context)
+        if not notices:
+            return
+        popup = Popup(
+            title="Notices", width="26rem", closable=True, backdrop_click_close=True, escape_close=True
+        )
+        self._notice_popups.append(popup)
+        with popup:
+            for notice in notices:
+                self._render_notice_line(binding_id, notice, popup, context)
+        icons = {n.icon for n in notices}
+        shared = icons.pop() if len(icons) == 1 else None
+        btn = ui.button().props("flat round dense size=xs data-hw-mark=graph-notice")
+        with btn:
+            # The icon carries the opt-out: the .hw-panel dim rule beats an inline colour.
+            ui.icon(shared or hui.icon.notice).classes("hw-use-props-color hw-text-warning")
+        btn.tooltip("\n".join(n.text for n in notices))
+        btn.on("click.stop", popup.open)
+
+    def _render_notice_line(
+        self, binding_id: str, notice: GraphNotice, popup: Popup, context: "SessionContext"
+    ) -> None:
+        with (
+            ui.column()
+            .classes("w-full gap-1 p-2 rounded")
+            .style(
+                "border-left: 3px solid var(--hw-warning);"
+                " background: color-mix(in srgb, var(--hw-warning) 12%, transparent)"
+            )
+        ):
+            with ui.row().classes("w-full items-start gap-2 no-wrap"):
+                ui.icon(notice.icon or hui.icon.notice, size="sm").classes(
+                    "hw-use-props-color hw-text-warning"
+                ).props("data-hw-mark=graph-notice-line-icon")
+                ui.label(notice.text).classes("flex-1 min-w-0 text-sm")
+                if notice.dismissable:
+                    hui.icon_action(
+                        hui.icon.close,
+                        tooltip="Dismiss",
+                        on_click=lambda k=notice.key: self._dismiss_notice(binding_id, k, context),
+                    )
+            if notice.action is not None and notice.action_label and context.can_access(notice.requires):
+                with ui.row().classes("w-full justify-end"):
+                    hui.button(
+                        notice.action_label,
+                        on_click=lambda n=notice: self._run_notice_action(n, popup, context),
+                    ).props("data-hw-mark=graph-notice-action").classes("w-auto")
+
+    def _run_notice_action(self, notice: GraphNotice, popup: Popup, context: "SessionContext") -> None:
+        """Run a notice's action with this session's context, then close the popup."""
+        client = ui.context.client
+        popup.close()
+        if notice.action is None:
+            return
+        try:
+            notice.action(context)
+        except Exception as exc:
+            logger.warning(f"HaystackEditor: notice action {notice.key} failed: {exc}")
+            with client:
+                ui.notify(f"{notice.action_label or 'Action'} failed: {exc}", type="negative")
+
+    def _dismiss_notice(self, binding_id: str, key: str, context: "SessionContext") -> None:
+        """Hide a notice in this editor instance only."""
+        self._dismissed_notices.add((binding_id, key))
+        # The list redraw deletes the popup (and this button's slot) holding the handler.
+        self._render_list(context)
+
     # ------------------------------------------------------------------
     # per-entry file actions
     # ------------------------------------------------------------------
@@ -352,6 +476,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 +520,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 +546,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 +567,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 +632,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 +688,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 +727,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 +743,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 +757,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 +787,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 +815,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 +881,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 +942,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")
@@ -837,4 +991,5 @@ class HaystackEditor(BaseEditor):
     # ------------------------------------------------------------------
 
     def cleanup(self) -> None:
+        self._delete_notice_popups()
         self._list_container = None