alissa-tools-github-devloop 0.8.29__tar.gz → 0.8.30__tar.gz

{alissa_tools_github_devloop-0.8.29/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.8.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.29
+Version: 0.8.30
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_devloop-0.8.29 → alissa_tools_github_devloop-0.8.30}/src/main/alissa/tools/github/devloop/alissa.py

@@ -80,6 +80,26 @@ def pane_path_argv(name: str) -> "list[str]":
     ]
 
 
+# What `#{pane_current_command}` reads on a worker pane whose `claude` has
+# EXITED (issue #140): the shell `alissa tmux new` launched it from, back in
+# the foreground. A live worker reads `node` (Claude Code's runtime); a
+# name here means the process the session was spawned for is gone, whatever
+# the session listing says about liveness.
+SHELL_COMMANDS = frozenset((
+    "bash", "sh", "zsh", "fish", "dash", "ksh", "ash", "tcsh", "csh",
+))
+
+
+def pane_command_argv(name: str) -> "list[str]":
+    """`tmux -S <socket> display-message -p -t =<real>: #{pane_current_command}`:
+    the foreground process of the session's active pane, by name."""
+    check_session_name(name)
+    return [
+        "tmux", "-S", tmux_socket(), "display-message", "-p",
+        "-t", tmux_target(name), "#{pane_current_command}",
+    ]
+
+
 def send_keys_argv(name: str, keys: "tuple[str, ...]") -> "list[str]":
     """`tmux -S <socket> send-keys -t =<real> <key>…` with every key drawn
     from `prompts.ALLOWED_KEYS`. Anything else -- a letter, a word, a path --
@@ -270,6 +290,23 @@ class Alissa:
             log.debug("could not read the pane path of %s (%s)", name, exc)
             return ""
 
+    def pane_command(self, name: str) -> str:
+        """The session's pane current command (`#{pane_current_command}`),
+        or "" when tmux cannot answer. The first-turn death check's one
+        liveness probe (issue #140): a worker whose pane reads a shell
+        (`SHELL_COMMANDS`) has lost its `claude`, however alive the tmux
+        session itself is. A READ: runs under dry-run too."""
+        try:
+            argv = pane_command_argv(name)
+        except ValueError as exc:
+            log.warning("pane_command refused: %s", exc)
+            return ""
+        try:
+            return run(argv, timeout=15).strip()
+        except CommandError as exc:
+            log.debug("could not read the pane command of %s (%s)", name, exc)
+            return ""
+
     def send_keys(self, name: str, *keys: str, dry_run: bool = False) -> bool:
         """Press `keys` -- each one of `prompts.ALLOWED_KEYS`, nothing else
         -- on ONE managed session's pane. True when tmux accepted them.

{alissa_tools_github_devloop-0.8.29 → alissa_tools_github_devloop-0.8.30}/src/main/alissa/tools/github/devloop/loop.py

@@ -464,7 +464,7 @@ from . import janitor
 from . import fleet_vitals as fleet_vitals_mod
 from . import loop_events as loop_events_mod
 from . import prompts as prompts_mod
-from .alissa import MANAGED_PREFIX, Alissa
+from .alissa import MANAGED_PREFIX, SHELL_COMMANDS, Alissa
 from .alissa_client import AlissaClient
 from .bows import BowRepoSource
 from .hubs import (
@@ -1268,6 +1268,10 @@ PROMPT_PAGE_COMMENT = (
     "not answering it, and it is HOLDING new worker spawns until the "
     "condition clears (live sessions keep running). Operator options: "
     "`login_expired` → re-run the claude login on the worker container; "
+    "`auth_rejected` → Claude refused the worker's credential (401): replace "
+    "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` "
     "→ 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 "
@@ -1575,6 +1579,11 @@ ESCALATION_PROMPT_PAGE = "prompt-page"
 # a slow container.
 PROMPT_SETTLE_SECONDS = 3.0
 
+# The first-turn death check's "never looked" marker (issue #140): the
+# cache maps a session to a finding, to None ("looked: died, not auth"),
+# or -- absent -- to this, so the two negatives cannot be confused.
+_UNCHECKED = object()
+
 
 def prompt_event_kind(kind: str, verb: str, session: str, seq: int) -> str:
     """The ledger kind of ONE responder act: `prompt:<kind>:<verb>@<session>#<seq>`.
@@ -2482,6 +2491,11 @@ class Sweep:
     waiting: "tuple[dict, ...]" = ()
     hold: "str | None" = None
     answered: int = 0
+    # The refusals the responder observed this pass (issue #140): the
+    # `auth.rejected` records the loop-events emitter turns into events,
+    # one per session (`{session, repo, edge, number, attempt, round,
+    # source, matched}`).
+    auth_rejected: "tuple[dict, ...]" = ()
 
     @property
     def total(self) -> int:
@@ -2493,12 +2507,14 @@ class Sweep:
 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, and the keystroke answers
-    sent. Folded into the pass's `Sweep`."""
+    spawn hold an account-level notice raised, the keystroke answers
+    sent, and the `auth.rejected` records (issue #140). Folded into the
+    pass's `Sweep`."""
 
     waiting: "tuple[dict, ...]" = ()
     hold: "str | None" = None
     answered: int = 0
+    auth_rejected: "tuple[dict, ...]" = ()
 
 
 @dataclass(frozen=True, slots=True)
@@ -3247,6 +3263,16 @@ class DevWatcher:
         # rebuilt only when the allowlist itself changes rather than per
         # session per sweep.
         self._slug_repos = _slug_index(config.repos)
+        # The first-turn death check's memory (issue #140): every develop
+        # session whose pane was found back in a shell inside its first
+        # stale window, mapped to what its last lines said -- an
+        # `auth_rejected` finding, or None for the ordinary "died, not
+        # auth". The pane is captured ONCE per session; later passes
+        # re-assert a cached finding (so the hold and its expiry run the
+        # login_expired ladder) and never re-read a None. In-memory on
+        # 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 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,
@@ -8589,6 +8615,7 @@ class DevWatcher:
         waiting: "list[dict]" = []
         hold: "str | None" = None
         answered = 0
+        rejected: "list[dict]" = []
         for entry in sessions:
             name = str(entry.get("name") or "")
             worker = parse_worker_session(name)
@@ -8596,6 +8623,20 @@ class DevWatcher:
                 continue
             live.add(name)
             tmux_name = str(entry.get("session") or "") or MANAGED_PREFIX + name
+            # The first-turn death check (issue #140) runs BEFORE the two
+            # triggers below: a pane whose `claude` exited is a shell at
+            # rest, which neither a marker nor the quiet gate reads as a
+            # prompt, and which the banner classifier would call idle.
+            exited = self._first_turn_death(worker, name)
+            if exited is not None:
+                outcome = self._answer_prompt(worker, tmux_name, None, exited, mode)
+                waiting.append(outcome["waiting"])
+                answered += outcome["answered"]
+                if outcome["hold"] and hold is None:
+                    hold = outcome["hold"]
+                if outcome["auth"]:
+                    rejected.append(outcome["auth"])
+                continue
             marker = self._waiting_marker(tmux_name)
             quiet = self._entry_quiet_for(entry)
             if marker is None and (
@@ -8624,8 +8665,88 @@ class DevWatcher:
             answered += outcome["answered"]
             if outcome["hold"] and hold is None:
                 hold = outcome["hold"]
+            if outcome["auth"]:
+                rejected.append(outcome["auth"])
         self.state.prune_prompt_sightings(live)
-        return PromptSweep(waiting=tuple(waiting), hold=hold, answered=answered)
+        for gone in [n for n in self._exit_findings if n not in live]:
+            del self._exit_findings[gone]
+        return PromptSweep(
+            waiting=tuple(waiting), hold=hold, answered=answered,
+            auth_rejected=tuple(rejected),
+        )
+
+    def _first_turn_death(
+        self, worker: WorkerSession, name: str
+    ) -> "prompts_mod.PromptFinding | None":
+        """The first-turn death check (issue #140): an `auth_rejected`
+        finding with `source: "exit"` for a develop session whose `claude`
+        died on a 401 before it could do anything, else None.
+
+        The candidate is narrow by design, and every leg is cheap or rare:
+        a DEVELOP session (the only edge whose lane has no PR until the
+        worker opens one) that this ledger spawned inside the last stale
+        window, whose pane's current command is back in `SHELL_COMMANDS`
+        (one `display-message` per young develop session per pass -- a
+        handful, for twenty minutes), with no open PR linked to its issue
+        (one timeline read, only for a dead shell). Its last lines are
+        captured ONCE and read by `prompts.classify_exit`; a match is
+        remembered and re-asserted on later passes while the pane is still
+        a shell, so the page-and-hold path and its one-hour expiry run
+        exactly as they do for a login_expired banner. No match is the
+        ordinary "died, not auth": remembered too (never re-read), and
+        nothing new is emitted -- the stale-retry edge's respawn is the
+        remedy it always was."""
+        cached = self._exit_findings.get(name, _UNCHECKED)
+        if cached is None:
+            return None
+        if cached is not _UNCHECKED:
+            command = self.alissa.pane_command(name)
+            if command in SHELL_COMMANDS or not command:
+                # Still the dead shell -- or tmux could not answer ("" is
+                # a failed read, never a command), in which case the last
+                # thing known stands: forgetting it here would re-arm a
+                # second capture inside the stale window and drop the
+                # hold and its expiry past it, for a shell still dead.
+                return cached  # type: ignore[return-value]
+            # A named, non-shell command: someone re-ran claude by hand in
+            # the session -- a live pane again, and the ordinary triggers
+            # own it from here.
+            del self._exit_findings[name]
+            return None
+        if not worker.is_issue:
+            return None
+        row = self.state.spawn_for_session(name)
+        if row is None:
+            return None
+        if time.time() - int(row["spawned_at"]) >= self.config.stale_minutes * 60:
+            return None
+        if self.alissa.pane_command(name) not in SHELL_COMMANDS:
+            return None
+        repo = self._slug_repos.get(worker.slug)
+        if repo is None:
+            return None
+        try:
+            linked = self.github.linked_open_prs(repo[0], repo[1], worker.number)
+        except Exception as exc:
+            log.debug(
+                "first-turn death check: could not read the PRs linked to %s#%d "
+                "(%s) — deferring the check to the next pass",
+                row["repo_slug"], worker.number, exc,
+            )
+            return None
+        if linked:
+            return None
+        pane = self.alissa.capture_pane(name, prompts_mod.PANE_LINES)
+        finding = prompts_mod.classify_exit(pane)
+        self._exit_findings[name] = finding
+        if finding is None:
+            log.info(
+                "first-turn death check: %s exited to a shell %d s after its "
+                "spawn with no linked PR and no auth wording in its last lines "
+                "— died, not auth; the retry edge owns it",
+                name, int(time.time() - int(row["spawned_at"])),
+            )
+        return finding
 
     def _answer_prompt(
         self,
@@ -8770,10 +8891,16 @@ class DevWatcher:
                 tail = " · killed; the ordinary retry edge respawns"
             elif action.sends_keys and not sent and not self.config.dry_run:
                 tail = " · keys not sent (tmux refused)"
+            # The auth kinds name the wording and where it was read (the
+            # `auth.rejected` event's own tokens, never the pane's text).
+            auth_tail = (
+                f" · matched {finding.matched} · source {finding.source}"
+                if finding.kind in prompts_mod.AUTH_KINDS and finding.matched else ""
+            )
             line = self._activity_line(
                 name, f"{worker.edge} edge",
                 f"{prefix}: {finding.kind} → {action.verb} ({action.reason})"
-                f"{f' · target {target_rel}' if target_rel else ''}"
+                f"{f' · target {target_rel}' if target_rel else ''}{auth_tail}"
                 f" · {since} s after it appeared{tail}",
             )
             self._append_activity(owner, repo_name, worker.number, line, f"{slug}#{worker.number}")
@@ -8787,6 +8914,25 @@ class DevWatcher:
                 "prompt responder: %s (%s) is not on the allowlist — %s → %s "
                 "recorded in the log only", name, worker.slug, finding.kind, action.verb,
             )
+        # The `auth.rejected` record (issue #140): the two AUTH_KINDS are
+        # the same signal, and the record carries the vocabulary tokens and
+        # the lane's coordinates -- never the signature. Live mode only:
+        # `observe` pages nobody and holds nothing, and Studio acts on this
+        # event (it flips the stored credential), so an observing daemon
+        # must not make that claim either.
+        auth: "dict | None" = None
+        if finding.kind in prompts_mod.AUTH_KINDS and live_mode:
+            auth = {
+                "session": 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_API_ERROR_401,
+            }
+            if repo:
+                auth["repo"] = slug
         return {
             "waiting": {
                 "session": name, "kind": finding.kind,
@@ -8795,6 +8941,7 @@ class DevWatcher:
             },
             "answered": 1 if sent else 0,
             "hold": hold,
+            "auth": auth,
         }
 
     def _page_prompt(
@@ -8985,6 +9132,7 @@ class DevWatcher:
         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,
         )
         if sweep.hold:
             log.warning(
@@ -10050,6 +10198,7 @@ class DevWatcher:
         self.loop_events.emit_pass(
             deferrals=deferrals,
             reaps=self._reap_records(sweep.names),
+            auth_rejections=list(sweep.auth_rejected),
             now_ms=int(time.time() * 1000),
         )
 

{alissa_tools_github_devloop-0.8.29 → alissa_tools_github_devloop-0.8.30}/src/main/alissa/tools/github/devloop/loop_events.py

@@ -69,6 +69,22 @@ Event vocabulary (the `kind` field; Studio validates the SHAPE
   `escalation.stacked_base`, `escalation.foreign_session`, …): Studio's kind
   shape allows no hyphens, so the raw ledger kind rides in ``data.ledgerKind``
   and `reason` instead.
+* ``auth.rejected`` — a worker REFUSED by Claude (issue #140; Studio design
+  `managed-dark-factory-claude-auth.md` §2.6, lane L5): the prompt responder
+  saw a documented 401 wording (or the login-expired banner) on a live
+  pane, or the first-turn death check found one in the last lines of a pane
+  whose `claude` had already exited. Pass-observed and keyed on the SESSION
+  name (`auth_rejected_key`), so one session emits at most one whatever
+  the pass count. ``data: { status: 401, source: "pane" | "exit", matched,
+  envName, tokenSuffix }`` — `envName` is which of `ANTHROPIC_API_KEY` /
+  `CLAUDE_CODE_OAUTH_TOKEN` the container carries, read BY NAME ONLY (`null`
+  on a persisted `claude /login`); `tokenSuffix` is the last four characters
+  of that variable's value, computed in-process and emitted as the suffix
+  only (`null` beside a `null` envName). The suffix is the design's R1 key:
+  Studio's reducer flips a credential only when the suffix matches the
+  stored row, so a container still running an OLD token after a same-mode
+  replace cannot flip the new, good credential. `reason` is a fixed
+  sentence, never the pane's text.
 
 No ``poll`` vitals events: live vitals stay a console pull (`/api/state`).
 """
@@ -76,6 +92,7 @@ No ``poll`` vitals events: live vitals stay a console pull (`/api/state`).
 from __future__ import annotations
 
 import logging
+import os
 import re
 from typing import Iterable, Mapping, Sequence
 
@@ -253,6 +270,14 @@ def reap_key(session: str) -> str:
     return f"{SEAT}:reap:{session}"
 
 
+def auth_rejected_key(session: str) -> str:
+    """One `auth.rejected` per SESSION (issue #140): worker names are
+    deterministic per (repo, number, attempt) and a session is refused
+    once -- the pane detector seeing the same banner on every pass, or the
+    exit check re-asserting a dead shell, is the same refusal."""
+    return f"{SEAT}:auth.rejected:{session}"
+
+
 def escalation_key(event_kind: str, repo_slug: str, number: int,
                    raw_kind: str) -> str:
     """Escalation-derived events key on the ledger PRIMARY KEY verbatim
@@ -494,6 +519,83 @@ def reap_events(reaps: "Sequence[Mapping]", at_ms: int) -> "list[dict]":
     return events
 
 
+# -- auth.rejected (issue #140) ---------------------------------------------
+
+# The credential variables a container may carry, in Claude Code's own
+# precedence order (design §1.4: `ANTHROPIC_API_KEY` outranks
+# `CLAUDE_CODE_OAUTH_TOKEN`; both outrank the persisted login). Read by
+# NAME only -- the value is touched for its last four characters and for
+# nothing else, and never leaves this function whole.
+AUTH_ENV_NAMES = ("ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN")
+TOKEN_SUFFIX_CHARS = 4
+AUTH_STATUS = 401
+
+# The fixed `reason` sentences -- never the pane's text (the contract's
+# `reason` is ≤ 2000 characters, and a pane is another agent's screen).
+AUTH_REASONS = {
+    "pane": "claude answered 401 — the worker's pane shows an auth banner",
+    "exit": "claude answered 401 on the first turn and exited",
+}
+
+
+def credential_identity(
+    environ: "Mapping[str, str] | None" = None,
+) -> "tuple[str | None, str | None]":
+    """`(envName, tokenSuffix)` for the container this daemon runs in: the
+    first of AUTH_ENV_NAMES that is set and non-blank, and the last
+    TOKEN_SUFFIX_CHARS characters of its value; `(None, None)` when neither
+    is set -- a container running on a persisted `claude /login`. The
+    workers are spawned on this same container by `alissa tmux`, so the
+    daemon's environment IS theirs."""
+    env = os.environ if environ is None else environ
+    for name in AUTH_ENV_NAMES:
+        value = str(env.get(name) or "").strip()
+        if value:
+            return name, value[-TOKEN_SUFFIX_CHARS:]
+    return None, None
+
+
+def auth_rejected_events(
+    rejections: "Sequence[Mapping]",
+    at_ms: int,
+    environ: "Mapping[str, str] | None" = None,
+) -> "list[dict]":
+    """Pass-observed refusals as events. Each entry carries `session`,
+    `source` (`pane` / `exit`), `matched` (one of the design's tokens),
+    and -- when the session resolved to a repo -- `repo`, `edge`
+    (`issue`/`pr`), `number`, `attempt`, `round`. Keyed on the session
+    name alone (see `auth_rejected_key`). `data` is the design's §2.6
+    shape, `envName` and `tokenSuffix` from `credential_identity`."""
+    env_name, suffix = credential_identity(environ)
+    events = []
+    for item in rejections:
+        edge = str(item.get("edge") or "")
+        number = item.get("number")
+        source = str(item.get("source") or "pane")
+        events.append(_event(
+            "auth.rejected",
+            at_ms,
+            auth_rejected_key(str(item["session"])),
+            repo=str(item.get("repo") or "") or None,
+            issue_number=int(number) if number is not None and edge == "issue"
+            else None,
+            pr_number=int(number) if number is not None and edge == "pr"
+            else None,
+            attempt=item.get("attempt"),
+            round_=item.get("round"),
+            session=str(item["session"]),
+            reason=AUTH_REASONS.get(source, AUTH_REASONS["pane"]),
+            data={
+                "status": AUTH_STATUS,
+                "source": source,
+                "matched": str(item.get("matched") or "api_error_401"),
+                "envName": env_name,
+                "tokenSuffix": suffix,
+            },
+        ))
+    return events
+
+
 # -- the emitter -------------------------------------------------------------
 
 
@@ -513,9 +615,16 @@ class LoopEventEmitter:
       with its flag intact.
     """
 
-    def __init__(self, state, client: "AlissaClient"):
+    def __init__(
+        self, state, client: "AlissaClient",
+        environ: "Mapping[str, str] | None" = None,
+    ):
         self.state = state
         self.client = client
+        # Where `auth.rejected` reads the credential's name and suffix
+        # (issue #140): the process environment by default, injectable so a
+        # test never depends on -- or leaks -- the seat's own token.
+        self.environ = environ
         self._emitted: "set[str]" = set()
         self._observed: "dict[str, dict]" = {}
         self._resume_keys: "set[str]" = set()
@@ -530,6 +639,7 @@ class LoopEventEmitter:
         *,
         deferrals: "Sequence[Mapping]" = (),
         reaps: "Sequence[Mapping]" = (),
+        auth_rejections: "Sequence[Mapping]" = (),
         now_ms: int,
     ) -> int:
         """Derive this pass's events and POST what the server has not yet
@@ -538,10 +648,13 @@ class LoopEventEmitter:
         Returns how many events were accepted this pass. NEVER raises: any
         failure — a wedged ledger read, a transport error, an ingest 400 —
         logs one warning naming the count (and status, when there is one)
-        and the pass completes."""
+        and the pass completes. `auth_rejections` (issue #140) are
+        pass-observed like the reaps: carried until a POST lands, first
+        observation per session wins."""
         try:
             for event in (defer_events(deferrals, now_ms)
-                          + reap_events(reaps, now_ms)):
+                          + reap_events(reaps, now_ms)
+                          + auth_rejected_events(auth_rejections, now_ms, self.environ)):
                 self._observed.setdefault(str(event["dedupeKey"]), event)
             events = (
                 spawn_events(

{alissa_tools_github_devloop-0.8.29 → alissa_tools_github_devloop-0.8.30}/src/main/alissa/tools/github/devloop/prompts.py

@@ -50,6 +50,12 @@ KIND_PERMISSION = "permission"
 KIND_TRUST = "trust"
 KIND_RESUME_PICKER = "resume_picker"
 KIND_LOGIN_EXPIRED = "login_expired"
+# A 401 from the API on a worker's turn (issue #140, Studio design
+# managed-dark-factory-claude-auth §2.6): the credential the container
+# carries -- an env token or the persisted login -- was REFUSED. Same
+# family as login_expired (an account-level notice: page, hold spawns, no
+# keys) and the same loop-event signal (`auth.rejected`, see `matched`).
+KIND_AUTH_REJECTED = "auth_rejected"
 KIND_USAGE_LIMIT = "usage_limit"
 KIND_OUT_OF_CREDITS = "out_of_credits"
 KIND_UNKNOWN_DIALOG = "unknown_dialog"
@@ -60,6 +66,7 @@ KINDS = (
     KIND_TRUST,
     KIND_RESUME_PICKER,
     KIND_LOGIN_EXPIRED,
+    KIND_AUTH_REJECTED,
     KIND_USAGE_LIMIT,
     KIND_OUT_OF_CREDITS,
     KIND_UNKNOWN_DIALOG,
@@ -68,7 +75,38 @@ KINDS = (
 # The account-level kinds: nothing a keystroke can fix. The policy pages the
 # operator and holds NEW spawns while the condition stands, so attempts are
 # not burned against a dead account.
-ACCOUNT_KINDS = frozenset((KIND_LOGIN_EXPIRED, KIND_USAGE_LIMIT, KIND_OUT_OF_CREDITS))
+ACCOUNT_KINDS = frozenset((
+    KIND_LOGIN_EXPIRED, KIND_AUTH_REJECTED, KIND_USAGE_LIMIT, KIND_OUT_OF_CREDITS,
+))
+
+# The two kinds that ARE the `auth.rejected` loop event (issue #140): a
+# refused credential, whichever wording Claude Code chose for it. The
+# existing login_expired banner is the same signal under its old name.
+AUTH_KINDS = frozenset((KIND_LOGIN_EXPIRED, KIND_AUTH_REJECTED))
+
+# -- the auth.rejected vocabulary (design §2.6) ---------------------------
+
+# `data.matched` -- WHICH documented wording the pane showed. A closed list,
+# settled in the design before any daemon emits it; Studio's reducer reads
+# the suffix, not this, so the token is for the operator's eyes.
+MATCHED_API_ERROR_401 = "api_error_401"
+MATCHED_INVALID_API_KEY = "invalid_api_key"
+MATCHED_OAUTH_EXPIRED = "oauth_expired"
+MATCHED_OAUTH_REVOKED = "oauth_revoked"
+MATCHED_LOGIN_EXPIRED = "login_expired"
+AUTH_MATCHED = (
+    MATCHED_API_ERROR_401,
+    MATCHED_INVALID_API_KEY,
+    MATCHED_OAUTH_EXPIRED,
+    MATCHED_OAUTH_REVOKED,
+    MATCHED_LOGIN_EXPIRED,
+)
+
+# `data.source` -- where the detector read the wording: a still-open pane
+# (the banner classifier) or the last lines of a pane whose `claude`
+# already exited back to the shell (the first-turn death check).
+SOURCE_PANE = "pane"
+SOURCE_EXIT = "exit"
 
 # -- keys ----------------------------------------------------------------
 
@@ -122,6 +160,16 @@ BANNER_LINES = 3
 # excerpt the issue allows: three lines, secrets-scrubbed, never more).
 EXCERPT_LINES = 3
 
+# How many non-blank lines from the bottom the first-turn death check reads
+# (issue #140). A `claude` that 401s prints the error and exits; the shell
+# then draws its prompt (and, on some shells, a blank line or two) under it,
+# so the wording sits a few lines above the bottom -- never as the LAST
+# thing on screen, which is why the banner rule cannot see it. Twelve lines
+# hold the error, the JSON body Claude Code sometimes wraps it in, and the
+# shell chrome, and nothing older: the scrollback above is the worker's own
+# turn, where a quoted phrase would be a false positive.
+EXIT_SCAN_LINES = 12
+
 # The default per-kind page cadence for the account-level kinds: one
 # operator page per kind per six hours through the escalation ledger.
 PAGE_WINDOW_SECONDS = 6 * 3600
@@ -161,6 +209,34 @@ _LOGIN_EXPIRED_RE = re.compile(
     r"(?:Your )?(?:session|login|token) (?:has )?expired\b)",
     re.IGNORECASE,
 )
+# The 401 wordings Anthropic documents (issue #140; design §1.4: the Claude
+# Code *Errors* page and the Platform *Authentication* page): `API Error:
+# 401 …`, `Invalid authentication credentials`, `Invalid API key`, `OAuth
+# token has expired`, `OAuth token revoked`. Anchored like the banners
+# above (an optional error glyph is the only thing allowed before the
+# wording), and read on the de-decorated line: Claude Code draws the API
+# error on a `⎿` row of its own under the turn that failed, so
+# `_banner_line` admits THAT row for this one family -- a `●` turn or tool
+# call above it in the same paragraph still makes it a worker's output.
+_AUTH_REJECTED_RE = re.compile(
+    r"^(?:[✗✘⚠]\s*)?(?:API Error:\s*401\b|Invalid authentication credentials\b|"
+    r"Invalid API key\b|OAuth token (?:has )?expired\b|"
+    r"OAuth token (?:has been |was )?revoked\b)",
+    re.IGNORECASE,
+)
+# The specific wordings, tested on an auth line AFTER `_AUTH_REJECTED_RE`
+# admitted it, most specific first; a line none of them names is the bare
+# 401 (`api_error_401`), which is also what `API Error: 401 Invalid
+# authentication credentials` reads as -- the credentials sentence is the
+# 401's own message.
+_AUTH_MATCHED_RES = (
+    (MATCHED_INVALID_API_KEY, re.compile(r"Invalid API key\b", re.IGNORECASE)),
+    (MATCHED_OAUTH_EXPIRED, re.compile(r"OAuth token (?:has )?expired\b", re.IGNORECASE)),
+    (MATCHED_OAUTH_REVOKED, re.compile(r"OAuth token (?:has been |was )?revoked\b", re.IGNORECASE)),
+)
+# A `⎿` tool-OUTPUT row specifically (the `●` turn row is the other half of
+# `_OUTPUT_ROW_RE`): the row Claude Code draws its own API error on.
+_TOOL_OUTPUT_ROW_RE = re.compile(r"^\s*⎿")
 _USAGE_LIMIT_RE = re.compile(
     r"^(?:(?:You've|You have) hit your (?:(?:weekly|daily|5-hour|session|usage) )?limit\b|"
     r"(?:Weekly|Daily|Session|Usage) limit reached\b|Usage limit\b|"
@@ -178,6 +254,11 @@ _OUT_OF_CREDITS_RE = re.compile(
 # (`⎿  ...`): a worker's output, which Claude Code never uses to draw a
 # notice of its own. Tested on the ANSI-stripped line, decoration intact.
 _OUTPUT_ROW_RE = re.compile(r"^\s*[●⎿]")
+# The row Claude Code draws for a SUBMITTED prompt (`> implement issue
+# #7`) or the bare input prompt at column 0 (`❯`): the boundary between
+# one worker turn and the next, which is what releases the lines below
+# it from the `●` above (issue #140, PR #141 review round 2).
+_USER_PROMPT_ROW_RE = re.compile(r"^[>❯](?:\s|$)")
 # The dialog's path line, as the trust gate draws it: the path and nothing
 # else on the line.
 _PATH_LINE_RE = re.compile(r"^/[^\s'\"]+$")
@@ -273,14 +354,31 @@ def _is_banner_chrome(text: str) -> bool:
     return text in ("❯", ">") or _is_chrome(text)
 
 
+def auth_matched(text: str) -> "str | None":
+    """Which documented 401 wording this (plain) line is, as the
+    `data.matched` token, or None when it is not an auth-rejected line at
+    all. The login-expired banner is NOT read here (its own regex and kind
+    already exist); `classify` stamps that finding `login_expired`."""
+    if not _AUTH_REJECTED_RE.search(text):
+        return None
+    for token, pattern in _AUTH_MATCHED_RES:
+        if pattern.search(text):
+            return token
+    return MATCHED_API_ERROR_401
+
+
 def _banner_line(lines: "list[str]") -> "tuple[int, str] | None":
     """The one line an account-level banner could be, as (index into
     `lines`, plain text), or None. Bottom-up: chrome and the bare input
     prompt are skipped, then the contiguous paragraph above them is read
     up to the blank line or chrome that bounds it. A `●`/`⎿` tool row
     anywhere in that paragraph makes it a worker's output (the row and its
-    indented continuation lines), never a banner; otherwise the
-    paragraph's last BANNER_LINES lines are the candidates."""
+    indented continuation lines), never a banner -- with ONE exception: a
+    `⎿` row that IS a documented 401 wording is how Claude Code draws its
+    own API error (issue #140), so that row is admitted as a candidate,
+    and a `●` turn above it in the same paragraph still voids the whole
+    paragraph. Otherwise the paragraph's last BANNER_LINES lines are the
+    candidates."""
     index = len(lines) - 1
     while index >= 0 and _is_banner_chrome(_plain(lines[index])):
         index -= 1
@@ -290,12 +388,16 @@ def _banner_line(lines: "list[str]") -> "tuple[int, str] | None":
         text = _plain(raw)
         if _is_banner_chrome(text):
             break
-        if _OUTPUT_ROW_RE.match(raw):
+        if _OUTPUT_ROW_RE.match(raw) and not (
+            _TOOL_OUTPUT_ROW_RE.match(raw) and _AUTH_REJECTED_RE.search(text)
+        ):
             return None
         paragraph.append((index, text))
         index -= 1
     for index, text in paragraph[:BANNER_LINES]:
-        for pattern in (_LOGIN_EXPIRED_RE, _USAGE_LIMIT_RE, _OUT_OF_CREDITS_RE):
+        for pattern in (
+            _LOGIN_EXPIRED_RE, _AUTH_REJECTED_RE, _USAGE_LIMIT_RE, _OUT_OF_CREDITS_RE,
+        ):
             if pattern.search(text):
                 return index, text
     return None
@@ -323,7 +425,12 @@ class PromptFinding:
     it, scrubbed, for the DEBUG log and nothing else. `pane_hash` fingerprints
     the dialog so the loop can tell "the same pane, one poll later" from "a
     new prompt": the unknown-dialog ladder and the answered/unanswered
-    re-capture both hang off it."""
+    re-capture both hang off it.
+
+    `matched` and `source` are the `auth.rejected` event's vocabulary
+    (issue #140), set on the two AUTH_KINDS only: which documented wording
+    was seen (`AUTH_MATCHED`) and whether it was read off a live pane or
+    the last lines of an exited one (`SOURCE_PANE` / `SOURCE_EXIT`)."""
 
     kind: str
     signature: str
@@ -331,6 +438,8 @@ class PromptFinding:
     options: "tuple[PromptOption, ...]"
     excerpt: "tuple[str, ...]"
     pane_hash: str
+    matched: "str | None" = None
+    source: str = SOURCE_PANE
 
     @property
     def selected(self) -> "PromptOption | None":
@@ -425,6 +534,96 @@ def _excerpt(lines: "list[str]", index: int) -> "tuple[str, ...]":
     return tuple(scrub(strip_ansi(ln).rstrip()) for ln in lines[lo:hi])
 
 
+def _matched_for(kind: str, text: str) -> "str | None":
+    """The `matched` token of a banner finding: the login-expired banner is
+    reported as the same signal (`login_expired`), an auth line as the
+    wording it carries, every other kind as None."""
+    if kind == KIND_LOGIN_EXPIRED:
+        return MATCHED_LOGIN_EXPIRED
+    if kind == KIND_AUTH_REJECTED:
+        return auth_matched(text)
+    return None
+
+
+def classify_exit(pane: str) -> "PromptFinding | None":
+    """The first-turn death check's half of the classifier (issue #140):
+    what a pane whose `claude` has already EXITED back to the shell says
+    about why, or None for the ordinary "died, not auth".
+
+    Only ever called on a pane the loop has established is a shell (the
+    pane's current command is one of `alissa.SHELL_COMMANDS`, inside the
+    first stale window of the spawn, no linked PR), so the banner rule --
+    the wording must be the LAST thing on screen -- does not apply: the
+    shell prompt is the last thing on screen, and the error sits a few
+    lines above it. The last EXIT_SCAN_LINES non-blank lines are read
+    bottom-up for a documented 401 wording or the login-expired banner; a
+    `●` turn row is skipped, and so is EVERY line that belongs to a turn
+    (`_under_a_turn`): every line below a `●` row until the next submitted
+    prompt row (`>`), paragraph breaks included -- Claude Code renders one
+    assistant message as blank-separated paragraphs and code blocks, and
+    only the first line carries the `●`. So the worker's own prose
+    wrapping onto the wording, a quoted error in a paragraph or code block
+    of its own, a README quoted under a tool call, a `grep` for it, are
+    all the worker's -- never Claude Code's error, which is drawn under
+    the `>` prompt row (`⎿  API Error: 401 …`) or, on a start-up refusal,
+    before any turn exists. The finding is an `auth_rejected` with
+    `source: "exit"` and the wording under `matched` -- the same kind the
+    pane detector raises, so the policy (page once, hold spawns) is the
+    same row."""
+    if not pane or not pane.strip():
+        return None
+    lines = pane.splitlines()
+    indices = [i for i, ln in enumerate(lines) if _plain(ln)][-EXIT_SCAN_LINES:]
+    for index in reversed(indices):
+        raw = strip_ansi(lines[index])
+        if _OUTPUT_ROW_RE.match(raw) and not _TOOL_OUTPUT_ROW_RE.match(raw):
+            continue
+        text = _plain(raw)
+        matched = (
+            MATCHED_LOGIN_EXPIRED if _LOGIN_EXPIRED_RE.search(text)
+            else auth_matched(text)
+        )
+        if matched is None:
+            continue
+        if _under_a_turn(lines, index):
+            # Any line under a `●` turn or tool call, up to the next `>`
+            # prompt row, is that turn's: a `⎿` row is its output (a README
+            # quoting the wording, a `grep` for it), a plain row is its own
+            # prose -- wrapped onto the wording, or quoting it in a later
+            # paragraph or code block. Claude Code's error is never drawn
+            # under a `●` without a `>` between them.
+            continue
+        return PromptFinding(
+            kind=KIND_AUTH_REJECTED,
+            signature=scrub(text),
+            target=None,
+            options=(),
+            excerpt=_excerpt(lines, index),
+            pane_hash=pane_hash(pane),
+            matched=matched,
+            source=SOURCE_EXIT,
+        )
+    return None
+
+
+def _under_a_turn(lines: "list[str]", index: int) -> bool:
+    """Whether `lines[index]` belongs to a worker's turn: a `●` row sits
+    above it, anywhere in the capture, with no submitted-prompt row
+    (`_USER_PROMPT_ROW_RE`, the `>` Claude Code draws for the prompt that
+    opens the NEXT turn) between them. Blank lines and chrome do NOT end
+    a turn (PR #141 review round 2): one assistant message is several
+    blank-separated paragraphs and code blocks, `●` on its first line
+    only, so the paragraph is no boundary -- only the next prompt row is.
+    A `⎿` row above is the turn's output and bounds nothing either."""
+    for above in range(index - 1, -1, -1):
+        raw = strip_ansi(lines[above])
+        if _USER_PROMPT_ROW_RE.match(raw):
+            return False
+        if _OUTPUT_ROW_RE.match(raw) and not _TOOL_OUTPUT_ROW_RE.match(raw):
+            return True
+    return False
+
+
 def classify(pane: str) -> "PromptFinding | None":
     """What this pane is parked on, or None for a pane that is WORKING, idle
     at the input prompt, empty, or unreadable.
@@ -455,6 +654,7 @@ def classify(pane: str) -> "PromptFinding | None":
         index, text = banner
         for kind, pattern in (
             (KIND_LOGIN_EXPIRED, _LOGIN_EXPIRED_RE),
+            (KIND_AUTH_REJECTED, _AUTH_REJECTED_RE),
             (KIND_USAGE_LIMIT, _USAGE_LIMIT_RE),
             (KIND_OUT_OF_CREDITS, _OUT_OF_CREDITS_RE),
         ):
@@ -466,6 +666,7 @@ def classify(pane: str) -> "PromptFinding | None":
                     options=(),
                     excerpt=_excerpt(lines, index),
                     pane_hash=digest,
+                    matched=_matched_for(kind, text),
                 )
 
     parked = _tail_is_dialog(lines)

alissa_tools_github_devloop-0.8.30/src/main/alissa/tools/github/devloop/version

@@ -0,0 +1 @@
+0.8.30

{alissa_tools_github_devloop-0.8.29 → alissa_tools_github_devloop-0.8.30/src/main/alissa_tools_github_devloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.29
+Version: 0.8.30
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_devloop-0.8.29/src/main/alissa/tools/github/devloop/version

@@ -1 +0,0 @@
-0.8.29