Integrate typed goal refusals and retained queue controls

src/toad/acp/agent_controller.py

@@ -21,7 +21,6 @@
     encode_request,
 )
 from agent_comms.acp_failure import ACPFailure, RequestFailure
-from agent_comms.coordination_errors import Refused
 from agent_comms.runtime import RuntimeConnection, socket_path
 from agent_comms.transcripts import TranscriptReadIdentity
 from agent_comms.order_tools import InputDeliveryRead
@@ -411,8 +410,6 @@ def resolve():
             result = await proxy.request(method, **params)
             self.require_owner(coordination, authority)
             return result
-        except (RuntimeError, Refused) as error:
-            raise ValueError(str(error)) from error
         finally:
             await proxy.close()
 

src/toad/block_navigation.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
+from collections.abc import Iterable
 from functools import cached_property
 from typing import TYPE_CHECKING, Callable, ClassVar, cast
 
@@ -15,6 +16,7 @@
 
 from toad.block_content import BlockContent
 from toad.frame_presentation import AnimationEffects
+from toad.notification_status import MessageQueueEntry
 from toad.widgets.presentation_window import NewerEnd, OlderEnd, PageEnd
 
 if TYPE_CHECKING:
@@ -402,6 +404,10 @@ def notification_identity_for(self, references: frozenset[MessageReference]) ->
         """Live entries have no captured BUS display cut; source rows override with theirs."""
         return NoDisplaySelection()
 
+    def queue_entries(self) -> Iterable[MessageQueueEntry]:
+        """Live entries supply no captured BUS delivery rows; source rows override with theirs."""
+        return ()
+
     @cached_property
     def block_cursor(self) -> BlockCursor:
         return AtomicBlockCursor(self)

src/toad/conversation_submission.py

@@ -23,7 +23,7 @@
 from toad.command_catalog import CommandCatalog
 from toad.acp.agent import Agent
 from toad.acp.queue_attachment import QueueActionRefused
-from toad.submission_queue import QueueEvidence
+from toad.submission_queue import QueueEvidence, QueueSource
 from toad.core.input_events import UserInputSubmitted
 from toad.core_event_carrier import CoreEventMessage
 from toad.input_decision import InputDecision, InputRefused
@@ -334,10 +334,11 @@ def reset(self):
         self.publish_pending()
 
     def send_now(self):
-        source = self.queue_source
+        source = self.view.queue_source
+        presentation = self.view.agent_binding.presentation
         return self.view.run_worker(
-            partial(self._send_now, source, self.view.agent_binding.presentation,
-                    source.queue_scope(self.view.agent_binding.presentation)),
+            partial(self._send_now, source, presentation,
+                    source.queue_scope(presentation)),
             group="send-queued-now", exclusive=True,
         )
 

src/toad/goal_interaction.py

@@ -5,6 +5,8 @@
 from typing import ClassVar, TYPE_CHECKING
 from weakref import ref
 
+from agent_comms.coordination_errors import Refused
+from agent_comms.errors import GoalRefused
 from agent_comms.nominal.declared_family import DeclaredFamily
 from agent_comms.goal_actions import ClearGoalAction, GoalAction
 from agent_comms.goal_presentation import ControlledExecution, GoalExecution
@@ -103,7 +105,7 @@ async def apply(cls, session):
 
         async def save(text: str) -> None:
             if not session.owns(agent):
-                raise ValueError("The goal presentation changed; reopen its editor.")
+                raise GoalRefused("The goal presentation changed; reopen its editor.")
             await session.write(agent, agent.edit_goal(goal, text))
 
         observed = await view.app.preparation.run_thread(view.app.coordination_access.observation.observed)
@@ -159,15 +161,18 @@ async def activate(self, action: type[GoalInteraction]) -> None:
         if not action.enabled(self):
             view.feedback.flash(view.goal_display.heading(view.goal_execution))
             return
