diff --git a/crates/mcp-config/src/codex/limit.rs b/crates/mcp-config/src/codex/limit.rs
index b6930e4..3269113 100644
--- a/crates/mcp-config/src/codex/limit.rs
+++ b/crates/mcp-config/src/codex/limit.rs
@@ -1,4 +1,4 @@
-//! A Codex CLI seat stopped on its usage limit, held, and handed back (#294).
+//! A Codex CLI seat stopped on its usage limit, and resumed (#294, #403).
 //! See docs/3-accounts.md, "Codex の席が利用上限で止まったとき".
 //!
 //! Three readings and one state machine, all free of the app so that a test
@@ -18,17 +18,16 @@
 //!   and a broken answer are all [`Answer::Unavailable`], which keeps the seat
 //!   limited.
 //!
-//! [`Limit`] is one seat: free, or stopped with the posts the room held for it
-//! and when to ask next. Times are Unix seconds, passed in.
+//! [`Limit`] is one seat: free, or stopped with when to ask next. Times are
+//! Unix seconds, passed in. Nothing is held back from a stopped seat (#403):
+//! the room types into it as into any seat, and a post typed there while it is
+//! stopped stays in its conversation as a turn the limit refused.
 //!
-//! A stopped seat has a mailbox ([`Mailboxes`], #312): the ids of the posts
-//! held for it, kept in a small file beside its topic's record so that they
-//! outlive the session and the app. What the seat is handed at the recovery is
-//! those posts, read again from the room's record ([`mailbox`]). A seat
-//! launched while its mailbox is still there starts stopped
-//! ([`Limit::resumed`]).
+//! A stopped seat has a mark ([`Mailboxes`], #312): a small file beside its
+//! topic's record that outlives the session and the app. A seat launched while
+//! its mark is still there starts stopped ([`Limit::resumed`]), so the resume
+//! is typed by whichever launch holds the seat when the recovery is confirmed.
 use serde_json::Value;
-use std::collections::HashMap;
 use std::path::Path;
 
 /// How a turn ended, as its `task_complete` line says.
@@ -166,36 +165,28 @@ pub const GRACE: i64 = 30;
 /// still no, or no answer came. The last one repeats.
 pub const BACKOFF: [i64; 5] = [60, 120, 300, 600, 900];
 
-/// The least time between two questions when a held post brings the next one
-/// forward (#377): posts arriving together ask once.
-pub const HELD_GAP: i64 = 60;
-
-/// One room post the room did not type into a stopped seat.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Held {
-    pub message_id: String,
-    pub speaker: String,
-    /// The label's `at`, when the post's time could be read.
-    pub at: Option<String>,
-    pub content: String,
-    /// Its `to` names this seat.
-    pub addressed: bool,
-}
+/// How long the resume input waits for the seat's answer (a turn starting or
+/// ending) before the seat counts as stopped on something other than the
+/// limit (#403, the same wait as a Claude seat's, #401).
+pub const ANSWER_WAIT: i64 = 120;
+
+/// What is typed into the seat once its recovery is confirmed (#389).
+pub const CONTINUE: &str = "利用上限の解除を確認しました。中断していた作業を再開してください。中断していた作業がなければ、そのまま待機してください。";
 
 #[derive(Debug, Clone, PartialEq)]
 struct Stopped {
     resets_at: Option<i64>,
     next_query: i64,
     misses: u32,
-    /// When the last question was answered, if one has been.
-    asked: Option<i64>,
 }
 
-/// One Codex seat: free, or stopped with what the room held for it.
+/// One Codex seat: free or stopped, and whether the resume typed into it is
+/// still waiting for its answer.
 #[derive(Debug, Default)]
 pub struct Limit {
     stopped: Option<Stopped>,
-    held: Vec<Held>,
+    /// When [`CONTINUE`] was typed, until a turn starts or ends.
+    typed: Option<i64>,
 }
 
 fn first_query(now: i64, resets_at: Option<i64>) -> i64 {
@@ -206,18 +197,17 @@ fn first_query(now: i64, resets_at: Option<i64>) -> i64 {
 }
 
 impl Limit {
-    /// A seat launched while its mailbox is still there (#312): stopped from
-    /// the start, with its first question due now. Not at a reset: none is
-    /// known, and the one the stop was told may long have passed.
+    /// A seat launched while its mark is still there (#312): stopped from the
+    /// start, with its first question due now. Not at a reset: none is known,
+    /// and the one the stop was told may long have passed.
     pub fn resumed(now: i64) -> Self {
         Limit {
             stopped: Some(Stopped {
                 resets_at: None,
                 next_query: now,
                 misses: 0,
-                asked: None,
             }),
-            held: Vec::new(),
+            typed: None,
         }
     }
 
@@ -229,15 +219,13 @@ impl Limit {
         self.stopped.as_ref().and_then(|s| s.resets_at)
     }
 
-    /// What has been held so far, oldest first.
-    pub fn held(&self) -> &[Held] {
-        &self.held
-    }
-
     /// The rollout said a turn ended on the limit. Whether that stopped a seat
     /// that was free — the moment the room is told. A seat already stopped
-    /// stays as it is: its schedule is the app-server's to move.
+    /// stays as it is: its schedule is the app-server's to move. A resume
+    /// answered by the limit is answered: the stop starts the cycle again, and
+    /// the next confirmed recovery types it again.
     pub fn stop(&mut self, now: i64, resets_at: Option<i64>) -> bool {
+        self.typed = None;
         if self.stopped.is_some() {
             return false;
         }
@@ -245,7 +233,6 @@ impl Limit {
             resets_at,
             next_query: first_query(now, resets_at),
             misses: 0,
-            asked: None,
         });
         true
     }
@@ -263,47 +250,26 @@ impl Limit {
         }
     }
 
-    /// Keep a post back from a stopped seat. `false`, and nothing kept, when
-    /// the seat is free: the post is to be typed.
-    pub fn hold(&mut self, post: impl FnOnce() -> Held) -> bool {
-        if self.stopped.is_none() {
-            return false;
-        }
-        self.held.push(post());
-        true
-    }
-
     /// Whether a question is due now.
     pub fn due(&self, now: i64) -> bool {
         self.stopped.as_ref().is_some_and(|s| now >= s.next_query)
     }
 
-    /// A turn finished without error while stopped (a person typed into the
-    /// terminal). Not a recovery by itself; it brings the next question to now.
+    /// A turn finished without error while stopped — a post typed in by the
+    /// room or a person after the limit was reset by hand (#377). Not a
+    /// recovery by itself; it brings the next question to now.
     pub fn turn_completed(&mut self, now: i64) {
         if let Some(stopped) = self.stopped.as_mut() {
             stopped.next_query = stopped.next_query.min(now);
         }
     }
 
-    /// A post has just been held (#377): the room has something for the seat,
-    /// so whether it is free is worth asking now rather than at the reset —
-    /// the limit may have been reset by hand. Not sooner than [`HELD_GAP`]
-    /// after the last question.
-    pub fn post_held(&mut self, now: i64) {
-        if let Some(stopped) = self.stopped.as_mut() {
-            let earliest = stopped.asked.map_or(now, |asked| (asked + HELD_GAP).max(now));
-            stopped.next_query = stopped.next_query.min(earliest);
-        }
-    }
-
     /// The answer of a due question. Whether it confirmed the recovery; the
