@@ -4,8 +4,18 @@
 
 Deleting from the condition modal waits for server acknowledgement before closing
 back to its existing parent (including Source). Pending, rejected and unavailable
-requests remain visible in the same modal. The breakpoint list now only
-navigates: its row overflow, toggle, condition, delete and Undo actions are removed.
+requests remain visible in the same modal.
+
+Inline toggle rejections additionally appear in a wrapped Codon toast without
+hovering the marker; the marker tooltip retains its detail. A missing edit reply
+after ten seconds reports that changes are unconfirmed, without changing the
+acknowledged definitions. Hidden markers also expire. Only the matching pending
+request may produce a rejection, so late/duplicate replies cannot release a retry.
+Notices disappear after six seconds. Save/Delete modal errors remain in the modal
+without a duplicate toast.
+
+The breakpoint list now only navigates: its row overflow, toggle, condition,
+delete and Undo actions are removed.
 Function entries open their original source line and matching stage; block entries
 open an exact matching recorded/static stage in the current pause's Flow. Matching
 uses location, stage identity and command fingerprint, never a guessed row index.
@@ -140,6 +150,7 @@ Screen; actual list navigation and focus remain a UI acceptance check.
 | --- | --- |
 | Definition/condition logic | `coreTest`: `BreakpointRegistryTest`, `BreakpointConditionEvaluatorTest`, `DebuggerEngineTest` |
 | Acknowledgement and pending UI state | `clientTest`: `ClientBreakpointStateTest` |
+| Non-hover inline rejection feedback (EN/KO), owner denial and unchanged definitions | `DebuggerRequestFeedbackGameTest` |
 | Persistence/preview codec | `test`: `WorldBreakpointPersistenceTest`, `BreakpointStagePreviewPayloadTest` |
 | Native editor input, modal details without screen replacement, draft discard/cancel, pending/rejected saves, server edits, wrapping and narrow layouts | `DebuggerBreakpointUiGameTest` |
 | Single-stage editor/Flow target, legacy toggle/clear and native first-occurrence stop | `SingleStageBreakpointGameTest` |
@@ -154,6 +165,15 @@ Screen; actual list navigation and focus remain a UI acceptance check.
 | Numeric line/stage/coordinate list order | `clientTest`: `BreakpointListOrderTest` |
 
 Example: `./gradlew runClientGameTest -PclientGameTest=DebuggerBreakpointUiGameTest`.
+`DebuggerRequestFeedbackGameTest` sends inline toggle requests for a deliberately
+stale native command-block fingerprint and after owner permission is revoked. Its
+EN/KO screenshots show the rejection toast with the pointer away from all markers;
+the refused target is never added to acknowledged definitions. The same server
+rejection is also rendered above Source and the vanilla command-block editor.
+Requests use the inline edit API; these captures do not assert marker click routing.
+Modal notice
+suppression and hidden-marker expiry use the focused client state tests.
+
 Inspect `*codon-breakpoint-*.png` in the shared screenshot directory. The UI test
 checks editing and transport; use the result test or manual trigger path to prove
 the execution actually pauses. Record manual world reload separately from the
 
@@ -42,6 +42,20 @@ ID when the mailbox executes the request: a delayed control for an earlier stop
 must not advance a newer stop, including an execution-complete inspection stop.
 Explicit `/codon resume`, `stepinto`, `stepover` and `stepout` commands without an
 ID retain their manual/console behavior and target the stop present at execution.