-        await action.apply(self)
+        try:
+            await action.apply(self)
+        except Refused as error:
+            if not self.owns(agent):
+                raise
+            view.app.show_error(error, "Goal action failed")
 
     async def change(self, action: type[GoalAction], text: str = "") -> None:
         view = self.view
-        if not view.is_attached:
-            raise ValueError("The goal presentation changed; reopen its controls.")
         agent = view.agent_binding
         if not self.owns(agent):
-            raise ValueError("The goal presentation changed; reopen its controls.")
+            raise GoalRefused("The goal presentation changed; reopen its controls.")
         # The existing Agent boundary encodes the declared goal operation.
         # Goal state governs continuation, never interruption of an active turn.
         await self.write(agent, agent.update_goal(action, text))
@@ -177,15 +182,10 @@ async def change(self, action: type[GoalAction], text: str = "") -> None:
     async def write(self, agent, operation):
         """Every write settles by reading the owner, including rejected writes."""
         try:
-            try:
-                return await operation
-            finally:
-                if self.owns(agent):
-                    await self.view.goal_observation.refresh()
-        except (OSError, ValueError) as error:
+            return await operation
+        finally:
             if self.owns(agent):
-                raise ValueError(self.view.goal_display.action_failure(error)) from error
-            raise
+                await self.view.goal_observation.refresh()
 
     def close(self) -> None:
         modal = self.modal

src/toad/screens/goal_details.py

@@ -1,23 +1,18 @@
 """A full-height, scrollable projection of a persistent goal."""
-from toad.core_event_carrier import CoreEventReceiver, CoreEventMessage
-from metaclass_registry.mro_dispatch import handles
-
 from datetime import datetime
 
 from agent_comms.goal_history import RecordedGoalHistory
 from textual.app import ComposeResult
 from textual.containers import Vertical, VerticalScroll
-from toad.screens.modal import DismissibleScreen
+from toad.screens.source_modal import SourceModal
 from toad.widget_actions import DismissAction
 from textual.widgets import Button, Static
 
-from toad.navigation_target import SelectTarget
 from toad.goal_interaction import GoalSession
-from toad.project_path_owner import ProjectPathOwner
 from toad.widgets.goal_text import GoalText
 
 
-class GoalDetails(CoreEventReceiver, ProjectPathOwner, DismissibleScreen[None]):
+class GoalDetails(SourceModal):
     AUTO_FOCUS = "#goal-document"
     DEFAULT_CSS = """
     GoalDetails { align: center middle; background: $background 40%; }
@@ -37,16 +32,8 @@ def __init__(self, source: GoalSession, *, history: RecordedGoalHistory):
         self.failures = history.failures
 
     @property
-    def project_root(self):
-        return ProjectPathOwner.containing(self.source.view).project_root
-
-    @property
-    def coordination_root(self):
-        return ProjectPathOwner.containing(self.source.view).coordination_root
-
-    @property
-    def link_context_events(self):
-        return ProjectPathOwner.containing(self.source.view).link_context_events
+    def source_view(self):
+        return self.source.view
 
     @property
     def goal_display(self):
@@ -109,9 +96,3 @@ def _update_current(self) -> None:
         progress = self.query_one("#goal-current-progress", GoalText)
         progress.update_goal_text(f"Progress: {goal.progress}")
         progress.display = goal.shows_progress
-
-    @handles(SelectTarget)
-    def open_target(self, event: SelectTarget, message: CoreEventMessage) -> None:
-        message.stop()
-        self.dismiss(None)
-        self.source.view.publish_core(event)

src/toad/screens/goal_edit.py

@@ -80,7 +80,7 @@ async def save(self, text: str) -> None:
         save_button.disabled = True
         try:
             await self.on_save(text.strip())
-        except (Refused, ValueError) as error:
+        except Refused as error:
             self.query_one("#goal-edit-error", Static).update(str(error))
         else:
             self.dismiss(text.strip())

src/toad/screens/queue.py

@@ -1,4 +1,5 @@
 """Inspect the captured queue source through the actual conversation view."""
+from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
 
@@ -11,13 +12,12 @@
 
 from toad.acp.queue_attachment import QueueActionRefused
 from toad.agent_presentation import AgentPresentation
+from toad.conversation_submission import ConversationSubmissions
 from toad.line_blocks import SpanColumns
-from toad.screens.modal import DismissibleScreen
-from toad.submission_queue import QueueEvidence, QueueSource
+from toad.screens.source_modal import SourceModal
 from toad.widgets.tool_content import ToolContent
 
-
-class QueueInspection(DismissibleScreen[None]):
+class QueueInspection(SourceModal):
     """One screen captures the source, presentation and scope it actually displays."""
 
     DEFAULT_CSS = """