-    /// seat stays stopped, still holding, until [`Limit::release`].
+    /// seat stays stopped until [`Limit::free`].
     pub fn answer(&mut self, now: i64, answer: Answer) -> bool {
         let Some(stopped) = self.stopped.as_mut() else {
             return false;
         };
-        stopped.asked = Some(now);
         match answer {
             Answer::Allowed => return true,
             Answer::Denied { resets_at: Some(reset) } if reset + GRACE > now => {
@@ -320,129 +286,43 @@ impl Limit {
         false
     }
 
-    /// Free the seat and hand over what was held, oldest first.
-    pub fn release(&mut self) -> Vec<Held> {
+    /// The recovery is confirmed and the resume goes in: the seat is free.
+    pub fn free(&mut self) {
         self.stopped = None;
-        std::mem::take(&mut self.held)
     }
-}
 
-/// The one line handed to a seat on its recovery, or `None` when nothing was
-/// held: the count, the way to read them, and in full only the posts whose
-/// `to` named the seat.
-pub fn digest(held: &[Held]) -> Option<String> {
-    if held.is_empty() {
-        return None;
-    }
-    let mut text = format!(
-        "制限中に部屋で {} 件の発言がありました。必要なら read_room_history で読んでください。",
-        held.len()
-    );
-    let addressed: Vec<&Held> = held.iter().filter(|post| post.addressed).collect();
-    if !addressed.is_empty() {
-        text.push_str(&format!("\n\nそのうちあなた宛ての {} 件:", addressed.len()));
-        for post in addressed {
-            let at = post.at.as_deref().map(|at| format!("、{at}")).unwrap_or_default();
-            text.push_str(&format!(
-                "\n\n--- {}{}（message_id {}）\n{}",
-                post.speaker, at, post.message_id, post.content
-            ));
-        }
+    /// [`CONTINUE`] was typed into the seat now: its answer is awaited.
+    pub fn resume_typed(&mut self, now: i64) {
+        self.typed = Some(now);
     }
-    Some(text)
-}
-
-/// One post of the topic's record, as [`mailbox`] reads it. `at` is the
-/// post's time already read the way a label carries it.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Recorded {
-    pub message_id: String,
-    pub speaker: String,
-    pub account: Option<String>,
-    pub content: String,
-    pub to: Vec<String>,
-    pub at: Option<String>,
-}
-
-/// The seat a mailbox is read for.
-#[derive(Debug, Clone, Copy)]
-pub struct Seat<'a> {
-    /// Its name now.
-    pub name: &'a str,
-    pub account_id: &'a str,
-}
 
-/// The names the seat is known by in the record: its name now, and every name
-/// its account has spoken under there — what a post addressed to the seat
-/// before a rename carries. A name some other account has spoken under is not
-/// taken from the record: it would read posts to that seat as to this one.
-fn names_of(record: &[Recorded], seat: &Seat) -> Vec<String> {
-    let mut names = vec![seat.name.to_string()];
-    for post in record {
-        if post.account.as_deref() == Some(seat.account_id) && !names.contains(&post.speaker) {
-            names.push(post.speaker.clone());
-        }
+    /// A turn of the seat started or ended: the resume has its answer.
+    pub fn answered(&mut self) {
+        self.typed = None;
     }
-    let others: Vec<&str> = record
-        .iter()
-        .filter(|post| post.account.as_deref().is_some_and(|id| id != seat.account_id))
-        .map(|post| post.speaker.as_str())
-        .collect();
-    names.retain(|name| name == seat.name || !others.contains(&name.as_str()));
-    names
-}
 
-/// What the seat is handed at its recovery, in the order held (#312): the
-/// posts whose ids its mailbox holds, and nothing else. `ids` is the mailbox as
-/// its file keeps it; `held` is what this launch's memory held, whose ids the
-/// file normally holds too, and any it does not are kept after them.
-///
-/// Each post is read from the record, with `addressed` read against every name
-/// the seat is known by there. A post the record does not show is taken as
-/// memory held it, and one neither shows is left out: there is nothing of it
-/// to hand over. Nothing else in the record is looked at — no notice, no range
-/// between two ids: a post said while the seat was closed, or while the app was
-/// down, was never held, and is not the seat's to be handed.
-pub fn mailbox(record: &[Recorded], seat: &Seat, ids: &[String], held: Vec<Held>) -> Vec<Held> {
-    let names = names_of(record, seat);
-    let by_id: HashMap<&str, &Recorded> = record
-        .iter()
-        .map(|post| (post.message_id.as_str(), post))
-        .collect();
-    let mut order: Vec<String> = Vec::new();
-    for id in ids.iter().chain(held.iter().map(|post| &post.message_id)) {
-        if !order.contains(id) {
-            order.push(id.clone());
+    /// Whether the resume drew no answer within [`ANSWER_WAIT`]: the seat is
+    /// stopped on something else (a selection screen, an expired login, a
+    /// trust prompt), where a submit key could pick a choice. `true` once;
+    /// nothing is typed again for it.
+    pub fn unanswered(&mut self, now: i64) -> bool {
+        if self.typed.is_some_and(|typed| now >= typed + ANSWER_WAIT) {
+            self.typed = None;
+            return true;
         }
+        false
     }
-    order
-        .into_iter()
-        .filter_map(|id| {
-            let memory = held.iter().find(|post| post.message_id == id);
-            match by_id.get(id.as_str()) {
-                Some(post) => Some(Held {
-                    message_id: post.message_id.clone(),
-                    speaker: post.speaker.clone(),
-                    at: post.at.clone(),
-                    content: post.content.clone(),
-                    addressed: memory.is_some_and(|m| m.addressed)
-                        || post.to.iter().any(|to| names.contains(to)),
-                }),
-                None => memory.cloned(),
-            }
-        })
-        .collect()
 }
 
-/// The mailboxes of one topic's stopped seats, as the small file beside the
+/// The marks of one topic's stopped seats, as the small file beside the
 /// topic's record keeps them across a session's end and the app's (#312): by
-/// account, the ids of the posts held for that seat, oldest first. Ids only —
-/// what was said is the record's. A seat has a mailbox from its stop until its
-/// recovery has been handed over, empty while nothing has been held. The file
-/// goes with its topic (`topic_index::delete`).
+/// account, from the seat's stop until its resume is typed. The file goes with
+/// its topic (`topic_index::delete`). A seat's value is an empty list; a file
+/// written before #403 carries the ids of posts held then, and is read as the
+/// same mark.
 ///
 /// A file that is missing, cannot be read, or is not what this writes is no
-/// mailbox at all.
+/// mark at all.
 #[derive(Debug, Default, Clone, PartialEq)]
 pub struct Mailboxes {
     seats: serde_json::Map<String, Value>,
@@ -462,7 +342,7 @@ impl Mailboxes {
     }
 
     /// Written whole, through a file beside it renamed over it, so a write cut
-    /// short leaves the last one standing. No mailbox left is no file.
+    /// short leaves the last one standing. No mark left is no file.
     pub fn write(&self, path: &Path) -> std::io::Result<()> {
         if self.seats.is_empty() {
             return match std::fs::remove_file(path) {
@@ -478,44 +358,20 @@ impl Mailboxes {
         std::fs::rename(&next, path)
     }
 
-    /// The seat's mailbox, or `None` when it has none.
-    pub fn get(&self, account_id: &str) -> Option<Vec<String>> {
-        let ids = self.seats.get(account_id)?.as_array()?;
-        Some(
-            ids.iter()
-                .filter_map(|id| id.as_str().map(str::to_string))
-                .collect(),
-        )
+    /// Whether the seat is marked stopped.
+    pub fn has(&self, account_id: &str) -> bool {
+        self.seats.contains_key(account_id)
     }
 
-    fn ids_mut(&mut self, account_id: &str) -> &mut Vec<Value> {
-        let ids = self
-            .seats
+    /// The seat has stopped: it is marked from now. A mark already there is
+    /// kept as it is.
+    pub fn open(&mut self, account_id: &str) {
+        self.seats
             .entry(account_id.to_string())
             .or_insert_with(|| Value::Array(Vec::new()));
-        if !ids.is_array() {
-            *ids = Value::Array(Vec::new());
-        }
-        match ids {
-            Value::Array(ids) => ids,
-            _ => unreachable!("made an array above"),
-        }
-    }
-
-    /// The seat has stopped: it has a mailbox from now, empty if it had none.
-    pub fn open(&mut self, account_id: &str) {
-        self.ids_mut(account_id);
     }
 
-    /// One more post held for the seat.
-    pub fn push(&mut self, account_id: &str, message_id: &str) {
-        let ids = self.ids_mut(account_id);
-        if !ids.iter().any(|id| id == message_id) {
-            ids.push(Value::String(message_id.to_string()));
-        }
-    }
-
-    /// The seat's recovery is being handed over: its mailbox goes.
+    /// The seat's resume is being typed: its mark goes.
     pub fn close(&mut self, account_id: &str) {
         self.seats.remove(account_id);
     }
@@ -528,20 +384,23 @@ pub fn stop_notice(name: &str, reset: Option<&str>) -> String {
         Some(reset) => format!("解除予定は {reset} です。"),
         None => "解除予定は分かっていません。".to_string(),
     };
-    format!(
-        "{name} は利用上限で止まりました。{when}解除を確かめるまで、{name} への部屋の発言は Pullcept が預かります。"
-    )
+    format!("{name} は利用上限で止まりました。{when}")
 }
 
-/// What the room is told when the recovery is confirmed.
-pub fn recovery_notice(name: &str, held: usize) -> String {
-    if held == 0 {
-        format!("{name} の利用上限の解除を確かめました。")
-    } else {
-        format!(
-            "{name} の利用上限の解除を確かめました。預かっていた {held} 件の発言は、一通にまとめて {name} に渡します。"
-        )
-    }
+/// What the room is told when the recovery is confirmed and the resume is
+/// about to be typed into the seat.
+pub fn recovery_notice(name: &str) -> String {
+    format!("{name} の利用上限の解除を確かめました。{name} の端末へ再開の指示を打ちます。")
+}
+
+/// The resume drew no answer within [`ANSWER_WAIT`] (#403).
+pub fn other_cause(name: &str) -> String {
+    format!("{name} は、再開の指示を打ってから応答がありません。利用上限以外の理由（起動時の選択画面、ログイン切れ、信頼の確認など）で止まっているようです。指示は打ち直しません。端末を見てください。")
+}
+
+/// A seat the room was told of with [`other_cause`] finished a turn again.
+pub fn back_after_other_cause(name: &str) -> String {
+    format!("{name} は再開しました（正常な応答を確認）。先の「端末を見てください」は解消しています。")
 }
 
 #[cfg(test)]
@@ -640,23 +499,12 @@ mod tests {
         assert_eq!(json(&lines[2])["id"], READ_ID);
     }
 
-    fn post(id: &str, addressed: bool) -> Held {
-        Held {
-            message_id: id.into(),
-            speaker: "Master".into(),
-            at: Some("2026-10-05T22:10+09:00".into()),
-            content: format!("body {id}"),
-            addressed,
-        }
-    }
-
     #[test]
-    fn a_free_seat_holds_nothing_and_is_never_due() {
+    fn a_free_seat_is_never_due() {
         let mut limit = Limit::default();
-        assert!(!limit.hold(|| post("a", false)));
+        assert!(!limit.is_limited());
         assert!(!limit.due(i64::MAX));
         assert!(!limit.answer(0, Answer::Allowed));
-        assert_eq!(limit.release(), Vec::new());
     }
 
     #[test]
@@ -717,6 +565,7 @@ mod tests {
 
     #[test]
     fn a_turn_that_worked_brings_the_question_forward_but_is_not_a_recovery() {
+        // A room post typed into a seat whose limit was reset by hand (#377).
         let mut limit = Limit::default();
         limit.stop(0, Some(10_000));
         limit.turn_completed(50);
@@ -725,92 +574,56 @@ mod tests {
     }
 
     #[test]
-    fn a_held_post_asks_before_the_reset_but_not_twice_a_minute() {
+    fn a_confirmed_recovery_frees_the_seat_once() {
         let mut limit = Limit::default();
-        limit.stop(0, Some(10_000));
-        assert!(!limit.due(100));
-        limit.post_held(100);
-        assert!(limit.due(100));
-        assert!(!limit.answer(100, Answer::Denied { resets_at: Some(10_000) }));
-        assert!(!limit.due(130));
-        limit.post_held(130);
-        assert!(!limit.due(130));
-        assert!(limit.due(160));
-        assert!(limit.answer(160, Answer::Allowed));
-    }
-
-    #[test]
-    fn the_recovery_hands_over_what_was_held_in_order() {
-        let mut limit = Limit::default();
-        limit.stop(0, Some(100));
-        assert!(limit.hold(|| post("a", false)));
-        assert!(limit.hold(|| post("b", true)));
-        assert_eq!(limit.held().len(), 2);
-        assert!(limit.answer(200, Answer::Allowed));
-        // Confirmed, but still holding until released.
+        limit.stop(100, Some(200));
+        assert!(!limit.answer(201, Answer::Unavailable));
+        assert!(!limit.answer(202, Answer::Denied { resets_at: Some(200) }));
+        assert!(limit.answer(204, Answer::Allowed));
+        // Confirmed, but stopped until freed.
         assert!(limit.is_limited());
-        assert!(limit.hold(|| post("c", false)));
-        let held = limit.release();
-        assert_eq!(
-            held.iter().map(|p| p.message_id.as_str()).collect::<Vec<_>>(),
-            ["a", "b", "c"]
-        );
+        limit.free();
         assert!(!limit.is_limited());
-        assert!(!limit.hold(|| post("d", false)));
+        assert!(!limit.answer(205, Answer::Allowed));
     }
 
     #[test]
-    fn the_digest_counts_all_and_carries_only_the_addressed() {
-        assert_eq!(digest(&[]), None);
-        let text = digest(&[post("a", false), post("b", true), post("c", false)]).unwrap();
-        assert!(text.starts_with(
-            "制限中に部屋で 3 件の発言がありました。必要なら read_room_history で読んでください。"
-        ));
-        assert!(text.contains("あなた宛ての 1 件"));
-        assert!(text.contains("body b"));
-        assert!(text.contains("message_id b"));
-        assert!(!text.contains("body a"));
-        assert!(!text.contains("body c"));
-        let none_addressed = digest(&[post("a", false)]).unwrap();
-        assert!(!none_addressed.contains("あなた宛て"));
+    fn the_resume_is_answered_by_a_turn_or_by_the_limit_or_counts_as_another_cause() {
+        // A turn starts or ends: answered, nothing more.
+        let mut limit = Limit::default();
+        limit.resume_typed(1000);
+        limit.answered();
+        assert!(!limit.unanswered(1000 + ANSWER_WAIT));
+        // The limit again: a new stop, and no other cause.
+        let mut limit = Limit::default();
+        limit.resume_typed(1000);
+        assert!(limit.stop(1010, Some(5000)));
+        assert!(!limit.unanswered(1000 + ANSWER_WAIT));
+        // Nothing: once, at the wait's end, and not again.
+        let mut limit = Limit::default();
+        limit.resume_typed(1000);
+        assert!(!limit.unanswered(1000 + ANSWER_WAIT - 1));
+        assert!(limit.unanswered(1000 + ANSWER_WAIT));
+        assert!(!limit.unanswered(1000 + 2 * ANSWER_WAIT));
+        assert!(!limit.is_limited());
     }
 
     #[test]
-    fn the_notices_name_the_seat_and_the_reset() {
+    fn the_notices_name_the_seat_and_the_reset_and_hold_nothing() {
         assert_eq!(
             stop_notice("Codex Luna", Some("10月5日 22:45")),
-            "Codex Luna は利用上限で止まりました。解除予定は 10月5日 22:45 です。解除を確かめるまで、Codex Luna への部屋の発言は Pullcept が預かります。"
+            "Codex Luna は利用上限で止まりました。解除予定は 10月5日 22:45 です。"
         );
         assert!(stop_notice("L", None).contains("解除予定は分かっていません。"));
-        assert!(recovery_notice("L", 3).contains("3 件"));
-        assert!(!recovery_notice("L", 0).contains("件"));
-    }
-    const SEAT: Seat = Seat {
-        name: "Codex Luna",
-        account_id: "luna",
-    };
-
-    fn said(id: &str, speaker: &str, account: Option<&str>, to: &[&str], content: &str) -> Recorded {
-        Recorded {
-            message_id: id.into(),
-            speaker: speaker.into(),
-            account: account.map(str::to_string),
-            content: content.into(),
-            to: to.iter().map(|t| t.to_string()).collect(),
-            at: Some(format!("at {id}")),
+        for text in [stop_notice("L", None), recovery_notice("L")] {
+            assert!(!text.contains("預か"), "{text}");
         }
-    }
-
-    fn by_master(id: &str, to: &[&str]) -> Recorded {
-        said(id, "Master", None, to, &format!("body {id}"))
-    }
-
-    fn ids(posts: &[Held]) -> Vec<&str> {
-        posts.iter().map(|p| p.message_id.as_str()).collect()
-    }
-
-    fn strings(ids: &[&str]) -> Vec<String> {
-        ids.iter().map(|id| id.to_string()).collect()
+        assert!(recovery_notice("L").contains("再開の指示を打ちます"));
+        assert!(other_cause("L").contains("端末を見てください"));
+        assert!(back_after_other_cause("L").contains("解消"));
+        assert!(CONTINUE.contains("中断していた作業を再開してください"));
+        assert!(CONTINUE.contains("作業がなければ、そのまま待機"));
+        assert!(!CONTINUE.contains("read_room_history"));
     }
 
     #[test]
@@ -819,82 +632,13 @@ mod tests {
         assert!(limit.is_limited());
         assert_eq!(limit.resets_at(), None);
         assert!(limit.due(1000));
-        assert!(limit.hold(|| post("a", false)));
         assert!(!limit.stop(1001, Some(9000)), "already stopped: no second notice");
-        // Still no: held, and asked again on the backoff.
+        // Still no: asked again on the backoff.
         assert!(!limit.answer(1000, Answer::Unavailable));
         assert!(limit.is_limited());
         assert!(!limit.due(1000 + BACKOFF[0] - 1));
         assert!(limit.due(1000 + BACKOFF[0]));
         assert!(limit.answer(1000 + BACKOFF[0], Answer::Allowed));
-        assert_eq!(ids(&limit.release()), ["a"]);
-    }
-
-    #[test]
-    fn the_mailbox_is_its_ids_and_nothing_between_them() {
-        // The seat stopped and held m1; the app went down; m2 was said while
-        // it was down; the relaunched seat, still stopped, held m3.
-        let record = vec![
-            by_master("before", &["Codex Luna"]),
-            by_master("m1", &["Codex Luna"]),
-            said("lin", "Claude Lin", Some("lin"), &[], "body lin"),
-            by_master("m2", &["Codex Luna"]),
-            by_master("m3", &["Codex Luna", "Claude Lin"]),
-        ];
-        let held = vec![Held {
-            message_id: "m3".into(),
-            speaker: "Master".into(),
-            at: None,
-            content: "body m3".into(),
-            addressed: true,
-        }];
-        let posts = mailbox(&record, &SEAT, &strings(&["m1", "lin", "m3"]), held);
-        assert_eq!(ids(&posts), ["m1", "lin", "m3"]);
-        assert_eq!(
-            posts.iter().filter(|p| p.addressed).map(|p| p.message_id.as_str()).collect::<Vec<_>>(),
-            ["m1", "m3"]
-        );
-        // Read from the record: its time, not memory's missing one.
-        assert_eq!(posts[2].at.as_deref(), Some("at m3"));
-        let text = digest(&posts).unwrap();
-        assert!(text.starts_with("制限中に部屋で 3 件の発言がありました。"));
-        assert!(text.contains("body m1"));
-        assert!(!text.contains("body m2"));
-        assert!(!text.contains("body before"));
-        // The restart's memory is empty: the file alone carries it.
-        assert_eq!(ids(&mailbox(&record, &SEAT, &strings(&["m1", "lin"]), Vec::new())), ["m1", "lin"]);
-    }
-
-    #[test]
-    fn what_memory_held_outside_the_file_or_the_record_is_kept() {
-        let record = vec![by_master("m", &[]), by_master("n", &[])];
-        // "n" was held but its id did not reach the file; "late" reached the
-        // record after it was read; "gone" is in neither and is left out.
-        let held = vec![post("m", false), post("n", false), post("late", true)];
-        let posts = mailbox(&record, &SEAT, &strings(&["m", "gone"]), held);
-        assert_eq!(ids(&posts), ["m", "n", "late"]);
-        assert!(posts[2].addressed);
-        assert_eq!(mailbox(&record, &SEAT, &[], Vec::new()), Vec::new());
-    }
-
-    #[test]
-    fn a_renamed_seat_is_followed_by_its_account() {
-        // Held as "Luna", handed over as "Codex Luna".
-        let record = vec![
-            said("hi", "Luna", Some("luna"), &[], "hello"),
-            by_master("m1", &["Luna"]),
-            by_master("m2", &["Codex Luna"]),
-        ];
-        let posts = mailbox(&record, &SEAT, &strings(&["m1", "m2"]), Vec::new());
-        assert!(posts.iter().all(|p| p.addressed));
-        // A name another account has spoken under is not taken as the seat's.
-        let record = vec![
-            said("hi", "Luna", Some("luna"), &[], "hello"),
-            said("sol", "Luna", Some("sol"), &[], "I am Luna now"),
-            by_master("m1", &["Luna"]),
-        ];
-        let posts = mailbox(&record, &SEAT, &strings(&["m1"]), Vec::new());
-        assert!(!posts[0].addressed);
     }
 
     struct Scratch(std::path::PathBuf);
@@ -913,41 +657,32 @@ mod tests {
     }
 
     #[test]
-    fn the_mailboxes_outlive_a_restart_and_go_at_the_recovery() {
+    fn the_marks_outlive_a_restart_and_go_at_the_resume() {
         let scratch = Scratch::new();
         let path = scratch.0.join("mailboxes").join("topic.json");
         assert_eq!(Mailboxes::read(&path), Mailboxes::default());
         let mut boxes = Mailboxes::default();
         boxes.open("luna");
-        boxes.write(&path).unwrap();
-        // Stopped with nothing held is still a mailbox.
-        assert_eq!(Mailboxes::read(&path).get("luna"), Some(Vec::new()));
-        boxes.push("luna", "a");
-        boxes.push("luna", "b");
-        boxes.push("luna", "a");
-        boxes.push("sol", "c");
+        boxes.open("sol");
         boxes.write(&path).unwrap();
         let mut read = Mailboxes::read(&path);
-        assert_eq!(read.get("luna"), Some(strings(&["a", "b"])));
-        assert_eq!(read.get("sol"), Some(strings(&["c"])));
-        assert_eq!(read.get("other"), None);
-        // Opening again keeps what is there.
-        read.open("luna");
-        assert_eq!(read.get("luna"), Some(strings(&["a", "b"])));
+        assert!(read.has("luna") && read.has("sol"));
+        assert!(!read.has("other"));
         read.close("luna");
         read.write(&path).unwrap();
-        assert_eq!(Mailboxes::read(&path).get("luna"), None);
+        assert!(!Mailboxes::read(&path).has("luna"));
         read.close("sol");
         read.write(&path).unwrap();
-        assert!(!path.exists(), "no mailbox left is no file");
+        assert!(!path.exists(), "no mark left is no file");
         read.write(&path).unwrap();
-        // A file that is not what this writes is no mailbox.
+        // A file written before #403, with held ids, is the same mark.
+        std::fs::write(&path, r#"{"luna":["a","b"]}"#).unwrap();
+        let mut old = Mailboxes::read(&path);
+        assert!(old.has("luna"));
+        old.open("luna");
+        assert!(old.has("luna"));
+        // A file that is not what this writes is no mark.
         std::fs::write(&path, "[1,2]").unwrap();
         assert_eq!(Mailboxes::read(&path), Mailboxes::default());
-        std::fs::write(&path, r#"{"luna":"x"}"#).unwrap();
-        let mut odd = Mailboxes::read(&path);
-        assert_eq!(odd.get("luna"), None);
-        odd.push("luna", "a");
-        assert_eq!(odd.get("luna"), Some(strings(&["a"])));
     }
 }
diff --git a/crates/mcp-config/src/codex/status.rs b/crates/mcp-config/src/codex/status.rs
index a36287c..76a7c0e 100644
--- a/crates/mcp-config/src/codex/status.rs
+++ b/crates/mcp-config/src/codex/status.rs
@@ -163,6 +163,9 @@ pub struct Tail {
     pub status: Status,
     /// The last turn end read and not yet taken (#294, `limit::turn_end`).
     turn_end: Option<super::limit::TurnEnd>,
+    /// A turn's `task_started` was read and not yet taken (#403): the seat
+    /// answered the resume typed into it.
+    turn_started: bool,
     /// The reset the last `token_count` reported for its fullest window
     /// (#294, `limit::rollout_reset`): what the room is told while the
     /// app-server has not said better.
@@ -199,6 +202,7 @@ impl Tail {
                     if let Some(end) = super::limit::turn_end(&value) {
                         self.turn_end = Some(end);
                     }
+                    self.turn_started |= value["type"] == "event_msg" && value["payload"]["type"] == "task_started";
                     if let Some(reset) = super::limit::rollout_reset(&value) {
                         self.resets_at = Some(reset);
                     }
@@ -220,6 +224,11 @@ impl Tail {
         self.turn_end.take()
     }
 
+    /// Whether a turn started since the previous call (#403).
+    pub fn take_turn_started(&mut self) -> bool {
+        std::mem::take(&mut self.turn_started)
+    }
+
     /// Whether the rate limits were read since the previous call (#364).
     pub fn take_limits_read(&mut self) -> bool {
         std::mem::take(&mut self.limits_read)
@@ -496,6 +505,10 @@ mod tests {
         assert_eq!(tail.resets_at, Some(1791613577), "93 is the fuller window in TOKENS");
         assert_eq!(tail.take_turn_end(), Some(TurnEnd::UsageLimit));
         assert_eq!(tail.take_turn_end(), None);
+        assert!(!tail.take_turn_started());
+        tail.feed(lines(&[r#"{"type":"event_msg","payload":{"type":"task_started"}}"#]).as_bytes());
+        assert!(tail.take_turn_started());
+        assert!(!tail.take_turn_started(), "taken once");
     }
 
     #[test]
diff --git a/crates/mcp-config/src/lib.rs b/crates/mcp-config/src/lib.rs
index bb25753..213321a 100644
--- a/crates/mcp-config/src/lib.rs
+++ b/crates/mcp-config/src/lib.rs
@@ -38,7 +38,6 @@ pub mod hook_activity;
 pub mod claude_limit;
 pub mod claude_notice;
 pub mod claude_resume;
-pub mod limit_recovery;
 pub mod permission_prompt;
 pub mod prompt_hold;
 pub mod usage;
diff --git a/crates/mcp-config/src/limit_recovery.rs b/crates/mcp-config/src/limit_recovery.rs
deleted file mode 100644
index f06ed52..0000000
--- a/crates/mcp-config/src/limit_recovery.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-//! The single input handed to a parent after its limit recovery is confirmed.
-//! Confirmation remains the caller's Codex limit (docs/3-accounts.md, #389).
-use crate::codex::limit::{digest, Held};
-
-pub const CONTINUE: &str = "利用上限の解除を確認しました。中断していた作業を再開してください。中断していた作業がなければ、そのまま待機してください。";
-
-pub fn input(held: &[Held]) -> String {
-    match digest(held) {
-        Some(digest) => format!("{CONTINUE}\n\n{digest}"),
-        None => CONTINUE.to_string(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{
-        codex::limit::{Answer, Limit},
-        prompt_hold::{Item, Queue},
-    };
-
-    #[test]
-    fn empty_mailbox_still_resumes_and_can_wait_without_new_work() {
-        let text = input(&[]);
-        assert_eq!(text, CONTINUE);
-        assert!(text.contains("中断していた作業を再開してください"));
-        assert!(text.contains("作業がなければ、そのまま待機"));
-        assert!(!text.contains("read_room_history"));
-    }
-
-    #[test]
-    fn held_posts_share_one_input_with_the_continuation() {
-        let held = [Held {
-            message_id: "post-1".into(),
-            speaker: "Master".into(),
-            at: None,
-            content: "continue the same issue".into(),
-            addressed: true,
-        }];
-        let text = input(&held);
-        assert!(text.starts_with(CONTINUE));
-        assert_eq!(text.matches(CONTINUE).count(), 1);
-        assert!(text.contains(&digest(&held).unwrap()));
-        assert!(text.contains("post-1"));
-        assert!(text.contains("continue the same issue"));
-    }
-
-    #[test]
-    fn codex_confirmation_releases_once_even_with_no_posts() {
-        let mut limit = Limit::default();
-        limit.stop(100, Some(200));
-        assert!(!limit.answer(201, Answer::Unavailable));
-        assert!(limit.is_limited());
-        assert!(!limit.answer(
-            202,
-            Answer::Denied {
-                resets_at: Some(200)
-            }
-        ));
-        assert!(limit.is_limited());
-        assert!(limit.answer(204, Answer::Allowed));
-        assert_eq!(input(&limit.release()), CONTINUE);
-        assert!(!limit.answer(203, Answer::Allowed));
-    }
-
-    #[test]
-    fn confirmed_recovery_keeps_one_continuation_through_permission_wait() {
-        let mut limit = Limit::default();
-        limit.stop(100, Some(200));
-        assert!(limit.answer(201, Answer::Allowed));
-        let mut queue = Queue::new();
-        let item = Item {
-            message_id: "recovery".into(),
-            text: input(&limit.release()),
-            post: None,
-            launch_bound: true,
-            relaunch_text: None,
-        };
-        assert!(queue.pass(true, item).is_none());
-        assert!(!limit.is_limited());
-        assert!(!queue.begin(true));
-        assert!(queue.begin(false));
-        assert_eq!(queue.next(false).unwrap().text, CONTINUE);
-        assert!(queue.next(false).is_none());
-        assert!(!queue.begin(false));
-    }
-
-    #[test]
-    fn recovery_waiting_on_permission_is_not_carried_to_another_launch() {
-        let recovery = Item {
-            message_id: "recovery".into(),
-            text: input(&[]),
-            post: None,
-            launch_bound: true,
-            relaunch_text: None,
-        };
-        let ordinary = Item {
-            message_id: "post".into(),
-            text: "ordinary room post".into(),
-            post: None,
-            launch_bound: false,
-            relaunch_text: None,
-        };
-        let mut queue = Queue::new();
-        queue.pass(true, recovery.clone());
-        queue.pass(true, ordinary.clone());
-        let mut next_launch = queue.carry();
-        assert_eq!(next_launch.len(), 1);
-        // An earlier launch's in-flight hand-over can also refuse after carry.
-        next_launch.put_first(recovery);
-        assert_eq!(next_launch.len(), 1);
-        assert!(next_launch.begin(false));
-        assert_eq!(next_launch.next(false), Some(ordinary));
-        assert!(next_launch.next(false).is_none());
-    }
-
-    #[test]
-    fn relaunch_keeps_the_existing_digest_and_watermark_without_continuation() {
-        let held = [Held {
-            message_id: "post-1".into(),
-            speaker: "Master".into(),
-            at: None,
-            content: "same issue".into(),
-            addressed: true,
-        }];
-        let fallback = digest(&held).unwrap();
-        let item = Item {
-            message_id: "recovery-watermark".into(),
-            text: input(&held),
-            post: None,
-            launch_bound: true,
-            relaunch_text: Some(fallback.clone()),
-        };
-        let mut queue = Queue::new();
-        queue.pass(true, item.clone());
-        let mut next_launch = queue.carry();
-        assert!(next_launch.begin(false));
-        let carried = next_launch.next(false).unwrap();
-        assert_eq!(carried.message_id, "recovery-watermark");
-        assert_eq!(carried.text, fallback);
-        assert!(!carried.text.contains(CONTINUE));
-        assert!(next_launch.next(false).is_none());
-        // A refusal of an item already taken by the old launch has the same fallback.
-        next_launch.put_first(item);
-        let mut third_launch = next_launch.carry();
-        assert!(third_launch.begin(false));
-        assert_eq!(third_launch.next(false), Some(carried));
-        assert!(third_launch.next(false).is_none());
-    }
-}
diff --git a/crates/mcp-config/src/prompt_hold.rs b/crates/mcp-config/src/prompt_hold.rs
index 59f06f2..4e47046 100644
--- a/crates/mcp-config/src/prompt_hold.rs
+++ b/crates/mcp-config/src/prompt_hold.rs
@@ -22,23 +22,16 @@
 //! to end. An item the terminal refused is put back at the front and the
 //! hand-over ends: nothing is dropped.
 //!
-//! **The usage-limit hold comes first** (#294). A post for a Codex seat stopped
-//! on its usage limit is that hold's, as before, and never reaches this queue.
-//! A Claude Code seat has no such hold (#401): its posts come here like any.
-//! A kept post whose hand-over finds the seat stopped on its limit is given to
-//! that hold (`deliver`) rather than typed, and goes out with its digest at the
-//! recovery. The digest itself, typed at a recovery that finds the seat
-//! waiting, is kept here like a post and typed after the wait — it is already
-//! the limit hold's release, and is not given back to it. One order is not
-//! kept: a post held here before a limit began goes into the limit's mailbox
-//! after the posts the limit itself held while this wait lasted.
+//! **No seat is held back on its usage limit** (Claude #401, Codex #403): a
+//! post for a seat stopped on its limit comes here like any. The resume typed
+//! at a recovery that finds the seat waiting is kept here like a post and
+//! typed after the wait, for that launch only (`Item::launch_bound`).
 //!
 //! **A wait's end is not a hand-over at once.** The hand-over is begun
 //! `RELEASE_GRACE` after the end was heard, and only if no wait has begun in
 //! between: a prompt answered in the terminal can be followed at once by the
 //! next one (a second call waiting on its own permission), and the request of
 //! that one is heard before its prompt is drawn.
-use crate::codex::limit::Held;
 use std::collections::VecDeque;
 use std::time::Duration;
 
@@ -49,27 +42,19 @@ pub const RELEASE_GRACE: Duration = Duration::from_millis(1500);
 /// One thing the room would have typed into the seat's terminal.
 #[derive(Debug, Clone, PartialEq)]
 pub struct Item {
-    /// The post's id, or the watermark a digest is labelled with: for the log
-    /// only.
+    /// The post's id, or the watermark a resume is labelled with: for the
+    /// log only.
     pub message_id: String,
     /// What is typed, label line and all (`terminal_input::compose`).
     pub text: String,
-    /// The post as the usage-limit hold keeps one, or `None` for what is not a
-    /// post of the room's — the limit hold's own digest.
-    pub post: Option<Held>,
-    /// Recovery continuation belongs only to the launch that confirmed it.
+    /// A resume belongs only to the launch it was typed for (#389, #401): it
+    /// is not carried to the next launch, which types its own.
     pub launch_bound: bool,
-    /// The existing held-post digest carried across relaunch, without continuation.
-    pub relaunch_text: Option<String>,
 }
 
 impl Item {
-    fn for_relaunch(mut self) -> Option<Self> {
-        if self.launch_bound {
-            self.text = self.relaunch_text.take()?;
-            self.launch_bound = false;
-        }
-        Some(self)
+    fn for_relaunch(self) -> Option<Self> {
+        (!self.launch_bound).then_some(self)
     }
 }
 
@@ -138,7 +123,7 @@ impl Queue {
     }
 
     /// The queue of a seat launched again: what was kept carries over to the
-    /// new launch, except continuation bound to the old launch (#389). A
+    /// new launch, except a resume bound to the old launch (#389). A
     /// hand-over that was under way for the old one ends.
     pub fn carry(self) -> Queue {
         Queue {
@@ -156,19 +141,10 @@ impl Queue {
     }
 }
 
-/// How one item of a hand-over went.
-#[derive(Debug, PartialEq)]
-pub enum Delivered {
-    /// Given to the usage-limit hold, the seat being stopped on its limit.
-    ToLimit,
-    /// Handed to the terminal.
-    Typed,
-}
-
 /// One line of `permission_prompt::LOG_FILE` for a kept post (#346):
-/// `[prompt-hold] <kept|typed|to-limit|refused> message=<id> room=<topic id>
+/// `[prompt-hold] <kept|typed|refused> message=<id> room=<topic id>
 /// account=<account id> at=<time>`. `kept` when the room keeps it for the
-/// wait, then one of the other three when the hand-over reaches it.
+/// wait, then one of the other two when the hand-over reaches it.
 pub fn log_line(action: &str, message_id: &str, topic_id: &str, account_id: &str, at: &str) -> String {
     let token = |text: &str| -> String {
         let cleaned: String = text
@@ -188,19 +164,11 @@ pub fn log_line(action: &str, message_id: &str, topic_id: &str, account_id: &str
     )
 }
 
-/// Deliver one item of a hand-over: to the usage-limit hold when `limit` takes
-/// its post (the seat is stopped on its limit), else typed. `Err` is the item
-/// back when the terminal took nothing, for `Queue::put_back`.
-pub fn deliver(
-    item: Item,
-    limit: impl FnOnce(&Held) -> bool,
-    type_in: impl FnOnce(&str) -> bool,
-) -> Result<Delivered, Item> {
-    if item.post.as_ref().is_some_and(limit) {
-        return Ok(Delivered::ToLimit);
-    }
+/// Deliver one item of a hand-over: typed. `Err` is the item back when the
+/// terminal took nothing, for `Queue::put_back`.
+pub fn deliver(item: Item, type_in: impl FnOnce(&str) -> bool) -> Result<(), Item> {
     if type_in(&item.text) {
-        Ok(Delivered::Typed)
+        Ok(())
     } else {
         Err(item)
     }
@@ -209,31 +177,20 @@ pub fn deliver(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::codex::limit::Limit;
 
     fn post(id: &str) -> Item {
         Item {
             message_id: id.into(),
             text: format!("[pullcept] {id}"),
             launch_bound: false,
-            relaunch_text: None,
-            post: Some(Held {
-                message_id: id.into(),
-                speaker: "Lin".into(),
-                at: None,
-                content: id.into(),
-                addressed: false,
-            }),
         }
     }
 
-    fn digest(id: &str) -> Item {
+    fn resume(id: &str) -> Item {
         Item {
             message_id: id.into(),
-            text: format!("[pullcept] digest {id}"),
-            post: None,
-            launch_bound: false,
-            relaunch_text: None,
+            text: format!("[pullcept] resume {id}"),
+            launch_bound: true,
         }
     }
 
@@ -242,14 +199,13 @@ mod tests {
     fn hand_over(
         q: &mut Queue,
         waiting: impl Fn() -> bool,
-        mut limit: impl FnMut(&Held) -> bool,
         typed: &mut Vec<String>,
     ) {
         if !q.begin(waiting()) {
             return;
         }
         while let Some(item) = q.next(waiting()) {
-            match deliver(item, &mut limit, |text| {
+            match deliver(item, |text| {
                 typed.push(text.to_string());
                 true
             }) {
@@ -282,15 +238,15 @@ mod tests {
         }
         let mut typed = Vec::new();
         // Still waiting: nothing goes.
-        hand_over(&mut q, || true, |_| false, &mut typed);
+        hand_over(&mut q, || true, &mut typed);
         assert!(typed.is_empty());
         assert_eq!(q.len(), 3);
         // The wait ended.
-        hand_over(&mut q, || false, |_| false, &mut typed);
+        hand_over(&mut q, || false, &mut typed);
         assert_eq!(ids(&typed), ["a", "b", "c"]);
         assert!(q.is_empty());
         // A second hand-over hands nothing again.
-        hand_over(&mut q, || false, |_| false, &mut typed);
+        hand_over(&mut q, || false, &mut typed);
         assert_eq!(typed.len(), 3);
         // And the seat is free again.
         assert!(q.pass(false, post("d")).is_some());
@@ -355,12 +311,12 @@ mod tests {
         }
         assert!(q.begin(false));
         let item = q.next(false).unwrap();
-        let back = deliver(item, |_| false, |_| false).unwrap_err();
+        let back = deliver(item, |_| false).unwrap_err();
         q.put_back(back);
         assert_eq!(q.len(), 2);
         // A later hand-over starts from it.
         let mut typed = Vec::new();
-        hand_over(&mut q, || false, |_| false, &mut typed);
+        hand_over(&mut q, || false, &mut typed);
         assert_eq!(ids(&typed), ["a", "b"]);
     }
 
@@ -399,83 +355,27 @@ mod tests {
     }
 
     #[test]
-    fn a_wait_ending_on_a_limited_seat_gives_its_posts_to_the_limit_hold() {
-        // The permission wait and a Codex seat's usage limit at once (#294).
-        // The posts kept for the prompt are not typed while the seat is
-        // stopped on its limit; they go to the limit hold, and out once with
-        // its release.
-        let mut limit = Limit::default();
-        let mut q = Queue::new();
-        // The prompt first: the seat is free of its limit, so the queue keeps.
-        assert!(!limit.hold(|| post("a").post.unwrap()));
-        for id in ["a", "b"] {
-            assert_eq!(q.pass(true, post(id)), None);
-        }
-        // The limit begins during the wait: the limit hold is asked before
-        // the queue, and takes what comes now.
-        limit.stop(1, None);
-        assert!(limit.hold(|| post("c").post.unwrap()));
-        // The wait ends while the seat is still stopped.
-        let mut typed = Vec::new();
-        hand_over(&mut q, || false, |held| limit.hold(|| held.clone()), &mut typed);
-        assert!(typed.is_empty(), "nothing is typed into a limited seat");
-        assert!(q.is_empty(), "the queue let them go to the limit hold");
-        // The one order not kept: the limit's own first (module docs).
-        assert_eq!(
-            limit.held().iter().map(|p| p.message_id.as_str()).collect::<Vec<_>>(),
-            ["c", "a", "b"]
-        );
-        // The recovery releases each one once.
-        assert_eq!(limit.release().len(), 3);
-        assert!(limit.release().is_empty());
-    }
-
-    #[test]
-    fn a_limit_on_a_seat_that_then_waits_keeps_its_hold() {
-        // The limit first, then a prompt: every post is the limit hold's, the
-        // queue keeps nothing, and the wait's end types nothing.
-        let mut limit = Limit::default();
+    fn a_resume_kept_for_a_wait_is_typed_after_it() {
         let mut q = Queue::new();
-        limit.stop(1, None);
-        for id in ["a", "b"] {
-            assert!(limit.hold(|| post(id).post.unwrap()));
-        }
-        assert!(q.is_empty());
-        let mut typed = Vec::new();
-        hand_over(&mut q, || false, |held| limit.hold(|| held.clone()), &mut typed);
-        assert!(typed.is_empty());
-        assert_eq!(limit.held().len(), 2);
-    }
-
-    #[test]
-    fn a_recovery_during_a_wait_keeps_its_digest_for_after_the_wait() {
-        let mut limit = Limit::default();
-        let mut q = Queue::new();
-        limit.stop(1, None);
-        limit.hold(|| post("early").post.unwrap());
-        // The recovery comes while a prompt is up: its digest is kept here
-        // rather than typed onto the prompt.
-        assert_eq!(limit.release().len(), 1);
-        assert_eq!(q.pass(true, digest("notice")), None);
-        // A post after the recovery, still during the wait: the limit hold no
-        // longer takes it, the queue does.
-        assert!(!limit.hold(|| post("b").post.unwrap()));
+        assert_eq!(q.pass(true, resume("notice")), None);
         assert_eq!(q.pass(true, post("b")), None);
         let mut typed = Vec::new();
-        hand_over(&mut q, || false, |held| limit.hold(|| held.clone()), &mut typed);
-        assert_eq!(ids(&typed), ["digest notice", "b"]);
-        assert!(limit.held().is_empty());
+        hand_over(&mut q, || false, &mut typed);
+        assert_eq!(ids(&typed), ["resume notice", "b"]);
     }
 
     #[test]
-    fn a_digest_is_typed_even_if_a_new_limit_began_during_the_wait() {
-        // The digest is the limit hold's release already: it is not given back.
-        let mut limit = Limit::default();
+    fn a_resume_is_not_carried_to_another_launch() {
         let mut q = Queue::new();
-        q.pass(true, digest("notice"));
-        limit.stop(3, None);
-        let mut typed = Vec::new();
-        hand_over(&mut q, || false, |held| limit.hold(|| held.clone()), &mut typed);
-        assert_eq!(ids(&typed), ["digest notice"]);
+        q.pass(true, resume("notice"));
+        q.pass(true, post("b"));
+        let mut next_launch = q.carry();
+        assert_eq!(next_launch.len(), 1);
+        // An earlier launch's in-flight hand-over can also refuse after carry.
+        next_launch.put_first(resume("notice"));
+        assert_eq!(next_launch.len(), 1);
+        assert!(next_launch.begin(false));
+        assert_eq!(next_launch.next(false), Some(post("b")));
+        assert!(next_launch.next(false).is_none());
     }
 }
diff --git a/crates/topic-index/src/lib.rs b/crates/topic-index/src/lib.rs
index 374814f..4b3efe8 100644
--- a/crates/topic-index/src/lib.rs
+++ b/crates/topic-index/src/lib.rs
@@ -48,8 +48,8 @@ pub const TOPIC_EXTENSION: &str = "jsonl";
 /// further down keeps that scan reading `.jsonl` files and nothing else.
 pub const ATTACHMENTS_DIR: &str = "attachments";
 
-/// The directory, inside the room's, that the stopped Codex seats' mailboxes
-/// are kept under: one file per topic below it (#312). One level down for the
+/// The directory, inside the room's, that the stopped Codex seats' marks
+/// are kept under: one file per topic below it (#312, #403). One level down for the
 /// reason the attachments are.
 pub const MAILBOXES_DIR: &str = "mailboxes";
 
@@ -267,7 +267,7 @@ pub fn attachments_path(dir: &Path, topic_id: &str) -> PathBuf {
     dir.join(ATTACHMENTS_DIR).join(topic_id)
 }
 
-/// Where one topic's mailboxes live (#312). What is in the file is
+/// Where one topic's stopped-seat marks live (#312, #403). What is in the file is
 /// `mcp_config::codex::limit::Mailboxes`; here is only where it is, so that
 /// [`delete`] takes it with the topic.
 pub fn mailboxes_path(dir: &Path, topic_id: &str) -> PathBuf {
@@ -675,7 +675,7 @@ pub fn delete(dir: &Path, index: &mut TopicIndex, topic_id: &str) -> Result<(),
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
         Err(e) => return Err(format!("Failed to delete the topic's attachments: {e}")),
     }
-    // The mailboxes of its stopped seats (#312): ids of posts that are gone.
+    // The marks of its stopped seats (#312): of a topic that is gone.
     match std::fs::remove_file(mailboxes_path(dir, topic_id)) {
         Ok(()) => {}
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
diff --git a/docs/0-requirements.md b/docs/0-requirements.md
index 5abce15..7daae97 100644
--- a/docs/0-requirements.md
+++ b/docs/0-requirements.md
@@ -121,7 +121,7 @@ Claude Desktop の置き換えではない。単独作業は Desktop、並列複
 
 現在の親 ID・Claude 専用 launch nonce・PTY を照合した root transcript の構造化イベントだけで停止／回復を判定する。親の新しい rate_limit 拒否で停止し、最後の拒否より後の実モデルの正常な親 assistant 応答で回復する。子の制限、古い起動、古い履歴、使用率の低下、reset 時刻、statusLine の到着、PTY 表示文字列だけでは状態を変えない。制限は残留した委任・出力表示より優先し、subagent の実状態は削除しない。
 
-停止中も部屋の投稿はその席の端末へ通常どおり打つ（#401 で配信の保留を外した。制限中の発言はトピックの記録から読み直せる）。止まっていることは親記録の答えられていない最後の拒否から読み、再起動を越える。Codex の回復問い合わせと預かりは保つ。合成検証とマージ後の実機確認を分ける。
+停止中も部屋の投稿はその席の端末へ通常どおり打つ（#401 で配信の保留を外した。制限中の発言はトピックの記録から読み直せる）。止まっていることは親記録の答えられていない最後の拒否から読み、再起動を越える。Codex の席も #403 で預かりを外し、回復問い合わせと解除後の再開指示は保つ。合成検証とマージ後の実機確認を分ける。
 
 ## 許可待ちの席への配信保留（#346）
 
diff --git a/docs/1-room.md b/docs/1-room.md
index 35656e9..6f2a2f0 100644
--- a/docs/1-room.md
+++ b/docs/1-room.md
@@ -57,7 +57,7 @@ Pullcept (Tauri app)  =  部屋の壁
 - **札に `role` を載せる。書くのはアプリであり、発言の本文からは決して取らない（#195）。** 値は発言が部屋へ入った口から決まる（`terminal_input::role`）：
   - 画面のコマンド（`room_post`、webview の Tauri コマンド）から来た発言は `admin` である。**`admin` になるのはこれだけである。**
   - アプリが受けた MCP サーバの通知は `mcp` である（発言するアカウントの種別）。
-  - アプリ自身の知らせ——Codex の席の利用上限での停止と解除、解除確定後に本人の中断作業の再開指示と預かり発言のまとめを同じ入力で一度渡す一通（預かり 0 件でも再開指示を渡す、#389 / #294、「[Codex の席が利用上限で止まったとき](3-accounts.md#codex-の席が利用上限で止まったとき294)」）——は `app` である。発言者は `Pullcept（自動通知）` で、アカウントを持たない。どのアカウントの種別でもなく、ソケットからは作らない。
+  - アプリ自身の知らせ——Codex の席の利用上限での停止と解除、解除確定後に本人へ一度打つ中断作業の再開指示（#389 / #294。#403 から預かり発言のまとめは付けない、「[Codex の席が利用上限で止まったとき](3-accounts.md#codex-の席が利用上限で止まったとき294)」）——は `app` である。発言者は `Pullcept（自動通知）` で、アカウントを持たない。どのアカウントの種別でもなく、ソケットからは作らない。
   - 部屋ソケットから来た発言は、その席が `hello` で名乗ったアカウントの種別である（`claude_code` / `cli`）。名乗りが無い、アプリに無いアカウントを名乗った、または `admin` や `mcp` のアカウントを名乗った接続は `unknown` である。
 - **`admin` はソケットから作らない（Master 判断、2026-09-28）。** 部屋のトークンは部屋全体で一つで、各セッションの `.mcp.json` に書かれている。`hello` の `account_id` も検証されない。セッションは自分で二本目のソケットを張り、`admin` のアカウント id を名乗れる。したがってソケットから来た発言は、名乗った id に依らず `admin` にしない。セッションが届かない口——webview の中のコマンド——だけが `admin` を作る。席ごとのトークンで id を縛る形より部品が少ない。
 - **本物の札は一行目だけである。** 一行目を書けるのはアプリだけであり、本文は送信キーを持たない（下記）。二行目以降に札の形の行があっても、それは本文である。この規則の置き場はサイドカーの `instructions` 一か所である（Master 判断、2026-09-28）——AI 側（キャラクター・CLAUDE.md 等）に作法を書き込まずに済み、CLI の種別にも依らない。
diff --git a/docs/2-screen.md b/docs/2-screen.md
index d71e994..995ff5e 100644
--- a/docs/2-screen.md
+++ b/docs/2-screen.md
@@ -553,10 +553,10 @@ Master「コメント書き込み欄の上にある下までスクロールボ
 - **待ちは席の hook から読む。** 本体かサブエージェントのどれか一つでも許可待ちであれば待ちとする（`Activity::any_waiting`）。どのエージェントの画面も同じ一つの端末に出るためである。待ちの始まりと終わりは上の「許可待ち」と同じである：`PermissionRequest` で始まり、人が端末に打った答えのキー（本体だけ）、そのエージェントの次の `PreToolUse`、同じツール名の終わり、ターンの区切り、`SubagentStop`、読めない `PostToolUse` で終わる。
 - **預かるかどうかは、発言を端末の列へ渡すときに決める。** 列で順番を待っている間に許可の画面が出た発言は、そのまま打たれる。`PermissionRequest` の hook は画面より約 3 秒早く届く（上の「カードは `PermissionRequest` の hook から出る」）ため、この隙間は短い。
 - **待ちが終わってすぐには打たない。** 終わりを聞いてから 1.5 秒（`prompt_hold::RELEASE_GRACE`）待ち、その時点でまだどのエージェントも待っていなければ渡し始める。端末で答えた直後に次の許可（並列の別のツール）が続くことがあり、その要求の hook は画面より前に届くためである。渡している途中で待ちが始まれば、そこで止め、残りは次の待ちの終わりまで預かる。
-- **順番を守り、一度だけ渡す。** 預かっている発言があるか、渡している途中の間は、待ちが終わっていても新しい発言はその後ろへ並ぶ。端末が受け付けなかった発言は列の先頭へ戻し、捨てない。席を起動し直したときは、預かった発言を新しい起動へ持ち越す。ただし Codex の席の利用上限の解除確定後の作業再開入力（#389）と、Claude の席へ解除予定時刻に打つ再開の指示（#401）は、その起動にだけ渡し、別の起動へは再開指示を持ち越さない。まとめを同梱していた場合は、従来の預かり発言のまとめだけを同じ既読位置で持ち越す。
-- **利用上限の預かりが先である（#294）。** 利用上限で止まっている Codex の席への発言は、今までどおりその預かり（受け箱）に入り、この列には来ない。許可待ちが終わったときに席が利用上限で止まっていれば、預かった発言は打たずに利用上限の預かりへ移し、解除のまとめと一緒に一度だけ渡る。利用上限の解除のまとめを打つときに席が許可待ちであれば、まとめもこの列で預かり、待ちの後に打つ。まとめは解除そのものであるため、その後にまた上限で止まっていても利用上限の預かりへは戻さない。順番が一つだけ崩れる場合がある：許可待ちの間にこの列へ入った発言は、その待ちの途中で利用上限が始まると、利用上限が預かった発言の後ろに並ぶ。
+- **順番を守り、一度だけ渡す。** 預かっている発言があるか、渡している途中の間は、待ちが終わっていても新しい発言はその後ろへ並ぶ。端末が受け付けなかった発言は列の先頭へ戻し、捨てない。席を起動し直したときは、預かった発言を新しい起動へ持ち越す。ただし Codex の席の利用上限の解除確定後の再開の指示（#389）と、Claude の席へ解除予定時刻に打つ再開の指示（#401）は、その起動にだけ渡し、別の起動へは持ち越さない。
+- **利用上限では預からない（Claude #401、Codex #403）。** 利用上限で止まっている席への発言も、ほかの発言と同じくこの列を通る。解除後の再開の指示を打つときに席が許可待ちであれば、指示もこの列で預かり、待ちの後に打つ。
 - **端末で答えることは変えない（#336）。** 預かるのは部屋がアプリから打ち込む発言だけである。人が端末の欄に打つキーは今までどおり届き、許可の画面に答えられる。
-- **記録する。** 預かった発言と、渡したときの行き先（`typed`：端末へ打った、`to-limit`：利用上限の預かりへ移した、`refused`：端末が受け付けず列へ戻した）を、上の `logs\permission-requests.log` に一行ずつ書く（`prompt_hold::log_line`）。発言の本文は書かず、`message_id` だけを書く。
+- **記録する。** 預かった発言と、渡したときの行き先（`typed`：端末へ打った、`refused`：端末が受け付けず列へ戻した）を、上の `logs\permission-requests.log` に一行ずつ書く（`prompt_hold::log_line`）。発言の本文は書かず、`message_id` だけを書く。
 - **預かりはメモリの中だけである。** 席を閉じたまま起動し直さなかったとき、Pullcept が落ちたときは、預かっていた発言は端末へは届かない。発言そのものはトピックの記録にあり、`read_room_history` で読める（「[受容したトレードオフ](6-tradeoffs.md#受容したトレードオフ)」）。
 
 ## サイドバーの開閉
diff --git a/docs/3-accounts.md b/docs/3-accounts.md
index af3dcc2..572a521 100644
--- a/docs/3-accounts.md
+++ b/docs/3-accounts.md
@@ -609,42 +609,41 @@ CLI は `.mcp.json` のサーバのうち承認されていないものを、セ
 
 ### Codex の席が利用上限で止まったとき（#294）
 
-**Claude Code の席では手作りの hook がしていること（止まったら知らせ、解除後に再開させる）を、Codex の席ではアプリが担う。** Codex には「エラーで止まった」ときの hook が無く（#290）、止まった席にも部屋の発言は端末へ打たれ続け、届くたびに失敗するターンが走っていた。Claude Code の席の挙動は変えない——以下はどれも Codex CLI の席だけに働く。
+**Claude Code の席では手作りの hook がしていること（止まったら知らせ、解除後に再開させる）を、Codex の席ではアプリが担う。** Codex には「エラーで止まった」ときの hook が無い（#290）。Claude Code の席の挙動は変えない——以下はどれも Codex CLI の席だけに働く。
 
 **止まったことは rollout から読む。使用率からは読まない。** 利用上限で止まったターンは、rollout に `event_msg` / `task_complete` の行を書き、その `payload.error.codex_error_info` が `usage_limit_exceeded` である（2026-10-05、0.160.0 の実セッションで観測）。アプリは五欄と同じ見張り（上記）でこの行を読み、その席を「止まった」とする。rollout の使用率は止まった席で 99.0 のまま動かず（#290）、100% を待つ形では「制限中」が出なかった。パネルの「制限中」はこの判定から出し（`session-stats` の `limited`）、Codex の席では使用率の 100% を見ない。
 
-**止まったら部屋に一通知らせる。** 発言者は `Pullcept（自動通知）`（アカウントを持たない）、札の `role` は `app` である（「[発言は端末へ入る](1-room.md#発言は端末へ入る183--195)」）。文面は止まった席の名前と解除予定（この PC の現地時刻、`10月5日 22:45` の形）。解除予定は、止まった時点で一度だけ Codex の app-server に `account/rateLimits/read` を聞き、`ordinaryUsageAllowed: false` の答えの `resetsAt` を採る。聞けなければ rollout の最後の `token_count` の `resets_at` を採り、どちらも無ければ「分かっていません」と書く。どちらも、使用率がいちばん高い窓（二つが同じなら遅いほう）の解除時刻である。この知らせは止まった席の端末へは打たない——打てば走れないターンが一つ増える。
+**止まったら部屋に一通知らせる。** 発言者は `Pullcept（自動通知）`（アカウントを持たない）、札の `role` は `app` である（「[発言は端末へ入る](1-room.md#発言は端末へ入る183--195)」）。文面は止まった席の名前と解除予定（この PC の現地時刻、`10月5日 22:45` の形）。解除予定は、止まった時点で一度だけ Codex の app-server に `account/rateLimits/read` を聞き、`ordinaryUsageAllowed: false` の答えの `resetsAt` を採る。聞けなければ rollout の最後の `token_count` の `resets_at` を採り、どちらも無ければ「分かっていません」と書く。どちらも、使用率がいちばん高い窓（二つが同じなら遅いほう）の解除時刻である。この知らせは止まった席の端末へは打たない——打てば走れないターンが一つ増える。止まっている相手に作業を振らないための知らせである。
 
-**止まっている間、部屋の発言はその席の端末へ打たず、アプリが預かる。** 他の席への打ち込みは変わらない。預かるのは端末への打ち込みだけであり、床・ログ・画面の会話面は変わらない。預かった発言の `message_id` は、預かるたびにその席の受け箱へ書き足す（下記「止まっている席の受け箱」、#312）。
+**止まっている間も、部屋の発言はその席の端末へ打つ（#403）。** 預からない（#401 で Claude の席から外したのと揃えた）。制限中に打たれた発言は、Codex が会話に user の発言として残し、そのターンが利用上限で終わる——捨てられはしない（2026-10-12、ローカルの rollout で `response_item` の user の発言の後に `usage_limit_exceeded` の `task_complete` が続くことを確認）。代わりに、発言のたびに利用上限で終わるターンが一つ増える。解除後は、席が必要ならトピックの記録を `read_room_history` で読む。#294 から #403 まではアプリが預かり、受け箱に id を書き、解除のときにまとめの一通を渡していた。Master の観測（2026-10-12）で「制限中に部屋の発言が来ない」ことが問題になり、外した。
 
 **解除はアプリが聞いて確かめる。推測しない。** Codex には「解除された」通知が無く、プロトコルは「使用率や解除時刻から回復を推測してはならない」と書く（`app-server-protocol/src/protocol/v2/account.rs:333`）。アプリは止まっている席についてだけ `account/rateLimits/read` を聞き、`ordinaryUsageAllowed` が `true` と答えたときに限って解除とする。`false`・`null`・エラー・応答なし・壊れた応答は、どれも「まだ止まっている」である。止まっていない席には聞かない。
 
 - 最初に聞くのは解除予定の 30 秒後である。解除予定が分からない、または既に過ぎていれば 1 分後。
 - まだ使えなければ 1 分・2 分・5 分・10 分・15 分と間を空け、以後は 15 分ごとに聞く。答えが先の解除予定を名指せば（5 時間の後に週次で止まった等）、その 30 秒後まで待つ。
-- 止まっている間に端末で直接打ったターンがエラー無しで終われば、次の問い合わせを今に繰り上げる。それ自体を解除とはしない。
-- 止まっている間に部屋の発言を預かったら、次の問い合わせを今に繰り上げる（#377）。ただし、前の問い合わせから 60 秒は空ける（`HELD_GAP`）。解除予定まで待つと、その前に上限を手でリセットしても、予定の時刻まで解除に気づけない——2026-10-11 に Master がリセットしたとき、解除予定は 10/14 だった。タイマーで聞き直さず、発言を契機にするのは Master の案である（「タイマー方式じゃなく、発言があった時にってするのはどう？」）。解除を急いで知る必要があるのは、渡したい発言があるときだけだからである。誰も発言しない間は、今までどおり解除予定まで待つ。
-- app-server に繋がらなければ解除を確かめられず、席は「制限中」のまま、発言は預かったままである（「[受容したトレードオフ](6-tradeoffs.md#受容したトレードオフ)」）。
+- 止まっている間にターンがエラー無しで終われば（端末で直接打った、または上限を手でリセットした後に部屋の発言が通った）、次の問い合わせを今に繰り上げる。それ自体を解除とはしない。上限を手でリセットしても、誰かが発言すればそのターンが通り、その場で聞き直して解除に気づく（#377 の「発言を契機にする」は、預かりを外した後はこの形で残る。#377 の `HELD_GAP` は預かった発言の契機だったため無くなった）。
+- app-server に繋がらなければ解除を確かめられず、席は「制限中」のまま、再開の指示は打たれない（「[受容したトレードオフ](6-tradeoffs.md#受容したトレードオフ)」）。
 
-**解除を確かめたら、部屋に一通、席に一通。** 部屋へは解除を知らせる（`Pullcept（自動通知）`、`app`。その席の端末へは打たない）。席へは、預かった発言を全部は渡さず、次の一通を打つ：「制限中に部屋で N 件の発言がありました。必要なら read_room_history で読んでください。」その席宛て（`to` に席の名前がある）の発言だけは、発言者・時刻・`message_id` と本文を続けて付ける。預かった発言が無くても、解除を確定した本人の親セッションへ「中断していた作業を再開してください。中断していた作業がなければ、そのまま待機してください。」と一度入力する（#389）。預かりがある場合は、その再開指示と上記のまとめを同じ入力に含める。この一通の札の `message_id` は、それが勘定に入れた最新の発言（部屋への解除の知らせ。それが入らなかったときは預かった最後の発言）の id である——席が次の `say_to_room` の `last_seen` に使えば、預かった発言で弾かれない。一通を打ってから席を「制限中」から戻すまでは一つの錠の内で行い、その後に届いた発言は一通の後に打たれる。
+**解除を確かめたら、部屋に一通、席に一通。** 部屋へは解除を知らせ、その席の端末へ再開の指示を打つと言う（`Pullcept（自動通知）`、`app`。その席の端末へは打たない）。席へは、「利用上限の解除を確認しました。中断していた作業を再開してください。中断していた作業がなければ、そのまま待機してください。」を一度だけ打つ（#389、`limit::CONTINUE`）。まとめは付けない。この一通の札の `message_id` は部屋への解除の知らせの id である——席が次の `say_to_room` の `last_seen` に使えば、その知らせで弾かれない。席を「制限中」から戻すことと一通を打つことは一つの錠の内で行い、その後に届いた発言は一通の後に打たれる。
 
-**止まっている席の受け箱（#312）。** 預かりがメモリの中だけにあると、止まった席のセッションが終わるか Pullcept が起き直したときに消え、そのあと上限が外れていても、起き直した席は止まっていない状態から始まるので解除の流れに進まず、止まっていたあいだの発言のまとめが届かない（2026-10-07 に実際に起きた）。そこで、止まっている席にだけ、再起動をまたいで残る小さな記録——受け箱——を持つ。
+**打った後の分かれ道（#403、#401 と同じ考え方）。**
 
-- 受け箱は、預かった発言の `message_id` の並びだけである。発言そのものは写さず、解除のときに部屋の記録（`read_room_history` と同じ記録）から読む。
-- 席が止まったときに受け箱を作り（まだ空）、発言を一つ預かるたびにその id を書き足す。書き足しは預かるのと同じ錠の内で行い、Pullcept が落ちても、そこまでの id は残る。
-- 置き場所は、トピックの記録と同じ部屋のディレクトリの `mailboxes/<トピックの id>.json` で、アカウントごとに id の並びを持つ。トピックを消せば一緒に消える（`topic_index::delete`）。
-- 席を起動したとき、そのトピックとアカウントの受け箱が残っていれば、その席は止まった状態から始まる。部屋の発言は、最初の一つから打たずに預かる——受け箱を読むのは、席が部屋から打ち込める状態になる前である。部屋への停止の知らせは出し直さない（止まったときに出している）。パネルにはその時点で「制限中」を一度送る。
-- 止まった状態から始まった席は、最初の見張りの一回目で app-server に聞く。解除予定の時刻は待たない（受け箱には解除予定を残さず、残っていたとしても、もう過ぎているかもしれない）。rollout がまだ無くても聞く——問い合わせは rollout が見つかるのを待たない。「まだ止まっている」と答えれば、今までどおり預かり、上の間隔で聞き直す。
-- 解除を確かめたら、受け箱の id の発言を記録から読み、件数とまとめにする。今の起動のメモリが預かった発言のうち受け箱に無いもの（受け箱へ書けなかったもの）はその後に足し、記録に無いもの（記録を読んだ後に届いたもの）はメモリの値をそのまま使う。どちらにも無い id は飛ばす。
-- 受け箱は、まとめの一通を席へ打つ前に消す。その間で落ちれば、席はまとめを受け取りそこなう。逆の順で落ちれば同じまとめを二度打つことになり、そちらを避けた。
-- 席を閉じていたあいだ（Pullcept が落ちていたあいだを含む）の発言は受け箱に入らない。預かったのではなく、その席が部屋にいなかっただけだからである。途中から入る席は、必要な過去を自分で `read_room_history` で探す（2026-10-07 マスター判断、#115 と同じ線）。受け箱を最初と最後の id の範囲にしないのも同じ理由である——止まったまま落ちて起き直すと、落ちていたあいだの発言が範囲に入ってしまう。
-- 「止まりました」「解除を確かめました」の知らせを記録から探すことはしない（#310 / #311 の数え直しはこれに置き換えた）。止まっているかどうかを決めるのは受け箱があるかどうか、渡せるかどうかを決めるのは app-server の答えだけである。
-- まとめに本文を付ける「その席宛て」は、預かったときに `to` に席の名前があった発言と、記録で `to` にその席の名前がある発言である。席の名前は、今の名前と、記録の中でその席のアカウントが発言したときの名前の全部とする（名前を変えて起動し直した席のため）。ただし別のアカウントが発言に使った名前は、その席の名前としない。
+- ターンが始まるか終われば、指示への応答である。それ以上は打たない。
+- ターンが利用上限で終われば、まだ解けていなかっただけである。新しい停止として扱い（部屋への停止の知らせも出る）、次に解除を確かめたときにもう一度打つ。
+- どちらも 120 秒無ければ（`limit::ANSWER_WAIT`、Claude の席と同じ）、利用上限以外の理由（起動時の選択画面、ログイン切れ、信頼の確認など）で止まっているとみなし、部屋に一度だけ「端末を見てください」と知らせる。選択肢に入力が入る危険があるため打ち直さない。その席が後でターンを正常に終えたら、戻ったことを一度だけ知らせる（席ごと、起動をまたいで覚える）。
 
-記録は解除の知らせを出す前に一度だけ読む。解除の知らせと停止の知らせは、もともとその席の端末へは打たないので、預からず、受け箱にも入らない。
+**止まっている席の印（#312）。** 止まったことがメモリの中だけにあると、止まった席のセッションが終わるか Pullcept が起き直したときに消え、そのあと上限が外れていても、起き直した席は止まっていない状態から始まるので解除の流れに進まず、再開の指示が届かない（2026-10-07 に実際に起きた）。そこで、止まっている席にだけ、再起動をまたいで残る小さな印を持つ。
+
+- 置き場所は、トピックの記録と同じ部屋のディレクトリの `mailboxes/<トピックの id>.json` で、止まっているアカウントごとに一つの項目（値は空の並び）を持つ。トピックを消せば一緒に消える（`topic_index::delete`）。#403 より前に書かれた、預かった発言の id を持つファイルも、同じ印として読む。
+- 席が止まったときに印を書く。
+- 席を起動したとき、そのトピックとアカウントの印が残っていれば、その席は止まった状態から始まる。部屋への停止の知らせは出し直さない（止まったときに出している）。パネルにはその時点で「制限中」を一度送る。
+- 止まった状態から始まった席は、最初の見張りの一回目で app-server に聞く。解除予定の時刻は待たない（印には解除予定を残さず、残っていたとしても、もう過ぎているかもしれない）。rollout がまだ無くても聞く——問い合わせは rollout が見つかるのを待たない。「まだ止まっている」と答えれば、上の間隔で聞き直す。
+- 再開の指示を打つのは、解除を確かめた時点で席を占めている起動である。問い合わせの間に席が起動し直されていれば、古い起動は打たず、印も消さない。新しい起動は印から止まった状態で始まり、自分で聞いて打つ——止まった時の起動と同じかどうかで指示を捨てることはない。
+- 印は、再開の指示を席へ打つ前に消す。その間で落ちれば、席は指示を受け取りそこなう。逆の順で落ちれば同じ指示を二度打つことになり、そちらを避けた。
 
 **app-server へは、問い合わせのたびに `codex app-server` を一つ起動し、stdio で聞く。** 送るのは一行一つの JSON で、`initialize`・`initialized`・`account/rateLimits/read` の三つだけである。会話（thread）は始めず、モデルは呼ばない。標準入力を閉じればプロセスは終わる（2026-10-05、0.160.0 で実測。全体で 0.5 秒未満）。20 秒で答えが無ければプロセスの木ごと止め、「応答なし」とする。起動の行は席のアカウントの起動コマンドに `app-server` を付けたもの（`.exe` 以外は `cmd.exe /C` 経由）で、席の環境変数・作業ディレクトリ・`CODEX_HOME` をそのまま渡す——聞かれるのはその席のアカウントである。共有 daemon の AF_UNIX ソケット（`~/.codex/app-server-control/app-server-control.sock`）でも聞ける（#290 で実測）が、採らない：Rust の標準ライブラリは Windows で AF_UNIX を持たず、ソケットは WebSocket の枠付けを要し、daemon は起動時の環境を全クライアントで共有するため席ごとのアカウントを区別できない。daemon を起動させる副作用も持たない。
 
-**読み方とその判断はアプリから切り離して置く。** rollout の行から止まりと解除時刻を読むこと、app-server の答えの読み方、止まり・問い合わせの予定・預かり・解除の状態、受け箱のファイルと受け箱からのまとめ（`Mailboxes`・`mailbox`）、一通の文面は `crates/mcp-config`（`codex::limit`）にあり、テストで確かめる。受け箱の置き場所とトピックと一緒に消すことは `crates/topic-index`（`mailboxes_path`・`delete`）にある。端末への打ち込みで預かるかどうかを決めるのは `room::type_into_sessions`、問い合わせ・知らせ・受け箱の読み書き・起動のときの確認（`Limiter::open`）は `src-tauri/src/codex_limit.rs`、見張りは五欄と同じ `codex_status.rs` の一本である。
+**読み方とその判断はアプリから切り離して置く。** rollout の行から止まり・ターンの始まり・解除時刻を読むこと（`codex::status::Tail`）、app-server の答えの読み方、止まり・問い合わせの予定・解除・再開の指示への応答待ちの状態、印のファイル（`Mailboxes`）、知らせと指示の文面は `crates/mcp-config`（`codex::limit`）にあり、テストで確かめる。印の置き場所とトピックと一緒に消すことは `crates/topic-index`（`mailboxes_path`・`delete`）にある。問い合わせ・知らせ・印の読み書き・起動のときの確認（`Limiter::open`）・再開の指示の打ち込みは `src-tauri/src/codex_limit.rs`、見張りは五欄と同じ `codex_status.rs` の一本である。
 
 ### Codex の席は自分の様子を app-server の知らせで知らせる（#326）
 
diff --git a/docs/4-status.md b/docs/4-status.md
index cf5342c..5ae992c 100644
--- a/docs/4-status.md
+++ b/docs/4-status.md
@@ -1,5 +1,13 @@
 # 実装状況
 
+## Codex の席の預かりを外す（#403、2026-10-12）
+
+Codex の席が利用上限で止まっている間も、部屋の発言を預からずその席の端末へ打つようにした（#401 で Claude の席から外したのと揃えた）。制限中に打った入力は、Codex が会話に user の発言として残してターンを利用上限で終える——捨てない（2026-10-12、ローカルの rollout で確認）。解除の確認（`account/rateLimits/read`）と止まったときの部屋への知らせは今までどおりである。解除を確かめたら、席を占めている起動が再開の指示（#389）を一度だけ打ち、まとめは付けない。打った後にターンが始まるか終われば応答とし、利用上限で終われば新しい停止として次の解除でもう一度打つ。どちらも 120 秒無ければ部屋へ一度だけ「端末を見てください」と知らせて打ち直さず、その席が後でターンを正常に終えたら戻ったことを一度だけ知らせる。受け箱は「止まっている印」だけになった（id を持たない）。預かり（`CodexLimits::hold`）、受け箱からのまとめ（`digest`・`mailbox`）、預かった発言での問い合わせの繰り上げ（#377 の `HELD_GAP`）、`limit_recovery`、許可待ちの列から利用上限の預かりへ移す経路（`to-limit`）は無くなった（「[Codex の席が利用上限で止まったとき](3-accounts.md#codex-の席が利用上限で止まったとき294)」）。
+
+**確かめた範囲:** `crates/mcp-config/src/codex/limit.rs` のテストが、止まり・問い合わせの予定・解除の確認、再開の指示への応答（ターン・利用上限・120 秒の無応答）、知らせが預かりを言わないこと、印のファイルの読み書き（#403 前の id 付きのファイルを同じ印として読むこと）を確かめる。`status.rs` のテストがターンの始まりを一度だけ渡すこと、`prompt_hold.rs` のテストが再開の指示を許可待ちの後に打ち、別の起動へ持ち越さないことを確かめる。`src-tauri` のコンパイルは通っている。
+
+**未確認（実機では確かめていない）:** 止まっている Codex の席に部屋の発言が打たれ、そのターンが利用上限で終わっても部屋への停止の知らせが重ならないこと。解除後に再開の指示が一度だけ打たれ、席が作業を再開すること。止まったまま起動し直した席に、解除後に指示が打たれること。ログイン切れなどで止まった席に「別の原因」の知らせが一度だけ出ること。
+
 ## Claude の親の自動再開を簡素にし、預かりを外す（#401、2026-10-12）
 
 Claude の親が利用上限で止まっている間も、部屋の発言を預からずその席の端末へ打つようにした。解除予定時刻の 30 秒後には、その時刻に席を占めている端末へ「再開して」の指示を一度打つ。止まった時の起動との照合（topic・account・nonce・PTY）と、合図を部屋の通知として本人だけ預かりを迂回させる経路（#399 / #400）は取り除いた。端末がいなければ打たず、親記録の答えられていない拒否を印として、次の起動で打つ。打った後に制限エラーなら打ち直し、どちらの答えも無ければ別の原因として部屋へ一度だけ知らせて打ち直さず、その席が後で正常に応答したら戻ったことを一度だけ知らせる。止まったときの知らせは今までどおり出す。判断ごとに `logs\claude-resume.log` へ一行書く（「[解除予定時刻に親の再開を試す](3-accounts.md#解除予定時刻に親の再開を試す357)」）。Claude の受け箱（`*.claude-mailboxes.json`）と解除後のまとめ・再開入力（#389 の Claude 側）は無くなった。
@@ -175,7 +183,7 @@ app-server 方式の Codex の席について、席の server がアプリへ送
 - 起動したアカウントと登録のアカウントが違うサイドカーは部屋に入らないこと（#208。起動した CLI のプロセスに載せる `PULLCEPT_LAUNCHED_AS`、サイドカーでの `PULLCEPT_ACCOUNT_ID` との突き合わせ、断ったサイドカーは道具も作法も出さず stderr に理由を残すこと、アプリが起動していない CLI が読んだ登録も入らないこと、アカウントの環境変数の欄での名前の拒否）
 - 起動した CLI のプロセスに載せる部屋 id（#264。`PULLCEPT_ROOM_ID`、登録の `env` と同じ名前と値、アカウントの環境変数の欄での名前の拒否）
 - セッションの様子の報告（#155 / #152。起動する行の `statusLine`、`sidecar/src/status.mjs` が JSON をそのまま `/hooks/status/<トピック>/<アカウント>` へ送り端末へ 1 行返す形、アドレスが名指す席、`cmd.exe` が反応する文字を載せないこと、環境から解決するトークン、行に載せる語の文字集合の判定と通らないときの不掲載、パネルのモデル・エフォート・5 時間・週次・コンテキストの五欄、欠けた値の「—」、動いたときだけの更新）
-- Codex CLI の席の利用上限（#294、「[Codex の席が利用上限で止まったとき](3-accounts.md#codex-の席が利用上限で止まったとき294)」。rollout の `task_complete` の `usage_limit_exceeded` で止まりを読むこと、パネルの「制限中」を使用率でなくその判定から出すこと（`session-stats` の `limited`）、止まった時点で一度 app-server に解除予定を聞き部屋へ `Pullcept`／`app` で一通知らせること、止まっている間その席の端末へ部屋の発言を打たず預かること、止まっている席だけを解除予定の 30 秒後から間を空けて `account/rateLimits/read` で聞くこと、`ordinaryUsageAllowed: true` だけを解除とし繋がらなければ止まったままにすること、解除で部屋へ一通・席へ要約の一通（席宛ての発言だけ本文付き）を打つこと、止まっている席の受け箱（#312。預かった発言の id の並びを預かるたびにトピックの記録の隣のファイルへ書き足すこと、起動した席は受け箱があれば止まった状態から始まり、rollout を待たずにすぐ問い合わせ、「制限中」を一度送ること、解除のときに受け箱の id の発言を記録から読んで件数とまとめにし、受け箱を消すこと、席を閉じていたあいだの発言は入れないこと、トピックを消せば受け箱も消えること。#310 の記録からの数え直しはこれに置き換えた）、問い合わせを `codex app-server` の stdio で行うこと、Claude Code の席を変えないこと）
+- Codex CLI の席の利用上限（#294、「[Codex の席が利用上限で止まったとき](3-accounts.md#codex-の席が利用上限で止まったとき294)」。rollout の `task_complete` の `usage_limit_exceeded` で止まりを読むこと、パネルの「制限中」を使用率でなくその判定から出すこと（`session-stats` の `limited`）、止まった時点で一度 app-server に解除予定を聞き部屋へ `Pullcept`／`app` で一通知らせること、止まっている間その席の端末へ部屋の発言を打たず預かること（#403 で外した）、止まっている席だけを解除予定の 30 秒後から間を空けて `account/rateLimits/read` で聞くこと、`ordinaryUsageAllowed: true` だけを解除とし繋がらなければ止まったままにすること、解除で部屋へ一通・席へ要約の一通（席宛ての発言だけ本文付き）を打つこと（#403 で再開の指示だけにした）、止まっている席の受け箱（#312。#403 で止まっている印だけにした。預かった発言の id の並びを預かるたびにトピックの記録の隣のファイルへ書き足すこと、起動した席は受け箱があれば止まった状態から始まり、rollout を待たずにすぐ問い合わせ、「制限中」を一度送ること、解除のときに受け箱の id の発言を記録から読んで件数とまとめにし、受け箱を消すこと、席を閉じていたあいだの発言は入れないこと、トピックを消せば受け箱も消えること。#310 の記録からの数え直しはこれに置き換えた）、問い合わせを `codex app-server` の stdio で行うこと、Claude Code の席を変えないこと）
 - Codex CLI の席の五欄（#283、「[Codex の席は自分の様子を rollout で知らせる](3-accounts.md#codex-の席は自分の様子を-rollout-で知らせる283)」。rollout の `turn_context` と `token_count` の行から読むこと、Claude Code の席と同じ `session-stats` で画面へ渡すこと、末尾の追記分だけを読むこと、壊れた行・知らない行・欠けた欄・長すぎる行で止まらず読めない欄を「—」のままにすること、窓の長さによる 5 時間と週次の見分けと `codex` 以外の枠を採らないこと、再開では起動時点のファイル長から読むこと、新規起動で id とファイルの出現を待って探し直すこと）
 - Codex CLI の席の代替画面を使わない起動（#293、「[Codex CLI の起動と再開](3-accounts.md#codex-cli-の起動と再開272)」。新規起動と再開の行の末尾に `--no-alt-screen` を足すこと、起動オプションが `--no-alt-screen` または鍵 `tui.alternate_screen` の `-c` / `--config` を持つときは足さないこと、`Claude Code` の行は変えないこと）
 - Codex CLI の部屋の MCP を起動の行だけで渡すこと（#297、「[Codex CLI の起動と再開](3-accounts.md#codex-cli-の起動と再開272)」。`.codex/config.toml` に書かないこと、有効 cwd に `.codex` フォルダーを用意すること、以前の版が書いたアプリの欄を起動時に消し他の欄・キー・コメントを残すこと、行に他の席の名前を載せないこと、Claude の席の `.mcp.json` を変えないこと）
diff --git a/docs/6-tradeoffs.md b/docs/6-tradeoffs.md
index d635452..55aaa92 100644
--- a/docs/6-tradeoffs.md
+++ b/docs/6-tradeoffs.md
@@ -12,7 +12,7 @@ native ID は初回の実会話で取得するため、起動直後にはまだ
 | 決定 | 代償 |
 |---|---|
 | Claude の親の再開は端末への指示で確かめる（#357、#401） | 指示は会話の一ターンとして記録に残り、まだ止まっていれば試すたびに一つ増える（間は 1 分から 15 分へ広げる）。Claude には Codex の `account/rateLimits/read` にあたる、会話を使わない問い合わせが無い。答えが無ければ別の原因とみなして打ち直さないので、選択画面に指示が重ならない代わりに、その席は人が端末で見るまで止まったままである。解除予定の分からない停止も、次の拒否が解除予定を名指すまでは自動では試さない。止まったまま起動し直した席の予定は、その親記録の起動前の末尾 4 MiB にある最後の拒否から組み直す（#366）。その範囲より前にしか拒否が無い席は自動では試さない。答えの無かった指示のあとに起動し直した席には、起動直後にもう一度だけ指示を打つ——起動し直すことを人の再試行と同じに扱う。席を占める端末の起動を照合しないため、止まった時と違う起動にも打つ |
-| Claude の席には制限中の投稿を預からない（#401） | 止まっている席の端末にも部屋の発言が打たれ、それぞれが制限エラーのターンを一つずつ起こす。解除後に一通のまとめは渡らず、席は必要ならトピックの記録を `read_room_history` で読む。預かりと、それを本人だけ迂回する再開の合図の照合が、再起動で合図を捨てる原因になったため外した |
+| 制限中の投稿を預からない（Claude #401、Codex #403） | 止まっている席の端末にも部屋の発言が打たれ、それぞれが制限エラーのターンを一つずつ起こす。解除後に一通のまとめは渡らず、席は必要ならトピックの記録を `read_room_history` で読む。預かりと、それを本人だけ迂回する再開の合図の照合が、再起動で合図を捨てる原因になったため外した。Codex の席も、制限中に部屋の発言が来ないことが問題になり外した（Codex は制限中の入力を会話に残し、捨てない） |
 | 許可待ちの席に預けた発言はメモリの中だけにある（#346） | 席を閉じたまま起動し直さなかったとき、Pullcept が落ちたときは、預かっていた発言はその席の端末へ届かない。発言はトピックの記録にあり、`read_room_history` で読める。待ちは数十秒から数分であり、利用上限の受け箱（#312）のようにファイルへ書くほどの長さではない。hook が待ちの終わりを取りこぼせば、次の合図まで預かったままになる |
 | Codex の app-server 方式を既定にしない（#299） | 切り替えたアカウントだけが新しい方式で立ち、他は hook 方式のままである。二つの方式が並ぶあいだ、起動の道筋は二本ある。実モデルの一往復でキャラどおりに答えることを確かめるまで、既定は変えない |
 | Codex の app-server file mode は共通指示の native discovery を毎回行う（#303） | プレビュー・起動・再開で、キャラ本文の検証に加え、モデルを呼ばない `debug prompt-input` を二回行う。追加のプロセスと待ち時間を使うが、`developerInstructions` が利用者の指示を置き換えるため省かない。取得失敗は共通指示を落として進めず止める。各実行の上限は15秒・出力8 MiBである |
@@ -37,10 +37,9 @@ native ID は初回の実会話で取得するため、起動直後にはまだ
 | 起動したセッションで利用者のステータスラインが出ない（#155） | `statusLine` はリストではないため上の層が丸ごと勝つ。その人が書いた行は、このアプリから起動したセッションでは出ない。合成するには利用者の設定ファイルを読むことになり、CLI に合わせて保つものが一つ増える。キャラクター（`outputStyle`）が既に持っている形である |
 | Codex の rollout の行の形に依存する（#283） | 五欄の出所は Codex が公開していない会話記録の形であり、2026-10-05 の 0.160.0 の観測だけに基づく。版が変わって読めなくなった欄は「—」になり、止まらないことだけを保証し、読めることは保証しない。Codex はステータスラインのコマンドを持たず、他に五欄の出所が無い |
 | Codex の席の「止まった」が rollout の行の形に依存する（#294） | 停止の判定は `task_complete` の `error.codex_error_info` が `usage_limit_exceeded` であることで、2026-10-05 の 0.160.0 の観測だけに基づく。版が変わって読めなくなれば、止まった席は「制限中」にならず、発言は今までどおり打たれ続ける（#294 以前の形に戻るだけで、止まらない）。使用率は止まった席で 99 のまま動かず、代わりにならない |
-| app-server に繋がらなければ Codex の席は「制限中」のまま（#294） | 解除の確認は `account/rateLimits/read` の `ordinaryUsageAllowed: true` だけである。繋がらない・壊れた答えのあいだ、席は解除後も「制限中」のまま、発言は預かったままになる。席を起動し直しても、受け箱が残っているので止まった状態から始まる（#312）。プロトコルが使用率と解除時刻からの推測を禁じており、推測で戻して失敗の連鎖を再び起こすより、止まったままの側へ倒した |
-| 解除した Codex の席へは要約の一通だけを渡す（#294） | 預かった発言のうち本文が届くのはその席宛てのものだけで、他は件数だけである。中身は `read_room_history` で席が自分で読む。全部を流し込めば、それぞれが一ターンを起こし、制限明けの枠を部屋の雑談で使い切りうる |
-| 止まっている席の受け箱には預かった発言だけが入る（#294、#312） | 受け箱は預かった発言の id の並びで、再起動をまたいで残り、起動した席はそれがあれば止まった状態から始まって、解除のときにその発言のまとめを受け取る。席を閉じていたあいだと Pullcept が落ちていたあいだの発言は入らず、まとめにも載らない——部屋は過去を押し付けず、席は `read_room_history` で読める（#115 と同じ線、2026-10-07 マスター判断）。受け箱はまとめを打つ前に消すため、その間で落ちれば席はまとめを受け取りそこなう。逆にすれば同じまとめを二度打ちうる。受け箱は席を起動し直すかトピックを消すまで残る |
-| 停止と解除の知らせはその席の端末へ打たない（#294） | 部屋への停止・解除通知自体は本人へ打たない。解除確定後は預かり 0 件でも別の再開入力を一度渡し、その札に解除通知の既読位置を載せる（#389）。停止中の失敗ターンを増やさない |
+| app-server に繋がらなければ Codex の席は「制限中」のまま（#294） | 解除の確認は `account/rateLimits/read` の `ordinaryUsageAllowed: true` だけである。繋がらない・壊れた答えのあいだ、席は解除後も「制限中」のまま、再開の指示は打たれない。席を起動し直しても、印が残っているので止まった状態から始まる（#312）。プロトコルが使用率と解除時刻からの推測を禁じており、推測で戻して失敗の連鎖を再び起こすより、止まったままの側へ倒した |
+| 止まっている Codex の席の印は再起動をまたいで残る（#312、#403） | 印は再起動をまたいで残り、起動した席はそれがあれば止まった状態から始まって、すぐ聞き、解除なら再開の指示を受け取る。印は指示を打つ前に消すため、その間で落ちれば席は指示を受け取りそこなう。逆にすれば同じ指示を二度打ちうる。印は指示を打つかトピックを消すまで残る。指示を打つのは解除を確かめたときに席を占めている起動であり、止まった時と違う起動にも打つ |
+| 停止と解除の知らせはその席の端末へ打たない（#294） | 部屋への停止・解除通知自体は本人へ打たない。解除確定後は別の再開の指示を一度打ち、その札に解除通知の既読位置を載せる（#389）。指示に 120 秒応答が無ければ別の原因として部屋に一度だけ知らせ、打ち直さない（#403） |
 | 問い合わせごとに `codex app-server` を一つ起動する（#294） | 一回 0.5 秒未満のプロセスを、止まっている席についてだけ、多くても 1 分に一度起こす。常駐の接続を持たないため、席ごとのアカウントと環境をそのまま使え、daemon の寿命に依らない |
 | Codex の再開した席は最初のターンまで五欄が「—」（#283） | rollout には前回の実行の値が残っているが、起動時点のファイル長から読むため出さない。前回の使用率を今回の値として出せば、解けた制限で「制限中」が立ちうる。Claude Code の席が次の報告まで「—」であるのと同じ形である |
 | ステータスラインの JSON の欄名に依存する（#155 / #161） | 五欄の出所は CLI の欄名であり、CLI がどれかを改名すればパネルの一行が消える。5 時間と週次の二つは「制限中」の出所でもあるため、その二つが改名されれば語ごと消える。値そのものが目的である以上この依存は受ける。端末の出力を読まないこと（#82）は動いていない |
diff --git a/src-tauri/src/claude_limit.rs b/src-tauri/src/claude_limit.rs
index 9cce77c..04a2a8d 100644
--- a/src-tauri/src/claude_limit.rs
+++ b/src-tauri/src/claude_limit.rs
@@ -317,9 +317,7 @@ impl ClaudeLimits {
                 let item = mcp_config::prompt_hold::Item {
                     message_id: notice.unwrap_or_default(),
                     text,
-                    post: None,
                     launch_bound: true,
-                    relaunch_text: None,
                 };
                 let typed = crate::hook_activity::type_or_keep(app, pty, item);
                 log(
diff --git a/src-tauri/src/codex_limit.rs b/src-tauri/src/codex_limit.rs
index 64b82db..608e5e7 100644
--- a/src-tauri/src/codex_limit.rs
+++ b/src-tauri/src/codex_limit.rs
@@ -1,17 +1,18 @@
-//! A Codex CLI seat stopped on its usage limit (#294). See docs/3-accounts.md,
-//! "Codex の席が利用上限で止まったとき".
+//! A Codex CLI seat stopped on its usage limit (#294, #403). See
+//! docs/3-accounts.md, "Codex の席が利用上限で止まったとき".
 //!
 //! What is read and decided is `mcp_config::codex::limit`, free of tauri so a
 //! test can run it. What stays here is what needs the app: the table of
-//! seats the room consults before typing (`CodexLimits`), the question put to
-//! Codex's app-server, and the notices and the one line handed back.
+//! Codex seats a watcher is following (`CodexLimits`), the question put to
+//! Codex's app-server, the notices, and the resume typed into the seat.
 //!
 //! **Driven from the rollout watcher** (`codex_status`), one per Codex launch,
 //! on its one-second round. A turn the rollout says ended on the limit stops
-//! the seat; while stopped, the room keeps its posts back from that terminal
-//! (`room::type_into_sessions`), and the watcher asks the app-server when a
-//! question is due. Claude Code seats never enter the table and are never
-//! asked about.
+//! the seat and the room is told; the watcher asks the app-server when a
+//! question is due. Nothing is held back from a stopped seat (#403): the room
+//! types into it as into any seat (`room::type_into_sessions`), and what is
+//! typed stays in its conversation as a turn the limit refused. Claude Code
+//! seats never enter the table and are never asked about.
 //!
 //! **The app-server is asked over stdio, one short-lived process per
 //! question** (`codex app-server`, the default `stdio://` transport: one JSON
@@ -24,19 +25,26 @@
 //! A process that does not answer within `ASK_TIMEOUT` is killed and the
 //! answer is `Unavailable`, which keeps the seat stopped.
 //!
-//! **A stopped seat's mailbox outlives the session and the app** (#312): the
-//! id of every post held for it is written to a small file beside its topic's
-//! record (`limit::Mailboxes`) as it is held. A seat launched while its mailbox
-//! is there starts stopped and asks at once (`Limiter::open`); the recovery
-//! hands over exactly the posts the mailbox names, read from the record, and
-//! the mailbox goes.
+//! **A stopped seat's mark outlives the session and the app** (#312): it is
+//! written to a small file beside its topic's record (`limit::Mailboxes`) at
+//! the stop. A seat launched while its mark is there starts stopped and asks
+//! at once (`Limiter::open`), so the resume is typed by whichever launch holds
+//! the seat when the recovery is confirmed. The mark goes as the resume is
+//! typed.
+//!
+//! **After the resume is typed** (#403, as #401 for a Claude seat): a turn
+//! that starts or ends answers it. A turn that ends on the limit is a new
+//! stop, and the next confirmed recovery types it again. Neither within
+//! `limit::ANSWER_WAIT`: the room is told once that the seat seems stopped on
+//! something else, and nothing is typed again; a turn the seat completes
+//! later is told back once.
 
 use crate::room::{RoomState, SessionStats};
-use mcp_config::codex::limit::{self, Answer, Held, Limit, Mailboxes, TurnEnd};
+use mcp_config::codex::limit::{self, Answer, Limit, Mailboxes, TurnEnd};
 use mcp_config::codex::status::Status;
 use parking_lot::Mutex;
 use serde_json::Value;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::io::{BufRead, BufReader, Write};
 use std::path::PathBuf;
 use std::process::{Child, Command, Stdio};
@@ -48,29 +56,24 @@ use tauri::{AppHandle, Manager};
 #[derive(Default)]
 pub struct CodexLimits {
     seats: Mutex<HashMap<String, Entry>>,
+    /// The seats (topic, account) the room was told seem stopped on another
+    /// cause, kept across their launches until a turn completes.
+    stalled: Mutex<HashSet<(String, String)>>,
 }
 
-/// One seat in the table: its limit, and where its mailbox is kept.
+/// One seat in the table: its limit, and where its mark is kept.
 struct Entry {
     limit: Limit,
     account_id: String,
-    /// The topic's mailbox file, or `None` when it could not be placed: the
-    /// seat is then held in memory only, as before #312.
+    /// The topic's mark file, or `None` when it could not be placed: the stop
+    /// is then known in memory only, as before #312.
     mailboxes: Option<PathBuf>,
 }
 
 impl Entry {
-    /// The seat's mailbox as its file has it, empty when it has none.
-    fn stored(&self) -> Vec<String> {
-        self.mailboxes
-            .as_deref()
-            .and_then(|path| Mailboxes::read(path).get(&self.account_id))
-            .unwrap_or_default()
-    }
-
-    /// Change the seat's mailbox in its file. Every change goes through the
+    /// Change the seat's mark in its file. Every change goes through the
     /// table's lock, so two seats of one topic do not write over each other.
-    /// A failure is said and goes no further: memory still holds the post.
+    /// A failure is said and goes no further.
     fn persist(&self, change: impl FnOnce(&mut Mailboxes, &str)) {
         let Some(path) = self.mailboxes.as_deref() else {
             return;
@@ -78,7 +81,7 @@ impl Entry {
         let mut boxes = Mailboxes::read(path);
         change(&mut boxes, &self.account_id);
         if let Err(err) = boxes.write(path) {
-            eprintln!("[codex-limit] the mailbox could not be written: {err}");
+            eprintln!("[codex-limit] the mark could not be written: {err}");
         }
     }
 }
@@ -88,28 +91,7 @@ impl CodexLimits {
         Self::default()
     }
 
-    /// Keep a post back from the seat on `pty_id` if it is stopped, its id
-    /// written to the seat's mailbox. `false` for a free seat and for a
-    /// terminal that is not a Codex seat's.
-    pub fn hold(&self, pty_id: &str, post: impl FnOnce() -> Held) -> bool {
-        let mut seats = self.seats.lock();
-        let Some(entry) = seats.get_mut(pty_id) else {
-            return false;
-        };
-        let mut id = None;
-        let held = entry.limit.hold(|| {
-            let post = post();
-            id = Some(post.message_id.clone());
-            post
-        });
-        if let Some(id) = id {
-            entry.persist(|boxes, account| boxes.push(account, &id));
-            entry.limit.post_held(now());
-        }
-        held
-    }
-
-    /// The seat on `pty_id` has left the table. Its mailbox stays.
+    /// The seat on `pty_id` has left the table. Its mark stays.
     pub fn forget(&self, pty_id: &str) {
         self.seats.lock().remove(pty_id);
     }
@@ -148,7 +130,7 @@ impl Limiter {
 
     fn mailboxes(&self) -> Option<PathBuf> {
         crate::room_log::mailboxes_path(&self.app, &self.topic_id)
-            .map_err(|err| eprintln!("[codex-limit] the mailbox has no place: {err}"))
+            .map_err(|err| eprintln!("[codex-limit] the mark has no place: {err}"))
             .ok()
     }
 
@@ -172,18 +154,16 @@ impl Limiter {
         f(entry)
     }
 
-    /// Put the seat in the table, before the room can type into it (#312).
-    /// A mailbox left from an earlier launch — the seat was still stopped
-    /// when its session or the app ended — starts it stopped, its first
-    /// question due at once (`Limit::resumed`). Nothing is said to the room:
-    /// the stop was told when it happened.
+    /// Put the seat in the table (#312). A mark left from an earlier launch —
+    /// the seat was still stopped when its session or the app ended — starts
+    /// it stopped, its first question due at once (`Limit::resumed`). Nothing
+    /// is said to the room: the stop was told when it happened.
     pub fn open(&self) {
         let entry = self.entry(Limit::default());
         let left = entry
             .mailboxes
             .as_deref()
-            .and_then(|path| Mailboxes::read(path).get(&self.account_id))
-            .is_some();
+            .is_some_and(|path| Mailboxes::read(path).has(&self.account_id));
         let entry = Entry {
             limit: if left { Limit::resumed(now()) } else { Limit::default() },
             ..entry
@@ -195,15 +175,19 @@ impl Limiter {
         self.with(|entry| entry.limit.is_limited())
     }
 
-    /// One round: the turn end the rollout last reported, if any, then a due
-    /// question. `rollout_reset` is the reset the rollout last reported.
-    /// Whether 制限中 turned over, for the caller to send to the screen.
-    pub fn round(&self, end: Option<TurnEnd>, rollout_reset: Option<i64>) -> bool {
+    /// One round: whether a turn started and the turn end the rollout last
+    /// reported, if any, then a due question, then the resume's answer wait.
+    /// `rollout_reset` is the reset the rollout last reported. Whether 制限中
+    /// turned over, for the caller to send to the screen.
+    pub fn round(&self, started: bool, end: Option<TurnEnd>, rollout_reset: Option<i64>) -> bool {
         let was = self.is_limited();
+        if started {
+            self.with(|entry| entry.limit.answered());
+        }
         match end {
             Some(TurnEnd::UsageLimit) => {
-                // The mailbox from the stop on, empty until a post is held,
-                // so a seat stopped when the app goes down starts stopped.
+                // The mark from the stop on, so a seat stopped when the app
+                // goes down starts stopped.
                 let stopped = self.with(|entry| {
                     let stopped = entry.limit.stop(now(), rollout_reset);
                     if stopped {
@@ -216,9 +200,16 @@ impl Limiter {
                 }
             }
             Some(TurnEnd::Completed) => {
-                self.with(|entry| entry.limit.turn_completed(now()));
+                self.with(|entry| {
+                    entry.limit.answered();
+                    entry.limit.turn_completed(now());
+                });
+                self.announce_back();
+            }
+            Some(TurnEnd::Failed) => {
+                self.with(|entry| entry.limit.answered());
             }
-            Some(TurnEnd::Failed) | None => {}
+            None => {}
         }
         if self.with(|entry| entry.limit.due(now())) {
             let answer = ask(&self.asker);
@@ -227,11 +218,14 @@ impl Limiter {
                 self.recover();
             }
         }
+        if self.with(|entry| entry.limit.unanswered(now())) {
+            self.announce_other_cause();
+        }
         self.is_limited() != was
     }
 
     /// The seat has just stopped. One question for the reset the room is
-    /// told, then the notice. The room's posts are already being held.
+    /// told, then the notice.
     fn announce_stop(&self) {
         let answer = ask(&self.asker);
         let reset = self.with(|entry| {
@@ -239,84 +233,86 @@ impl Limiter {
             entry.limit.resets_at()
         });
         let clock = reset.and_then(terminal_input::clock);
-        let content = limit::stop_notice(&self.name, clock.as_deref());
+        self.notice(&limit::stop_notice(&self.name, clock.as_deref()));
+    }
+
+    /// The resume drew no answer: told once, and the seat is remembered so a
+    /// turn it completes later is told back (`announce_back`).
+    fn announce_other_cause(&self) {
+        self.limits()
+            .stalled
+            .lock()
+            .insert((self.topic_id.clone(), self.account_id.clone()));
+        self.notice(&limit::other_cause(&self.name));
+    }
+
+    /// A turn completed: if the room was told the seat seemed stopped on
+    /// another cause, it is told once that the seat is back.
+    fn announce_back(&self) {
+        let told = self
+            .limits()
+            .stalled
+            .lock()
+            .remove(&(self.topic_id.clone(), self.account_id.clone()));
+        if told {
+            self.notice(&limit::back_after_other_cause(&self.name));
+        }
+    }
+
+    /// Say `content` to the room, not typed into this seat. The id it was
+    /// filed under, if it went in.
+    fn notice(&self, content: &str) -> Option<String> {
         let room = self.app.state::<RoomState>();
-        crate::room::post_app_notice(
-            &self.app,
-            &room,
-            &self.topic_id,
-            &content,
-            Some(&self.pty_id),
-        );
+        crate::room::post_app_notice(&self.app, &room, &self.topic_id, content, Some(&self.pty_id))
     }
 
-    /// The app-server said the seat may run again. The room is told first,
-    /// with the seat still holding, so the notice is not typed into it; then
-    /// the seat is freed and handed its one line under the same lock, so a
-    /// post arriving after is typed after it.
+    /// The app-server said the seat may run again. The room is told first, so
+    /// the notice is not typed into the seat; then, under one lock, the seat is
+    /// freed, its mark goes, and the resume (`limit::CONTINUE`, #389) is typed
+    /// once into its terminal, so a post arriving after is typed after it.
     ///
-    /// What the notice counts and the line carries are the posts the seat's
-    /// mailbox names (`limit::mailbox`, #312), read from the topic's record:
-    /// a seat restarted while stopped holds in memory only what came after its
-    /// restart, and its mailbox file holds the rest. The record is read once,
-    /// before the notice goes in.
+    /// Typed by the launch that holds the seat now. A launch that no longer
+    /// does types nothing and leaves the mark: the launch after it started
+    /// stopped from that mark, asks for itself, and types its own resume.
     fn recover(&self) {
         if !self.current() {
             return;
         }
-        let record = self.record();
-        let seat = limit::Seat {
-            name: &self.name,
-            account_id: &self.account_id,
-        };
-        let (ids, held) = self.with(|entry| (entry.stored(), entry.limit.held().to_vec()));
-        let count = limit::mailbox(&record, &seat, &ids, held).len();
-        let room = self.app.state::<RoomState>();
-        let notice = crate::room::post_app_notice(
-            &self.app,
-            &room,
-            &self.topic_id,
-            &limit::recovery_notice(&self.name, count),
-            Some(&self.pty_id),
-        );
+        let notice = self.notice(&limit::recovery_notice(&self.name));
         self.with(|entry| {
             // The app-server query may have outlived this launch.
             if !self.current() {
                 return;
             }
-            // Read again with what was held up to the release, so a post held
-            // after the record was read is not lost.
-            let ids = entry.stored();
-            let held = limit::mailbox(&record, &seat, &ids, entry.limit.release());
-            // The mailbox goes before the line is typed: cut short between the
-            // two, the seat misses its line rather than being handed it twice.
+            entry.limit.free();
+            // The mark goes before the resume is typed: cut short between the
+            // two, the seat misses its resume rather than being typed it twice.
             entry.persist(|boxes, account| boxes.close(account));
-            let text = mcp_config::limit_recovery::input(&held);
-            // The label carries the id of the newest post this line accounts
-            // for — the recovery notice, or the newest held post if the notice
-            // did not go in — so the seat's next `last_seen` stands past
-            // everything it was told of here (#47).
-            let watermark = notice.or_else(|| held.last().map(|p| p.message_id.clone()));
+            // The label carries the recovery notice's id, so the seat's next
+            // `last_seen` stands past it (#47).
+            let watermark = notice.unwrap_or_default();
             let at = terminal_input::at(&crate::room::now_iso());
-            let compose = |text: &str| terminal_input::compose(
-                watermark.as_deref().unwrap_or_default(),
+            let text = terminal_input::compose(
+                &watermark,
                 crate::room::APP_SPEAKER,
                 terminal_input::ROLE_APP,
                 at.as_deref(),
                 &[],
-                text,
+                limit::CONTINUE,
             );
-            crate::hook_activity::type_or_keep(
+            // Bound to this launch: not carried to the next (#389).
+            let typed = crate::hook_activity::type_or_keep(
                 &self.app,
                 &self.pty_id,
                 mcp_config::prompt_hold::Item {
-                    message_id: watermark.clone().unwrap_or_default(),
-                    text: compose(&text),
-                    post: None,
+                    message_id: watermark,
+                    text,
                     launch_bound: true,
-                    relaunch_text: limit::digest(&held).map(|digest| compose(&digest)),
                 },
             );
+            if typed {
+                entry.limit.resume_typed(now());
+            }
         });
     }
 
@@ -329,28 +325,8 @@ impl Limiter {
             && self.app.state::<crate::pty::PtyState>().is_running(&self.pty_id)
     }
 
-    /// The topic's record, as `limit::mailbox` reads it. Unreadable is no
-    /// record, which leaves the line to what memory held.
-    fn record(&self) -> Vec<limit::Recorded> {
-        crate::room_log::topic_posts(&self.app, &self.topic_id)
-            .unwrap_or_else(|err| {
-                eprintln!("[codex-limit] the record could not be read: {err}");
-                Vec::new()
-            })
-            .into_iter()
-            .map(|post| limit::Recorded {
-                at: terminal_input::at(&post.ts),
-                message_id: post.message_id,
-                speaker: post.speaker,
-                account: post.account,
-                content: post.content,
-                to: post.to,
-            })
-            .collect()
-    }
-
-    /// The session has ended: whatever was held in memory goes with it. The
-    /// mailbox stays, and the seat's next launch starts from it (`open`).
+    /// The session has ended. The mark stays, and the seat's next launch
+    /// starts from it (`open`).
     pub fn forget(&self) {
         self.limits().forget(&self.pty_id);
     }
diff --git a/src-tauri/src/codex_status.rs b/src-tauri/src/codex_status.rs
index 387e2d3..f675080 100644
--- a/src-tauri/src/codex_status.rs
+++ b/src-tauri/src/codex_status.rs
@@ -23,13 +23,12 @@
 //! sent every round so that a reloaded webview picks them up again (#374).
 //!
 //! **The same round drives the seat's usage limit** (#294, `codex_limit`):
-//! the turn end and the reset each read leaves behind are handed to the
-//! seat's `Limiter`, which stops the seat, asks the app-server when a question
-//! is due, and hands the seat back. The question does not wait for the rollout:
-//! a seat that starts stopped (#312) is asked on the first round, before its
-//! CLI has written anything. The limit in memory is the launch's, like this
-//! thread: when the thread ends, what was held in memory goes with it, and the
-//! seat's mailbox keeps the ids of what was held (#312).
+//! the turn start, the turn end and the reset each read leaves behind are
+//! handed to the seat's `Limiter`, which stops the seat, asks the app-server
+//! when a question is due, and types the resume. The question does not wait
+//! for the rollout: a seat that starts stopped (#312) is asked on the first
+//! round, before its CLI has written anything. The limit in memory is the
+//! launch's, like this thread; the seat's mark outlives it (#312).
 
 use crate::codex_limit::Limiter;
 use crate::pty::PtyState;
@@ -82,8 +81,7 @@ pub fn watch(limiter: Limiter, home: PathBuf, resumed: Option<(PathBuf, u64)>) {
         });
     if let Err(err) = spawned {
         // The session runs without its five values, which read `—`, and
-        // without its limit being watched: the room types into it as before,
-        // whatever its mailbox says.
+        // without its limit being watched: no resume is typed into it.
         app.state::<crate::codex_limit::CodexLimits>().forget(&pty_id);
         eprintln!("[codex-status] watcher could not start: {err}");
     }
@@ -116,8 +114,8 @@ fn follow(limiter: &Limiter, home: &std::path::Path, resumed: Option<(PathBuf, u
         // Every round, read or not, and with no rollout yet: a stopped seat's
         // due question does not wait for the file to move, or to exist.
         let _ = match tail.as_deref_mut() {
-            Some(tail) => limiter.round(tail.take_turn_end(), tail.resets_at),
-            None => limiter.round(None, None),
+            Some(tail) => limiter.round(tail.take_turn_started(), tail.take_turn_end(), tail.resets_at),
+            None => limiter.round(false, None, None),
         };
         // When the figures were received, changed or not (#364).
         if let Some(tail) = tail.as_deref_mut() {
diff --git a/src-tauri/src/hook_activity.rs b/src-tauri/src/hook_activity.rs
index b30454d..ff6018c 100644
--- a/src-tauri/src/hook_activity.rs
+++ b/src-tauri/src/hook_activity.rs
@@ -47,7 +47,7 @@
 use crate::session::RoomSeats;
 use mcp_config::hook_activity::{Activity, Reporter};
 use mcp_config::permission_prompt::{Decision, Press, Request};
-use mcp_config::prompt_hold::{self, Delivered, Item, Queue};
+use mcp_config::prompt_hold::{self, Item, Queue};
 use parking_lot::Mutex;
 use serde_json::Value;
 use std::collections::HashMap;
@@ -234,8 +234,8 @@ impl HookSeats {
     }
 
     /// Hand the posts kept for one seat over, once its wait has ended
-    /// (`prompt_hold`). Each item is taken under the lock and delivered
-    /// outside it, so the Codex limit hold's lock is never taken inside this one.
+    /// (`prompt_hold`). Each item is taken under the lock and typed outside
+    /// it.
     fn hand_over(&self, app: &AppHandle, topic_id: &str, account_id: &str) {
         let key = (topic_id.to_string(), account_id.to_string());
         {
@@ -263,18 +263,10 @@ impl HookSeats {
             };
             let id = item.message_id.clone();
             let at = crate::room::now_iso();
-            let delivered = prompt_hold::deliver(
-                item,
-                |post| crate::room::limit_hold(app, &pty_id, post),
-                |text| ptys.type_in(&pty_id, text.to_string()),
-            );
+            let delivered = prompt_hold::deliver(item, |text| ptys.type_in(&pty_id, text.to_string()));
             match delivered {
-                Ok(how) => {
-                    let action = match how {
-                        Delivered::ToLimit => "to-limit",
-                        Delivered::Typed => "typed",
-                    };
-                    log(app, &prompt_hold::log_line(action, &id, topic_id, account_id, &at));
+                Ok(()) => {
+                    log(app, &prompt_hold::log_line("typed", &id, topic_id, account_id, &at));
                 }
                 Err(item) => {
                     log(app, &prompt_hold::log_line("refused", &id, topic_id, account_id, &at));
diff --git a/src-tauri/src/room.rs b/src-tauri/src/room.rs
index bfd7eb9..32a1435 100644
--- a/src-tauri/src/room.rs
+++ b/src-tauri/src/room.rs
@@ -1067,19 +1067,14 @@ fn role_of(app: &AppHandle, room: &RoomState, origin: &str, account: Option<&str
 /// to push to it, and it reads the topic through the pull
 /// (`terminal_input::targets`).
 ///
-/// **A Codex seat stopped on its usage limit is not typed into** (#294): the
-/// post is kept for it (`codex_limit::CodexLimits`), its id written to the
-/// seat's mailbox (#312), and handed over as one line when the recovery is
-/// confirmed. A Claude Code seat stopped on its parent's limit is typed into
-/// as any seat is (#401): its resume is the prompt `claude_limit` types at the
-/// reset, and what was said meanwhile is in the topic's history.
+/// **A seat stopped on its usage limit is typed into as any seat is** (Claude
+/// #401, Codex #403): its resume is what `claude_limit` / `codex_limit` types
+/// once it may run again, and what was said meanwhile is in the topic's
+/// history.
 ///
-/// **A Claude Code seat waiting on a permission prompt is not typed into
-/// either** (#346): the post's submit key would answer the prompt. It is kept
-/// for the seat (`hook_activity::type_or_keep`) and typed once the wait has
-/// ended — or given to the Codex limit hold then, if the seat is stopped on
-/// its limit by that time. The limit hold is asked first, so a post for a
-/// seat stopped on its limit stays that hold's, as before.
+/// **A Claude Code seat waiting on a permission prompt is not typed into**
+/// (#346): the post's submit key would answer the prompt. It is kept for the
+/// seat (`hook_activity::type_or_keep`) and typed once the wait has ended.
 fn type_into_sessions(
     app: &AppHandle,
     room_id: &str,
@@ -1109,7 +1104,6 @@ fn type_into_sessions(
         return;
     }
     let at = terminal_input::at(&post.ts);
-    let display_speaker = post.full_name.as_ref().map(|name| format!("{} ({name})", post.speaker)).unwrap_or_else(|| post.speaker.clone());
     let text = terminal_input::compose_named(
         &post.message_id,
         &post.speaker,
@@ -1119,24 +1113,10 @@ fn type_into_sessions(
         &post.to,
         &post.content,
     );
-    let limits = app.state::<crate::codex_limit::CodexLimits>();
     for target in targets {
         if except_pty == Some(target.pty_id.as_str()) {
             continue;
         }
-        let post_for_hold = || mcp_config::codex::limit::Held {
-            message_id: post.message_id.clone(),
-            speaker: display_speaker.clone(),
-            at: at.clone(),
-            content: post.content.clone(),
-            addressed: seats
-                .iter()
-                .filter(|(origin, _, _)| target.origins.contains(origin))
-                .any(|(_, _, name)| post.to.contains(name)),
-        };
-        if limits.hold(&target.pty_id, post_for_hold) {
-            continue;
-        }
         // For addressed posts, the recipient's current call-name supersedes launch-time instructions.
         // A live rename does not need a new conversation or a synthetic user post.
         let recipient = seats.iter().find(|(origin, _, _)| target.origins.contains(origin)).and_then(|(_, account, _)| account.as_deref());
@@ -1149,21 +1129,12 @@ fn type_into_sessions(
             mcp_config::prompt_hold::Item {
                 message_id: post.message_id.clone(),
                 text: text.clone(),
-                post: Some(post_for_hold()),
                 launch_bound: false,
-                relaunch_text: None,
             },
         );
     }
 }
 
-/// Give `post` to the usage-limit hold of the seat on `pty_id`, if that seat
-/// is a Codex seat stopped on its limit (#294). True when it was taken. The
-/// hand-over of posts kept for a permission wait asks this first (#346).
-pub fn limit_hold(app: &AppHandle, pty_id: &str, post: &mcp_config::codex::limit::Held) -> bool {
-    app.state::<crate::codex_limit::CodexLimits>().hold(pty_id, || post.clone())
-}
-
 /// Say one notice of the app's own into one room (#294), typed into every
 /// session in it but `except_pty`'s. Said as [`APP_SPEAKER`] with no account,
 /// under the role `app`, through `deliver` like every other post: the same
diff --git a/src-tauri/src/room_log.rs b/src-tauri/src/room_log.rs
index d501a36..000ceb3 100644
--- a/src-tauri/src/room_log.rs
+++ b/src-tauri/src/room_log.rs
@@ -183,7 +183,7 @@ fn topic_path(app: &AppHandle, topic_id: &str) -> Result<PathBuf, String> {
     Ok(topic_index::topic_path(&room_dir(app)?, topic_id))
 }
 
-/// Where one topic's stopped Codex seats keep their mailboxes (#312): beside
+/// Where one topic's stopped Codex seats keep their marks (#312, #403): beside
 /// the topic's posts, so deleting the topic deletes them (`topic_index::delete`).
 pub fn mailboxes_path(app: &AppHandle, topic_id: &str) -> Result<PathBuf, String> {
     Ok(topic_index::mailboxes_path(&room_dir(app)?, topic_id))
diff --git a/src-tauri/src/session.rs b/src-tauri/src/session.rs
index cc00083..55d7ba3 100644
--- a/src-tauri/src/session.rs
+++ b/src-tauri/src/session.rs
@@ -1699,9 +1699,8 @@ pub fn start_session(
                 room_log::report(&app, err);
             }
             // The Codex seat's usage limit (#294) is put in the table before the
-            // seat is held, since holding it is what lets the room type into
-            // it: a seat whose mailbox was left from a launch that ended
-            // stopped (#312) has its first post held, not typed. It asks the
+            // seat is held: a seat whose mark was left from a launch that ended
+            // stopped (#312) starts stopped and asks at once. It asks the
             // app-server with the seat's own command, environment and
             // `CODEX_HOME`, so the account asked about is the seat's.
             let watched = rollout.map(|(home, resumed)| {