+UI controls also send a request ID. A rejection for that exact pending request and
+pause appears in a wrapped Codon toast without opening chat. A missing reply two
+seconds after sending the control reports that the server outcome is unknown;
+waiting for pre-step Watch reads does not start that deadline. It does not mean rollback
+or fabricate an execution acknowledgement. Late/duplicate rejections cannot clear
+a newer pending request. Feedback uses separate toast slots and renders above ordinary
+notifications, so a full, frozen vanilla toast queue cannot block it. Ordinary toast
+identities and paused lifetimes remain unchanged. Feedback expires after six seconds.
+A new control, pause or authoritative advancement clears control feedback; those
+execution events do not acknowledge independent breakpoint edits, whose notices
+retain their original deadline. Disconnect clears every notice. These notices are separate from
+Watch-read status before a control is sent. Command-tree owner checks remain intact;
+denials before command execution and mailbox drops have no correlated reply and
+therefore use the same unknown-outcome timeout.
 The debugger mailbox admits at most 256 pending client requests and 64 client
 control commands per server, with per-connection limits of 32 and 8 respectively.
 Admitted queries and controls keep their receive order. Excess work is dropped
@@ -89,6 +103,7 @@ captures a selected row alongside a keyboard-focused, truncated action label.
 | Delayed controls and pause ID validation | `coreTest`: `DebuggerControlTest`; command transport: `DebuggerRequestTransportGameTest` |
 | Mailbox limits, concurrent admission, request/step order, recovery and shutdown completion | `test`: `DebuggerMailboxTest`, `DebuggerTaskQueueTest` |
 | Pending state, Watch read deadline/cancellation, current/history separation | `clientTest`: `ClientQuerySchedulerTest`, `ClientDebuggerStateTest`, `ClientHistoricalCallStackTest`, `DebuggerStatusTest` |
+| Visible rejection/timeout with all ordinary toast slots occupied, late replies and recovery | `DebuggerRequestFeedbackGameTest` |
 | Native command-chain execution/stage recording | `DebuggerExecutionFlowGameTest` |
 | Stop after step/resume in a parked native command context | `DebuggerStopRoutingGameTest` |
 | Native conditional function chronology | `DebuggerConditionalFunctionFlowGameTest` |
@@ -104,6 +119,29 @@ Record the before/after command and call depth, not merely that the screen opene
 execution-complete stop, then continues. Its native command runs once; the client
 receives the completed record with a selected Flow stage and inactive controls.
 
+`DebuggerRequestFeedbackGameTest` triggers a real two-block chain and uses a cached
+earlier pause to provoke actual server rejections for all four UI controls. Its
+connection-local observer deliberately withholds rejection replies to reproduce
+post-send timeout, then delivers the same late reply. EN/KO screenshots show the
+wrapped toast and its automatic disappearance without hover.
+The fixture first fills all five vanilla slots with real timed SystemToasts. It
+observes actual toast draw submissions while the world is paused: timeout and
+rejection feedback must render, expire normally, and leave the five ordinary
+toast identities and frozen lifetimes intact. The unmodified queued-feedback path
+fails after its notice expires without a draw. This does not clear or advance
+ordinary notifications in production; fixture cleanup belongs to the test client.
+
+Current-stop Resume recovers and the score of 11 proves each block ran once. The test also observes a
+real not-paused rejection after execution ends and resets connection-local state.
+Before recovery, a real breakpoint rejection triggers Resume in the same client
+frame, before the notice's first draw. The Korean capture after authoritative
+advancement must retain that rejection; controls cannot erase unrelated edit
+feedback. The state regression covers Step/Resume/Continue, the next pause, a
+new control request, six-second expiry and disconnect without extending the clock.
+For that deliberately stale client view, vanilla also pauses the integrated
+server; the test drains the mailbox on the server thread to receive its rejection.
+This is an integrated-server check, not a dedicated-server or real packet-loss test.
+
 `DebuggerStopRoutingGameTest` uses a real outer vanilla Commands execution with
 command limit 1 and stops at the terminal after `execute positioned ~ ~ ~ run`.
 One mailbox runnable steps/resumes and then submits `stop` before the parked context
 
@@ -22,6 +22,7 @@
 import works.nuty.codon.client.state.ClientPauseEffects;
 import works.nuty.codon.client.ui.CodonScreen;
 import works.nuty.codon.client.ui.DebuggerOverlay;
