alissa-tools-github-devloop 0.8.30__py3-none-any.whl → 0.8.31__py3-none-any.whl

alissa/tools/github/devloop/loop.py

@@ -1272,7 +1272,12 @@ PROMPT_PAGE_COMMENT = (
     "the container's token (`ANTHROPIC_API_KEY` / `CLAUDE_CODE_OAUTH_TOKEN`) "
     "or re-run the claude login — the `auth.rejected` loop event names the "
     "variable and the token's last four characters; "
-    "`usage_limit` → wait for the reset or raise the plan; `out_of_credits` "
+    "`usage_limit` (\"You've reached your <Model> limit\" included) → wait "
+    "for the reset, buy usage credits, or set a fallback `ALISSA_AGENT_MODEL` "
+    "(a variable change redeploys and kills live lanes) — a session whose "
+    "ONLY turn was the notice is killed at once, its attempt refunded (it "
+    "never counts toward attempt_cap), and new spawns are held for "
+    "{hold_minutes} min after the last one; `out_of_credits` "
     "→ top up. The hold lifts on the first poll that no longer sees the "
     "notice and in any case after {hold_minutes} min on the same pane: the "
     "session is then killed and the retry edge's respawn re-confirms — a "
@@ -1303,6 +1308,35 @@ FIX_STALLED_COMMENT = (
     "close the PR to park the work."
 )
 
+# The ALIVE twin of FIX_STALLED_COMMENT (issue #142): the fix edge no longer
+# respawns a stale round on the timer alone, so a session that is LISTED but
+# has posted no triage reply defers -- floored by this once-per-episode ping
+# (fix_live_stalled_kind) so a wedged one is never deferred in silence.
+FIX_LIVE_STALLED_COMMENT = (
+    "**Fix loop stalled?** — fix attempt {attempts} on review round {round} "
+    "has been in flight {minutes} min with no triage reply, but its session "
+    "`{session}` is still listed by tmux. The daemon never respawns over a "
+    "session it cannot prove is gone (a second session would land on the "
+    "same branch in the same worktree), so it keeps deferring the retry — is "
+    "that session still making progress? Operator options: check it, and if "
+    "it is wedged `alissa tmux kill {session}` to let the retry proceed, or "
+    "finish the round by hand (fixes, re-request review)."
+)
+
+# The activity context of a retry whose previous session was refunded by a
+# usage limit (issue #142), on every edge -- in place of "presumed dead" or
+# "confirmed dead": the session did not die, the account stopped it.
+LIMITED_RETRY_CONTEXT = (
+    "re-enqueued — previous session limited (usage limit on its first turn; "
+    "attempt refunded)"
+)
+
+# The activity context the first-turn limit check posts on the lane's
+# artifact when it kills a limited session (issue #142).
+LIMITED_CONTEXT = (
+    "limited — attempt refunded; spawns held until the account is back"
+)
+
 # The hidden marker that identifies a fix-round handover comment (issue #121)
 # -- a machine-findable anchor for the live session and for anyone auditing
 # the PR, distinct from ACTIVITY_MARKER so the two kinds of comment never
@@ -1948,6 +1982,14 @@ def fix_stalled_kind(round_: int, attempt: int) -> str:
     return f"{ESCALATION_FIX_STALLED}:r{round_}a{attempt}"
 
 
+def fix_live_stalled_kind(round_: int, attempt: int) -> str:
+    """The ledger kind for the stalled ping of ONE fix-round liveness
+    deferral (issue #142): the round is stale, no triage reply exists, and
+    the row's session is still LISTED. Keyed per round AND attempt for
+    fix_stalled_kind's episode reasoning."""
+    return f"fix-live-stalled:r{round_}a{attempt}"
+
+
 def fix_handover_kind(round_: int) -> str:
     """The ledger kind that dedupes ONE round's handover comment (issue #121).
 
@@ -2496,6 +2538,10 @@ class Sweep:
     # one per session (`{session, repo, edge, number, attempt, round,
     # source, matched}`).
     auth_rejected: "tuple[dict, ...]" = ()
+    # The usage limits the responder observed this pass (issue #142): the
+    # `usage.limited` records, one per session (`{session, repo, edge,
+    # number, attempt, round, source, matched, model}`).
+    usage_limited: "tuple[dict, ...]" = ()
 
     @property
     def total(self) -> int:
@@ -2508,13 +2554,14 @@ class PromptSweep:
     """What ONE prompt-responder pass found and did (issue #127): the
     sessions parked on a prompt (`{session, kind, since, action}`), the
     spawn hold an account-level notice raised, the keystroke answers
-    sent, and the `auth.rejected` records (issue #140). Folded into the
-    pass's `Sweep`."""
+    sent, the `auth.rejected` records (issue #140) and the
+    `usage.limited` records (issue #142). Folded into the pass's `Sweep`."""
 
     waiting: "tuple[dict, ...]" = ()
     hold: "str | None" = None
     answered: int = 0
     auth_rejected: "tuple[dict, ...]" = ()
+    usage_limited: "tuple[dict, ...]" = ()
 
 
 @dataclass(frozen=True, slots=True)
@@ -3273,6 +3320,18 @@ class DevWatcher:
         # purpose: a restart re-checks once, and the loop event's key is
         # the session name, so a re-observation is a silent duplicate.
         self._exit_findings: "dict[str, prompts_mod.PromptFinding | None]" = {}
+        # The first-turn limit check's memory (issue #142): the sessions
+        # whose pane showed the usage-limit notice as their only turn (the
+        # finding, re-asserted while the session is still listed -- a kill
+        # that failed is retried, never re-narrated), the sessions whose
+        # first turn was provably something else (never read again for this
+        # check), and the sessions already acted on (paged, refunded,
+        # narrated once). In-memory like `_exit_findings`: the refund and the
+        # hold live on the ledger (`limited_at`), so a restart loses nothing
+        # but one re-read of a pane that is killed anyway.
+        self._limit_findings: "dict[str, prompts_mod.PromptFinding]" = {}
+        self._limit_settled: "set[str]" = set()
+        self._limit_acted: "set[str]" = set()
         # The janitor's two pieces of per-process state: when its expensive
         # half last ran (monotonic; None = never, so the first pass of a
         # process always sweeps) and the last per-hub breakdown it walked,
@@ -3604,13 +3663,17 @@ class DevWatcher:
 
         # Never spawn attempt cap+1. Escalate ONCE; `escalated()` dedupes, and
         # raising attempt_cap re-enters the loop without clearing the ledger.
-        if attempts >= self.config.attempt_cap:
+        # Billable attempts only (issue #142): an attempt refunded by a
+        # usage limit never counts toward the cap; the numbering below still
+        # counts it, so session names stay monotonic.
+        billed = self.state.attempt_count(issue.full_name, number, billable=True)
+        if billed >= self.config.attempt_cap:
             if self.state.escalated(issue.full_name, number, ESCALATION_CAP):
                 return Decision(Action.CAPPED, "already escalated", attempts)
-            self._escalate(issue, attempts)
+            self._escalate(issue, billed)
             return Decision(
                 Action.ESCALATED,
-                f"{attempts} attempts, cap {self.config.attempt_cap}",
+                f"{billed} attempts, cap {self.config.attempt_cap}",
                 attempts,
             )
 
@@ -3830,6 +3893,8 @@ class DevWatcher:
                 f"tmux listing) with its PR never handed off; finishing draft "
                 f"PR {resume_pr.url}"
             )
+        elif reenqueued and self.state.session_limited(dead_session):
+            context = LIMITED_RETRY_CONTEXT
         elif reenqueued:
             context = (
                 "re-enqueued — previous session confirmed dead (absent from "
@@ -4922,17 +4987,72 @@ class DevWatcher:
         # triage replies), so it resumes as attempt k+1 with
         # FIX_RESUME_DIRECTIVE; ALIVE and INDETERMINATE keep the floored
         # defer, and `resume_enabled=false` restores it wholesale.
+        #
+        # With NO author activity the timer used to decide alone ("fix
+        # session presumed dead", issue #142): a session that never got as
+        # far as a triage reply -- the 2026-09-28 incident's, parked idle on
+        # a usage-limit notice as its only turn -- was respawned every stale
+        # window, each respawn billed against attempt_cap, until the round
+        # capped out in three hours. Now the roster answers there too, the
+        # issue edge's PR-less guard transposed: ALIVE is in flight (a live
+        # idle pane belongs to the prompt responder and the first-turn limit
+        # check, never to a second session on the same branch), floored by a
+        # once-per-episode ping so a wedged one is not deferred in silence;
+        # INDETERMINATE defers one pass (a failed listing proves nothing);
+        # only DEAD -- absent from a SUCCESSFUL listing -- respawns, and it
+        # says CONFIRMED dead.
         resume_dead_session: "str | None" = None
+        confirmed_dead_session: "str | None" = None
         if age is not None:
             author_activity = any(
                 r.author == pr.author and r.submitted_at > newest.submitted_at
                 for r in records
             )
-            if author_activity:
-                row_session = self.state.newest_fix_spawn_session(
-                    pr.full_name, number, round_
-                )
-                liveness = self.session_liveness(row_session, roster)
+            row_session = self.state.newest_fix_spawn_session(
+                pr.full_name, number, round_
+            )
+            liveness = self.session_liveness(row_session, roster)
+            if not author_activity:
+                if liveness is Liveness.ALIVE:
+                    stalled_after = (
+                        STALLED_DEFER_MULTIPLE * self.config.stale_minutes * 60
+                    )
+                    if age >= stalled_after and not self.state.escalated(
+                        pr.full_name, number,
+                        fix_live_stalled_kind(round_, attempts),
+                    ):
+                        self._escalate_fix_live_stalled(
+                            pr, round_, attempts, age, row_session or ""
+                        )
+                    return Decision(
+                        Action.IN_FLIGHT,
+                        f"fix attempt {attempts} for round {round_} is stale "
+                        f"({int(age / 60)} min) with no triage reply yet, but "
+                        f"its session {row_session} reads alive — a live "
+                        f"session owns the round (an idle pane is the prompt "
+                        f"responder's); not respawning",
+                        attempts,
+                        session=row_session
+                        or fix_session_name(pr, round_, attempts),
+                        round=round_,
+                        defer_token=loop_events_mod.DEFER_IN_FLIGHT,
+                    )
+                if liveness is not Liveness.DEAD:
+                    return Decision(
+                        Action.IN_FLIGHT,
+                        f"fix attempt {attempts} for round {round_} is stale "
+                        f"({int(age / 60)} min) with no triage reply yet, and "
+                        f"its session {row_session} reads "
+                        f"{liveness.value} — the listing proves nothing; "
+                        f"deferring one pass",
+                        attempts,
+                        session=row_session
+                        or fix_session_name(pr, round_, attempts),
+                        round=round_,
+                        defer_token=loop_events_mod.DEFER_IN_FLIGHT,
+                    )
+                confirmed_dead_session = row_session
+            else:
                 if self.config.resume_enabled and liveness is Liveness.DEAD:
                     # Falls through to the cap check and the spawn below: a
                     # resume is an ORDINARY attempt of this round.
@@ -4967,7 +5087,12 @@ class DevWatcher:
         # first otherwise), so at cap-out the PR is invisible to reviewloop
         # and FIX_CAP_COMMENT is the operator's only signal. Deduped by the
         # fix-cap:r<k> row: once per round.
-        if attempts >= self.config.attempt_cap:
+        # Billable attempts only (issue #142): an attempt refunded by a
+        # usage limit never counts toward the round's cap.
+        billed = self.state.fix_attempt_count(
+            pr.full_name, number, round_, billable=True
+        )
+        if billed >= self.config.attempt_cap:
             kind = fix_cap_kind(round_)
             if self.state.escalated(pr.full_name, number, kind):
                 return Decision(
@@ -4976,10 +5101,10 @@ class DevWatcher:
                     attempts,
                     round=round_,
                 )
-            self._escalate_fix_cap(pr, round_, attempts)
+            self._escalate_fix_cap(pr, round_, billed)
             return Decision(
                 Action.ESCALATED,
-                f"{attempts} fix attempts on round {round_}, cap "
+                f"{billed} fix attempts on round {round_}, cap "
                 f"{self.config.attempt_cap} — operator paged on the PR (no "
                 f"pending re-request, so the reviewer daemon cannot see it)",
                 attempts,
@@ -5002,12 +5127,16 @@ class DevWatcher:
         elif age is not None:
             log.warning(
                 "%s fix attempt %d (round %d) has been in flight %.0f min "
-                "with no re-request — re-enqueuing as attempt %d (fix "
-                "session presumed dead)",
+                "with no re-request and its session %s is absent from the "
+                "tmux listing (CONFIRMED dead, not presumed%s) — "
+                "re-enqueuing as attempt %d",
                 pr.pr_slug,
                 attempts,
                 round_,
                 age / 60,
+                confirmed_dead_session,
+                "; usage-limited, attempt refunded"
+                if self.state.session_limited(confirmed_dead_session) else "",
                 attempts + 1,
             )
 
@@ -5019,6 +5148,7 @@ class DevWatcher:
             budget,
             reenqueued=age is not None,
             dead_session=resume_dead_session,
+            confirmed_dead=confirmed_dead_session,
         )
 
     def _reviewer_reviews(
@@ -6486,6 +6616,41 @@ class DevWatcher:
             pr.full_name, pr.number, fix_stalled_kind(round_, attempts)
         )
 
+    def _escalate_fix_live_stalled(
+        self, pr: PullRequest, round_: int, attempts: int, age: float,
+        session: str,
+    ) -> None:
+        """_escalate_fix_stalled's ALIVE twin (issue #142): the liveness
+        guard on the no-triage-reply branch defers while the row's session is
+        listed, and this ping is its floor. Same delivery contract: the row
+        is recorded only AFTER the comment posts; the decision stays
+        IN_FLIGHT either way."""
+        body = FIX_LIVE_STALLED_COMMENT.format(
+            attempts=attempts, round=round_, minutes=int(age / 60),
+            session=session,
+        )
+        log.warning(
+            "FIX STALLED %s fix attempt %d (round %d) has been deferred "
+            "%.0f min behind its still-listed session %s with no triage "
+            "reply — escalating to operator (once per episode)",
+            pr.pr_slug, attempts, round_, age / 60, session,
+        )
+        if self.config.dry_run:
+            log.info("[dry-run] would comment on %s:\n%s", pr.pr_slug, body)
+            return
+        try:
+            self.github.comment(pr.owner, pr.repo, pr.number, body)
+        except CommandError as exc:
+            log.error(
+                "could not post the fix live-stalled comment on %s: %s — not "
+                "recording the episode; the ping retries next poll",
+                pr.pr_slug, exc,
+            )
+            return
+        self.state.record_escalation(
+            pr.full_name, pr.number, fix_live_stalled_kind(round_, attempts)
+        )
+
     def _hand_over_round(
         self,
         pr: PullRequest,
@@ -6805,6 +6970,7 @@ class DevWatcher:
         *,
         reenqueued: bool = False,
         dead_session: "str | None" = None,
+        confirmed_dead: "str | None" = None,
     ) -> Decision:
         skipped = self._foreign_head_skip(pr, attempt)
         if skipped is not None:
@@ -6899,8 +7065,15 @@ class DevWatcher:
                 "resumed — previous session confirmed dead (absent from the "
                 "tmux listing); finishing the round on the same branch"
             )
+        elif reenqueued and self.state.session_limited(confirmed_dead):
+            context = LIMITED_RETRY_CONTEXT
         elif reenqueued:
-            context = "re-enqueued — previous session presumed dead"
+            # Issue #142: this edge retries only past the liveness guard now,
+            # so the previous session was absent from a successful listing.
+            context = (
+                "re-enqueued — previous session confirmed dead (absent from "
+                "the tmux listing) with no triage reply"
+            )
         else:
             context = "spawned"
         self._append_activity(
@@ -7051,14 +7224,18 @@ class DevWatcher:
         # explicit operator ask, and its removal -- by the session on
         # completion, or by the operator to park the PR -- is the only
         # convergence signal this edge has.
-        if attempts >= self.config.attempt_cap:
+        # Billable attempts only (issue #142), on the same epoch floor.
+        billed = self.state.maintain_attempt_count(
+            pr.full_name, number, since=labeled_ts or 0, billable=True
+        )
+        if billed >= self.config.attempt_cap:
             kind = maintain_cap_kind(labeled_ts)
             if self.state.escalated(pr.full_name, number, kind):
                 return Decision(Action.CAPPED, "already escalated", attempts)
-            self._escalate_maintain_cap(pr, attempts, kind)
+            self._escalate_maintain_cap(pr, billed, kind)
             return Decision(
                 Action.ESCALATED,
-                f"{attempts} maintenance attempts this request, cap "
+                f"{billed} maintenance attempts this request, cap "
                 f"{self.config.attempt_cap} — the label is still present; "
                 f"operator paged on the PR",
                 attempts,
@@ -7085,6 +7262,11 @@ class DevWatcher:
             self.state.maintain_max_attempt(pr.full_name, number) + 1,
             budget,
             reenqueued=age is not None,
+            limited=age is not None and self.state.session_limited(
+                maintain_session_name(
+                    pr, self.state.maintain_max_attempt(pr.full_name, number)
+                )
+            ),
         )
 
     def _spawn_maintain(
@@ -7094,6 +7276,7 @@ class DevWatcher:
         budget: "SessionBudget | None" = None,
         *,
         reenqueued: bool = False,
+        limited: bool = False,
     ) -> Decision:
         skipped = self._foreign_head_skip(pr, attempt)
         if skipped is not None:
@@ -7154,8 +7337,8 @@ class DevWatcher:
         # cost; the line stays best-effort and dry-run gated. The session name
         # carries the attempt; the context marks a retry.
         context = (
-            "re-enqueued — previous session presumed dead"
-            if reenqueued
+            LIMITED_RETRY_CONTEXT if reenqueued and limited
+            else "re-enqueued — previous session presumed dead" if reenqueued
             else "spawned"
         )
         self._append_activity(
@@ -8616,6 +8799,7 @@ class DevWatcher:
         hold: "str | None" = None
         answered = 0
         rejected: "list[dict]" = []
+        limited: "list[dict]" = []
         for entry in sessions:
             name = str(entry.get("name") or "")
             worker = parse_worker_session(name)
@@ -8636,6 +8820,8 @@ class DevWatcher:
                     hold = outcome["hold"]
                 if outcome["auth"]:
                     rejected.append(outcome["auth"])
+                if outcome["limited"]:
+                    limited.append(outcome["limited"])
                 continue
             marker = self._waiting_marker(tmux_name)
             quiet = self._entry_quiet_for(entry)
@@ -8649,6 +8835,19 @@ class DevWatcher:
                 self.state.clear_prompt_sighting(name)
                 continue
             pane = self.alissa.capture_pane(name, prompts_mod.PANE_LINES)
+            # The first-turn limit check (issue #142) reads the SAME capture:
+            # a young worker of any edge whose only turn is the usage-limit
+            # notice is killed and refunded here, before the banner rule --
+            # which, by design, never reads a `●` row -- calls it idle.
+            limit = self._first_turn_limit(worker, name, pane)
+            if limit is not None:
+                outcome = self._answer_first_turn_limit(worker, limit, mode)
+                waiting.append(outcome["waiting"])
+                if outcome["hold"] and hold is None:
+                    hold = outcome["hold"]
+                if outcome["limited"]:
+                    limited.append(outcome["limited"])
+                continue
             finding = prompts_mod.classify(pane)
             if finding is None:
                 log.debug(
@@ -8667,12 +8866,18 @@ class DevWatcher:
                 hold = outcome["hold"]
             if outcome["auth"]:
                 rejected.append(outcome["auth"])
+            if outcome["limited"]:
+                limited.append(outcome["limited"])
         self.state.prune_prompt_sightings(live)
         for gone in [n for n in self._exit_findings if n not in live]:
             del self._exit_findings[gone]
+        for gone in [n for n in self._limit_findings if n not in live]:
+            del self._limit_findings[gone]
+        self._limit_settled &= live
+        self._limit_acted &= live
         return PromptSweep(
             waiting=tuple(waiting), hold=hold, answered=answered,
-            auth_rejected=tuple(rejected),
+            auth_rejected=tuple(rejected), usage_limited=tuple(limited),
         )
 
     def _first_turn_death(
@@ -8933,6 +9138,13 @@ class DevWatcher:
             }
             if repo:
                 auth["repo"] = slug
+        # The `usage.limited` record (issue #142) for a usage-limit BANNER
+        # (`source: "pane"`): live mode only, like the auth record -- the
+        # first-turn check builds its own (`source: "first_turn"`).
+        limited = (
+            self._limited_record(worker, repo, finding)
+            if finding.kind == prompts_mod.KIND_USAGE_LIMIT and live_mode else None
+        )
         return {
             "waiting": {
                 "session": name, "kind": finding.kind,
@@ -8942,8 +9154,174 @@ class DevWatcher:
             "answered": 1 if sent else 0,
             "hold": hold,
             "auth": auth,
+            "limited": limited,
+        }
+
+    def _limited_record(
+        self,
+        worker: WorkerSession,
+        repo: "tuple[str, str] | None",
+        finding: "prompts_mod.PromptFinding",
+    ) -> "dict":
+        """One `usage.limited` record (issue #142): the lane's coordinates
+        and the finding's vocabulary tokens -- never its signature."""
+        record = {
+            "session": worker.name,
+            "edge": "issue" if worker.is_issue else "pr",
+            "number": worker.number,
+            "attempt": worker.attempt,
+            "round": worker.round_,
+            "source": finding.source,
+            "matched": finding.matched or prompts_mod.MATCHED_USAGE_LIMIT,
+            "model": finding.model,
+        }
+        if repo:
+            record["repo"] = f"{repo[0]}/{repo[1]}"
+        return record
+
+    def _spawn_row(self, name: str) -> "sqlite3.Row | None":
+        """The spawn row behind a worker session name on ANY of the four
+        ledgers, or None when this ledger never spawned it."""
+        return (
+            self.state.spawn_for_session(name)
+            or self.state.fix_spawn_for_session(name)
+            or self.state.maintain_spawn_for_session(name)
+            or self.state.revert_spawn_for_session(name)
+        )
+
+    def _first_turn_limit(
+        self, worker: WorkerSession, name: str, pane: str
+    ) -> "prompts_mod.PromptFinding | None":
+        """The first-turn limit check (issue #142): a `usage_limit` finding
+        with `source: "first_turn"` for a worker of ANY edge that this
+        ledger spawned inside the last stale window and whose captured pane
+        (`pane`, the responder's one capture) shows an idle prompt under the
+        usage-limit notice as its ONLY assistant turn -- else None.
+
+        Reads nothing new: the pane is the capture the responder already
+        took (a marker or the quiet gate asked for it), and the gate is the
+        ledger row. The verdict is remembered per session: a finding is
+        re-asserted while the session stays listed (its kill is retried),
+        and a session whose first turn was provably something else
+        (`classify_first_turn`'s `settled`) is never read for this again."""
+        cached = self._limit_findings.get(name)
+        if cached is not None:
+            return cached
+        if name in self._limit_settled:
+            return None
+        row = self._spawn_row(name)
+        if row is None:
+            return None
+        if time.time() - int(row["spawned_at"]) >= self.config.stale_minutes * 60:
+            self._limit_settled.add(name)
+            return None
+        finding, settled = prompts_mod.classify_first_turn(pane)
+        if finding is not None:
+            self._limit_findings[name] = finding
+        elif settled:
+            self._limit_settled.add(name)
+        return finding
+
+    def _answer_first_turn_limit(
+        self, worker: WorkerSession, finding: "prompts_mod.PromptFinding",
+        mode: str,
+    ) -> "dict":
+        """Act on a first-turn limit (issue #142): the account-kind policy
+        with the kill brought forward. The session is idle and useless -- a
+        worker whose only turn is the notice will never do anything -- so,
+        in live mode: page the operator (the account-kind page, once per
+        kind per PAGE_WINDOW_SECONDS), REFUND the attempt (`limited_at` on
+        its ledger row, which also arms the daemon-wide spawn hold for
+        ACCOUNT_HOLD_SECONDS -- see `_limit_hold`), kill it through the
+        responder's kill path, and leave one activity line naming the
+        limit and the refund. `observe` narrates and does nothing else;
+        dry-run withholds every side effect at its own seam. Returns the
+        responder's `{waiting, hold, limited}` for the sweep."""
+        name = worker.name
+        now = time.time()
+        live_mode = mode != PROMPT_OBSERVE
+        repo = self._slug_repos.get(worker.slug)
+        slug = f"{repo[0]}/{repo[1]}" if repo else FOREIGN_ESCALATION_SLUG
+        number = worker.number if repo else FOREIGN_ESCALATION_ISSUE
+        first = name not in self._limit_acted
+        self._limit_acted.add(name)
+        model = f" · model {finding.model}" if finding.model else ""
+        if first:
+            log.warning(
+                "first-turn limit check: %s answered its directive with the "
+                "usage-limit notice only (%s, matched %s%s) — %s",
+                name, finding.signature[:120], finding.matched, model,
+                "killing it, refunding the attempt and holding new spawns"
+                if live_mode else "observe mode, nothing done",
+            )
+        hold: "str | None" = None
+        record: "dict | None" = None
+        killed = False
+        if live_mode:
+            hold = f"usage_limit on {name} ({finding.signature[:80]})"
+            if first:
+                self._page_prompt(finding, worker, repo, slug, number)
+                if not self.config.dry_run:
+                    self.state.mark_limited(name, int(now))
+            if self.config.dry_run:
+                log.info("[dry-run] would kill %s (usage limit on its first turn)", name)
+            else:
+                try:
+                    self.alissa.kill_session(name)
+                    killed = True
+                except CommandError as exc:
+                    log.warning(
+                        "first-turn limit check: could not kill %s (%s) — "
+                        "kills are best-effort; retried next poll", name, exc,
+                    )
+            record = self._limited_record(worker, repo, finding)
+        if first and repo:
+            owner, repo_name = repo
+            tail = (
+                "" if not live_mode or killed or self.config.dry_run
+                else " · kill failed, retried next poll"
+            )
+            context = (
+                LIMITED_CONTEXT if live_mode
+                else "prompt-seen: usage limit on its first turn · observe mode, nothing sent"
+            )
+            line = self._activity_line(
+                name, f"{worker.edge} edge",
+                f"{context} (usage_limit · matched {finding.matched}{model} · "
+                f"source {finding.source}){tail}",
+            )
+            self._append_activity(
+                owner, repo_name, worker.number, line, f"{slug}#{worker.number}"
+            )
+        return {
+            "waiting": {
+                "session": name, "kind": finding.kind, "since": int(now),
+                "action": prompts_mod.VERB_KILL if live_mode else prompts_mod.VERB_WAIT,
+            },
+            "hold": hold,
+            "limited": record,
         }
 
+    def _limit_hold(self) -> "str | None":
+        """The spawn hold a usage limit keeps standing after its session was
+        killed (issue #142), or None: the newest `limited_at` on the ledger,
+        for ACCOUNT_HOLD_SECONDS. When it expires the retry edges respawn as
+        they would have, and a fresh pane still showing the notice stamps a
+        new row -- re-arming the hold (the re-confirmation doctrine of the
+        banner ladder). On the ledger, so a restart keeps it."""
+        row = self.state.newest_limited()
+        if row is None:
+            return None
+        age = max(0.0, time.time() - int(row["limited_at"]))
+        if age >= prompts_mod.ACCOUNT_HOLD_SECONDS:
+            return None
+        return (
+            f"usage_limit on {row['session']} {int(age // 60)} min ago — held "
+            f"until the account is back (the hold lifts "
+            f"{int((prompts_mod.ACCOUNT_HOLD_SECONDS - age) // 60)} min from "
+            f"now and the next spawn re-confirms)"
+        )
+
     def _page_prompt(
         self,
         finding: "prompts_mod.PromptFinding",
@@ -9119,9 +9497,12 @@ class DevWatcher:
                 "max_sessions is not enforced this pass, and session liveness "
                 "reads INDETERMINATE (no resume can fire)", exc,
             )
+            # The usage-limit hold (issue #142) is on the ledger, not the
+            # listing, so it stands through a listing failure too.
+            limit_hold = self._limit_hold()
             return (
-                Sweep(reaped=0, names=set()),
-                SessionBudget(None, 0),
+                Sweep(reaped=0, names=set(), hold=limit_hold),
+                SessionBudget(None, 0, hold=limit_hold),
                 SessionLiveness(None),
             )
         sweep = self._reap_sessions(sessions)
@@ -9131,14 +9512,17 @@ class DevWatcher:
         # outcome -- the account-level hold -- has to reach every edge.
         prompt = self._respond_to_prompts(sessions, sweep.names)
         sweep = replace(
-            sweep, waiting=prompt.waiting, hold=prompt.hold, answered=prompt.answered,
-            auth_rejected=prompt.auth_rejected,
+            sweep, waiting=prompt.waiting,
+            hold=prompt.hold or self._limit_hold(), answered=prompt.answered,
+            auth_rejected=prompt.auth_rejected, usage_limited=prompt.usage_limited,
         )
         if sweep.hold:
             log.warning(
                 "prompt responder: HOLDING new worker spawns this pass — %s. "
                 "Live sessions keep running; the hold lifts on the first "
-                "pass that no longer sees the notice", sweep.hold,
+                "pass that no longer sees the notice (a usage limit's hold: "
+                "%d min after the last one)", sweep.hold,
+                prompts_mod.ACCOUNT_HOLD_SECONDS // 60,
             )
         active = self._count_active_sessions(sessions, sweep.names)
         self._check_session_cap(active, sweep)
@@ -10199,6 +10583,7 @@ class DevWatcher:
             deferrals=deferrals,
             reaps=self._reap_records(sweep.names),
             auth_rejections=list(sweep.auth_rejected),
+            usage_limits=list(sweep.usage_limited),
             now_ms=int(time.time() * 1000),
         )