@@ -28,11 +28,16 @@
     QueueInspection #queue-error { height: auto; color: $error; }
     """
 
-    def __init__(self, source: QueueSource, evidence: QueueEvidence, changed: Callable[[], None]) -> None:
+    def __init__(self, submissions: ConversationSubmissions) -> None:
         super().__init__()
-        self.source, self.evidence = source, evidence
-        self.scope = source.queue_scope(evidence.presentation)
-        self.changed = changed
+        self.submissions = submissions
+        self.source = submissions.view.queue_source
+        self.evidence = submissions.queue_evidence
+        self.scope = self.source.queue_scope(self.evidence.presentation)
+
+    @property
+    def source_view(self):
+        return self.submissions.view
 
     def compose(self) -> ComposeResult:
         with Vertical():
@@ -55,7 +60,7 @@
         except (QueueActionRefused, RequestError) as error:
             self.query_one("#queue-error", Static).update(str(error))
             return
-        self.changed()
+        self.submissions.publish_pending()
         self.dismiss()
 
     @on(Button.Pressed, "#queue-send-now")

src/toad/screens/source_modal.py

@@ -0,0 +1,35 @@
+"""Rich modals retain their source's project and navigation capabilities."""
+from __future__ import annotations
+
+from abc import abstractmethod
+
+from metaclass_registry.mro_dispatch import handles
+from toad.core_event_carrier import CoreEventMessage, CoreEventReceiver
+from toad.navigation_target import SelectTarget
+from toad.project_path_owner import ProjectPathOwner
+from toad.screens.modal import DismissibleScreen
+
+class SourceModal(CoreEventReceiver, ProjectPathOwner, DismissibleScreen[None]):
+    """Rich modal content keeps the original view's project and navigation."""
+
+    @property
+    @abstractmethod
+    def source_view(self) -> CoreEventReceiver: ...
+
+    @property
+    def project_root(self):
+        return ProjectPathOwner.containing(self.source_view).project_root
+
+    @property
+    def coordination_root(self):
+        return ProjectPathOwner.containing(self.source_view).coordination_root
+
+    @property
+    def link_context_events(self):
+        return ProjectPathOwner.containing(self.source_view).link_context_events
+
+    @handles(SelectTarget)
+    def open_target(self, event: SelectTarget, message: CoreEventMessage) -> None:
+        message.stop()
+        self.dismiss(None)
+        self.source_view.publish_core(event)

src/toad/submission_queue.py

@@ -13,9 +13,9 @@
 
 from toad.acp.queue_attachment import QueueActionRefused
 from toad.agent_presentation import AgentPresentation
+from toad.block_navigation import ConversationEntry
 from toad.line_blocks import MutedRole, Span
 from toad.notification_status import DetailLines, MessageQueueEntry
-from toad.widgets.message_notifications import SourceNotifications
 
 
 @dataclass(frozen=True)
@@ -25,7 +25,7 @@ class QueueEvidence:
     presentation: AgentPresentation
     delivering: tuple[str, ...]
     transport: str
-    read_targets: Callable[[], tuple[SourceNotifications, ...]]
+    read_targets: Callable[[], tuple[ConversationEntry, ...]]
 
     @cached_property
     def entries(self) -> tuple[MessageQueueEntry, ...]:

src/toad/toad.tcss