+import works.nuty.codon.client.ui.DebuggerFeedbackToast;
 import works.nuty.codon.client.ui.ScreenLayers;
 
 /**
@@ -75,6 +76,7 @@ public void onInitializeClient() {
         input = inputManager;
 
         ClientNetworking.register(state, camera, effects);
+        DebuggerFeedbackToast.register(state);
         sourceState = ClientSourceBrowseNetworking.register();
         ClientTickEvents.START_CLIENT_TICK.register(camera::tick);
         ClientTickEvents.END_CLIENT_TICK.register(inputManager);
 
@@ -19,6 +19,7 @@
 import works.nuty.codon.network.BreakpointDefinitionsSyncPayload;
 import works.nuty.codon.network.BreakpointEditPayload;
 import works.nuty.codon.network.BreakpointEditResultPayload;
+import works.nuty.codon.network.ControlRejectedPayload;
 import works.nuty.codon.network.BreakpointStagePreviewRequestPayload;
 import works.nuty.codon.network.BreakpointStagePreviewSyncPayload;
 import works.nuty.codon.network.ExecutionFlowSyncPayload;
@@ -156,6 +157,9 @@ public static void register(ClientDebuggerState state, DebuggerFreecam freecam,
         ClientPlayNetworking.registerGlobalReceiver(BreakpointEditResultPayload.TYPE, (payload, context) ->
             context.client().execute(() -> state.breakpoints().finish(payload.requestId(),
                 ClientBreakpointState.Result.valueOf(payload.status().name()))));
+        ClientPlayNetworking.registerGlobalReceiver(ControlRejectedPayload.TYPE, (payload, context) ->
+            context.client().execute(() -> state.rejectControl(payload.pauseId(), payload.requestId(),
+                "command.codon.error." + payload.reason().name().toLowerCase(java.util.Locale.ROOT))));
         ClientPlayNetworking.registerGlobalReceiver(BreakpointStagePreviewSyncPayload.TYPE, (payload, context) ->
             context.client().execute(() -> state.stagePreviews().accept(payload.requestId(), payload.location(),
                 ClientStagePreviewState.Status.valueOf(payload.status().name()), payload.savedCommand(),
@@ -269,16 +273,16 @@ private static boolean requestStagePreview(ClientDebuggerState state,
     /** Send only credited reads; a pending step waits for every Watch from its pause. */
     public static void sendWatchQueries(Minecraft client, ClientDebuggerState state) {
         if (client.player == null) return;
-        queryScheduler.pump(state, sender(client));
+        queryScheduler.pump(state, sender(client, state));
     }
 
     public static void requestControl(Minecraft client, ClientDebuggerState state, long pauseId,
                                       String command, boolean readBeforeStep) {
         if (client.player == null) return;
-        queryScheduler.requestControl(state, pauseId, command, readBeforeStep, sender(client));
+        queryScheduler.requestControl(state, pauseId, command, readBeforeStep, sender(client, state));
     }
 
-    private static ClientQueryScheduler.Sender sender(Minecraft client) {
+    private static ClientQueryScheduler.Sender sender(Minecraft client, ClientDebuggerState state) {
         return new ClientQueryScheduler.Sender() {
             @Override public void editor(works.nuty.codon.client.state.ClientWatchEditorState.Query query) {
                 ClientPlayNetworking.send(new WatchEditorQueryPayload(query.pauseId(), query.requestId(),
@@ -293,7 +297,8 @@ private static ClientQueryScheduler.Sender sender(Minecraft client) {
                     query.offset(), query.path()));
             }
             @Override public void control(long pauseId, String command) {
-                if (client.player != null) client.player.connection.sendCommand("codon " + command + " " + pauseId);
+                if (client.player != null) client.player.connection.sendCommand("codon " + command + " " + pauseId
+                    + " " + state.controlRequestId());
             }
         };
     }
 
@@ -10,14 +10,16 @@
 import java.util.List;
 import java.util.Map;
 import java.util.function.LongSupplier;
+import java.util.function.Consumer;
 
 /** Server-confirmed breakpoint definitions, paged snapshots, and per-target edit status. */
 public final class ClientBreakpointState {
     public enum Action { TOGGLE, SAVE, DELETE }
-    public enum Result { APPLIED, STALE_SOURCE, INVALID_TARGET, NO_PERMISSION, FAILED }
+    public enum Result { APPLIED, STALE_SOURCE, INVALID_TARGET, NO_PERMISSION, FAILED, TIMED_OUT }
     public record Edit(long requestId, Action action, BreakpointDefinition definition) { }
     private static final long TIMEOUT_NANOS = 10_000_000_000L;
     private final LongSupplier clock;
+    private final Consumer<Result> inlineFailure;
     private final Map<BreakpointTarget, BreakpointDefinition> definitions = new HashMap<>();
     private final Map<BreakpointTarget, Pending> pending = new HashMap<>();
     private final Map<BreakpointTarget, Result> errors = new HashMap<>();
@@ -27,7 +29,11 @@ public record Edit(long requestId, Action action, BreakpointDefinition definitio
     private long nextRequestId;
 
     public ClientBreakpointState() { this(System::nanoTime); }
-    public ClientBreakpointState(LongSupplier clock) { this.clock = clock; }
+    public ClientBreakpointState(LongSupplier clock) { this(clock, result -> { }); }
+    public ClientBreakpointState(LongSupplier clock, Consumer<Result> inlineFailure) {
+        this.clock = clock;
+        this.inlineFailure = inlineFailure;
+    }
 
     public synchronized boolean acceptPage(long transferId, int offset, boolean last,
                                            List<BreakpointDefinition> page) {
@@ -54,19 +60,23 @@ public synchronized boolean acceptPage(long transferId, int offset, boolean last
         if (pending.containsKey(target)) return null;
         long id = ++nextRequestId;
         if (id <= 0) id = nextRequestId = 1;
-        pending.put(target, new Pending(id, clock.getAsLong()));
+        pending.put(target, new Pending(id, clock.getAsLong(), action));
         errors.remove(target);
         return new Edit(id, action, definition);
     }
 
     public synchronized void finish(long requestId, Result result) {
+        expirePending();
         BreakpointTarget target = null;
         for (var entry : pending.entrySet()) {
             if (entry.getValue().requestId() == requestId) { target = entry.getKey(); break; }
         }
         if (target == null) return;
-        pending.remove(target);
-        if (result != Result.APPLIED) errors.put(target, result);
+        Pending entry = pending.remove(target);
+        if (result != Result.APPLIED) {
+            errors.put(target, result);
+            if (entry.action() == Action.TOGGLE) inlineFailure.accept(result);
+        }
     }
 
     public synchronized @Nullable BreakpointDefinition get(BreakpointTarget target) {
@@ -96,17 +106,23 @@ private void expire(BreakpointTarget target) {
         Pending entry = pending.get(target);
         if (entry != null && clock.getAsLong() - entry.startedAt() >= TIMEOUT_NANOS) {
             pending.remove(target);
-            errors.put(target, Result.FAILED);
+            errors.put(target, Result.TIMED_OUT);
+            if (entry.action() == Action.TOGGLE) inlineFailure.accept(Result.TIMED_OUT);
         }
     }
 
+    /** Poll even when the marker is hidden; no automatic retry or optimistic edit. */
+    public synchronized void expirePending() {
+        for (var target : List.copyOf(pending.keySet())) expire(target);
+    }
+
     public synchronized void reset() {
         definitions.clear();
         pending.clear();
         errors.clear();
         incoming.clear();
-        incomingTransferId = completedTransferId = nextRequestId = 0;
+        incomingTransferId = completedTransferId = 0;
     }
 
-    private record Pending(long requestId, long startedAt) { }
+    private record Pending(long requestId, long startedAt, Action action) { }
 }
@@ -39,6 +39,8 @@ public final class ClientDebuggerState {
     private boolean controlAwaitingReads;
     private boolean watchReadsFailed;
     private long controlRequestedAt;
+    private long controlRequestId;
+    private final ClientRequestFeedback feedback;
     private final LongSupplier clock;
     private final ClientWatchState watches;
     private final ClientWatchEditorState watchEditor;
@@ -67,10 +69,13 @@ public ClientDebuggerState(DebuggerPreferences preferences) {
     public ClientDebuggerState(LongSupplier clock, DebuggerPreferences preferences) {
         this.clock = Objects.requireNonNull(clock);
         this.preferences = Objects.requireNonNull(preferences);
+        this.feedback = new ClientRequestFeedback(clock);
         this.watches = new ClientWatchState(clock);
         this.watchEditor = new ClientWatchEditorState(clock);
         this.nbt = new ClientNbtState(clock);
-        this.breakpoints = new ClientBreakpointState(clock);
+        this.breakpoints = new ClientBreakpointState(clock, result -> feedback.show(ClientRequestFeedback.Kind.BREAKPOINT,
+            "codon.ui.breakpoint_rejected",
+            "codon.breakpoint.error." + result.name().toLowerCase(java.util.Locale.ROOT)));
         this.stagePreviews = new ClientStagePreviewState();
         this.nbt.setEnabled(preferences.nbtExpanded());
         this.nbt.setEnabledListener(preferences::setNbtExpanded);
@@ -85,6 +90,7 @@ public GizmoMode next() {
     }
 
     public void applyPause(PauseSnapshot snapshot) {
+        feedback.clearControl();
         boolean repeatedPause = paused && this.snapshot != null && this.snapshot.pauseId() == snapshot.pauseId();
         boolean interruptedReads = repeatedPause && (controlAwaitingReads || watchReadsFailed);
         unobservedSelection = null;
@@ -144,6 +150,7 @@ public void applyResume() {
     }
 
     private void clearPause(boolean stepping) {
+        feedback.clearControl();
         unobservedSelection = null;
         if (stepping) watchEditor.invalidate();
         else watchEditor.cancel();
@@ -748,7 +755,9 @@ public DebuggerPreferences preferences() {
     /** Only a fresh server packet completes a control request; UI never fabricates a pause. */
     public boolean beginControlRequest() {
         if (!paused || snapshot == null || controlPending()) return false;
+        feedback.clearControl();
         controlPending = true;
+        controlRequestId = controlRequestId == Long.MAX_VALUE ? 1 : controlRequestId + 1;
         controlRequestedAt = clock.getAsLong();
         return true;
     }
@@ -773,17 +782,30 @@ public void controlSent() {
     }
 
     public boolean controlPending() {
-        if (controlPending && !controlAwaitingReads && clock.getAsLong() - controlRequestedAt >= 2_000_000_000L)
+        if (controlPending && !controlAwaitingReads && clock.getAsLong() - controlRequestedAt >= 2_000_000_000L) {
             controlPending = false;
+            feedback.show(ClientRequestFeedback.Kind.CONTROL, "codon.ui.control_timed_out", "codon.ui.control_timeout_detail");
+        }
         return controlPending;
     }
 
+    public long controlRequestId() { return controlRequestId; }
+    public ClientRequestFeedback feedback() { return feedback; }
+
+    /** Ignore expired/replaced requests, even if another attempt targets the same pause. */
+    public void rejectControl(long pauseId, long requestId, String messageKey) {
+        if (!controlPending() || snapshot == null || snapshot.pauseId() != pauseId || controlRequestId != requestId) return;
+        controlPending = false;
+        feedback.show(ClientRequestFeedback.Kind.CONTROL, "codon.ui.control_rejected", messageKey);
+    }
+
     /** Delay only the waiting label; controlPending() still disables actions immediately. */
     public boolean displayControlWaiting() {
         return controlPending() && clock.getAsLong() - controlRequestedAt >= PendingDisplay.GRACE_NANOS;
     }
 
     public void reset() {
+        feedback.clear();
         applyResume();
         recentFlowSnapshot = null;
         displayedCallStack = List.of();