@@ -148,6 +148,15 @@ HelpPanel {
 
 
 
+/* Notifications reserve their own row instead of owning clicks over the editor. */
+ToastRack {
+    layer: default;
+    dock: none;
+    split: bottom;
+    max-height: 25vh;
+    margin-bottom: 0;
+}
+
 Toast {    
     margin: 0 0;
     padding: 0 1;

src/toad/widgets/conversation.py

@@ -1693,8 +1693,7 @@ def queue_observation_changed(self, event: QueueEvidenceChanged) -> None:
         self.queue_evidence_changed()
 
     def open_queue_menu(self) -> None:
-        self.app.push_screen(QueueInspection(
-            self.queue_source, self.submissions.queue_evidence, self.submissions.publish_pending))
+        self.app.push_screen(QueueInspection(self.submissions))
 
     @handles(PreferenceChanged)
     async def _settings_changed(self, event: PreferenceChanged) -> None:

src/toad/widgets/message_notifications.py

@@ -11,10 +11,12 @@
 from textual.content import Content
 from textual.widgets import Collapsible
 
+from agent_comms.maintenance_barrier import MaintenanceHeldError
 from agent_comms.notification_reads import LiveNotificationRead
 from agent_comms.ui_model.observation import ReadNotifications
 from agent_comms.read_basis import DisplayIdentity, NoDisplaySelection
 from agent_comms.message_reference import MessageReference
+from toad.app_node import ToadNode
 from toad.messages import QueueEvidenceChanged
 
 from toad.notification_status import (
@@ -93,11 +95,17 @@ def start(self, marker: VisibleReadMarking) -> None:
 class ReadWork(PaintedRead):
     work: Awaitable[None]
 
+    async def run(self, marker: VisibleReadMarking) -> None:
+        try:
+            await self.work
+        except MaintenanceHeldError as error:
+            marker.app.show_error(error, "Read not marked", severity="warning")
+
     def start(self, marker: VisibleReadMarking) -> None:
-        marker._read_worker = marker.run_worker(self.work, group="painted-read")
+        marker._read_worker = marker.run_worker(self.run(marker), group="painted-read")
 
 
-class VisibleReadMarking:
+class VisibleReadMarking(ToadNode):
     """One painted-read operation at a time, for pagers and native/CLI sessions."""
 
     def __init__(self, *args, **kwargs):

src/toad/widgets/outgoing_message.py

@@ -14,7 +14,7 @@
 from toad.widgets.message_notifications import MessageNotifications
 from toad.widgets.linked_rows import MessageRowBlock
 from toad.widgets.message_row_owner import MessageRowOwner
-from toad.notification_status import CheckedNotifications, NotificationStatus
+from toad.notification_status import CheckedNotifications, MessageQueueEntry, NotificationStatus
 from toad.widgets.committed_presentation import CommitParticipant, OutgoingMessageClaim
 
 
@@ -40,6 +40,9 @@ def message_reference(self):
     def notification_targets(self):
         return (self,) if self.message_dividers and self.display else ()
 
+    def queue_entries(self) -> tuple[MessageQueueEntry, ...]:
+        return (MessageQueueEntry(self.message_reference, self.query_one(MessageNotifications).status),)
+
     @property
     def notification_references(self):
         return (self.message_reference,)

tests/model/test_goal_display.py

@@ -10,7 +10,7 @@ def test_each_goal_state_answers_visibility_control_and_snapshot():
     goal = published_goal("Keep the objective", "display-state")
     idle = IdleGoalExecution()
     for state, visible, enabled, snapshot in (
-        (NoGoal(), False, False, NoGoal()),  # nothing to control: Core answers a control with "This goal has been cleared."
+        (NoGoal(), False, False, NoGoal()),
         (goal, True, True, goal),
         (GoalUnavailable(goal), True, False, goal),
         (GoalUnavailable(NoGoal()), True, False, NoGoal()),
@@ -39,9 +39,6 @@ def heading(self, execution):
         def standby(self, execution):
             return False
 
-        def action_failure(self, error):
-            return str(error)
-
     state = OwnerReconnecting()
     assert state.visible
     assert not state.can_control