alissa-tools-github-revloop 0.31.5__tar.gz → 0.31.6__tar.gz

{alissa_tools_github_revloop-0.31.5/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.31.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.31.5
+Version: 0.31.6
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_revloop-0.31.5 → alissa_tools_github_revloop-0.31.6}/src/main/alissa/tools/github/revloop/alissa.py

@@ -467,6 +467,26 @@ def pane_path_argv(name: str) -> "list[str]":
     ]
 
 
+# What `#{pane_current_command}` reads on a reviewer pane whose `claude` has
+# EXITED (issue #146, devloop #140's set): the shell `alissa tmux new`
+# launched it from, back in the foreground. A live reviewer 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 --
@@ -1379,6 +1399,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 #146): a reviewer 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_revloop-0.31.5 → alissa_tools_github_revloop-0.31.6}/src/main/alissa/tools/github/revloop/loop.py

@@ -27,6 +27,7 @@ from typing import Callable
 from . import prompts as prompts_mod
 from .alissa import (
     MANAGED_PREFIX,
+    SHELL_COMMANDS,
     READINESS_AUTO,
     READINESS_MISSING,
     READINESS_OPERATOR,
@@ -91,7 +92,13 @@ from .fleet_vitals import (
     FleetVitalsPusher,
     build_pusher,
 )
-from .loop_events import LoopEventsEmitter, build_emitter
+from .loop_events import (
+    LoopEventsEmitter,
+    auth_rejected_kind,
+    auth_rejected_prefix,
+    build_emitter,
+    credential_identity,
+)
 from .proc import CommandError
 from .state import State
 
@@ -1330,7 +1337,11 @@ PROMPT_PAGE_COMMENT = (
     "not answering it, and it is HOLDING new reviewer spawns until the "
     "condition clears (live sessions keep running; the rounds they owe are "
     "not consumed). Operator options: `login_expired` → re-run the claude "
-    "login on the reviewer container; `usage_limit` → wait for the reset or "
+    "login on the reviewer container; `auth_rejected` → Claude refused the "
+    "reviewer'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 session is then killed and the stale-round "
@@ -1357,6 +1368,12 @@ ESCALATION_PROMPT_PAGE = "prompt-page"
 # slow container.
 PROMPT_SETTLE_SECONDS = 3.0
 
+# The first-turn death check's "never looked" marker (issue #146, devloop
+# #140's): 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 ping kind of ONE responder act: `prompt:<kind>:<verb>@<session>#<seq>`.
@@ -2141,6 +2158,26 @@ class ReviewWatcher:
         self._prompt_hold: "str | None" = None
         # What the responder found and did this pass, for the summary line.
         self._prompt_sweep = PromptSweep()
+        # The first-turn death check's memory (issue #146, devloop #140's
+        # `_exit_findings`): every reviewer session whose pane was found back
+        # in a shell inside its round's 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
+        # `auth-rejected:` row is once per session in the ledger, so a
+        # re-observation writes nothing and emits nothing new.
+        self._exit_findings: "dict[str, prompts_mod.PromptFinding | None]" = {}
+        # Where `auth.rejected` reads the credential's NAME and last four
+        # characters (`loop_events.credential_identity`): the process
+        # environment when None; injectable so a test never depends on --
+        # or leaks -- the seat's own token.
+        self.auth_environ: "dict[str, str] | None" = None
+        # Dry-run's once-per-session memory for the `auth-rejected:` row it
+        # would have written (the durable row is production's; the
+        # `_dry_run_drift` split).
+        self._dry_run_auth: "set[str]" = set()
         # The settle wait between pressing a dialog's keys and re-capturing
         # the pane; injectable so a test never sleeps.
         self._sleep: "Callable[[float], None]" = time.sleep
@@ -5742,6 +5779,18 @@ class ReviewWatcher:
         answered = 0
         for ses in sessions:
             live.add(ses.name)
+            # The first-turn death check (issue #146) 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(ses)
+            if exited is not None:
+                outcome = self._answer_prompt(ses, None, exited, mode)
+                waiting.append(outcome["waiting"])
+                answered += outcome["answered"]
+                if outcome["hold"] and hold is None:
+                    hold = outcome["hold"]
+                continue
             marker = self._waiting_marker(ses.tmux_name)
             quiet = ses.quiet_for
             if marker is None and (
@@ -5772,8 +5821,122 @@ class ReviewWatcher:
                 hold = outcome["hold"]
         self._sighting_prune(live)
         self._prune_prompt_pings(live)
+        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)
 
+    def _first_turn_death(
+        self, ses: ManagedSession
+    ) -> "prompts_mod.PromptFinding | None":
+        """The first-turn death check (issue #146; devloop #140's, on the
+        reviewer seat): an `auth_rejected` finding with `source: "exit"` for
+        a reviewer 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 session THIS ledger spawned (a spawn row names it -- the skill's
+        hand-driven `review-pr-<n>` rounds have none and no spawn time to
+        measure a window from) inside its round's first stale window
+        (STALE_ROUND_SECONDS), whose pane's current command is back in
+        `SHELL_COMMANDS` (one `display-message` per young session per pass).
+        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 -- and the expiry's kill ages the round's spawn
+        row, so the stale-round edge re-enters THE SAME ROUND (no verdict
+        was submitted, so `completed + 1` has not moved): an auth death
+        never burns a round number. No match is the ordinary "died, not
+        auth": remembered too (never re-read), and nothing new is emitted --
+        the stale-round respawn is the remedy it always was. An unreadable
+        pane (tmux answered nothing) is not remembered: the check runs again
+        next pass rather than filing a blank capture as "not auth"."""
+        name = ses.name
+        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 (devloop PR #141
+                # review round 1).
+                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
+        row = self.state.find_spawn_by_session(name)
+        if row is None:
+            return None
+        age = time.time() - int(row["spawned_at"])
+        if age >= STALE_ROUND_SECONDS:
+            return None
+        if self.alissa.pane_command(name) not in SHELL_COMMANDS:
+            return None
+        pane = self.alissa.capture_pane(name, prompts_mod.PANE_LINES)
+        if not pane.strip():
+            log.debug(
+                "first-turn death check: %s is a shell but its pane could not "
+                "be read — re-checked next pass", name,
+            )
+            return None
+        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 auth wording in its last lines — died, not "
+                "auth; the stale-round edge owns it", name, int(age),
+            )
+        return finding
+
+    def _record_auth_rejected(
+        self,
+        name: str,
+        anchor: "PromptAnchor | None",
+        finding: "prompts_mod.PromptFinding",
+    ) -> None:
+        """The `auth.rejected` row (issue #146): ONE `auth-rejected:` ping
+        per session, which the loop-events emitter derives the event from.
+        The row carries the vocabulary tokens, the round, the credential's
+        variable NAME and its last four characters -- read here, at
+        observation, so a later backfill still names the token that was
+        refused -- and never the signature or any other pane text. An
+        anchor-less session (no spawn row, a name that resolves to no single
+        watched repo) is recorded under ('', 0): the event still goes, with
+        no PR. Dry-run writes nothing and logs the row once per session."""
+        if self.state.ping_seen_since(auth_rejected_prefix(name), 0):
+            return
+        env_name, suffix = credential_identity(self.auth_environ)
+        if self.config.dry_run:
+            if name not in self._dry_run_auth:
+                self._dry_run_auth.add(name)
+                log.info(
+                    "[dry-run] would record auth.rejected for %s (source %s, "
+                    "matched %s, envName %s)",
+                    name, finding.source, finding.matched, env_name,
+                )
+            return
+        self.state.record_ping(
+            anchor.repo if anchor is not None else "",
+            anchor.number if anchor is not None else 0,
+            auth_rejected_kind(
+                name, anchor.round if anchor is not None else None,
+                finding.source, finding.matched, env_name, suffix,
+            ),
+        )
+        log.warning(
+            "auth.rejected: claude refused the credential of reviewer session "
+            "%s (source %s, matched %s, envName %s) — the loop event names the "
+            "token's last four characters; spawns are held",
+            name, finding.source, finding.matched, env_name,
+        )
+
     def _answer_prompt(
         self,
         ses: ManagedSession,
@@ -5899,10 +6062,16 @@ class ReviewWatcher:
                 tail = " · killed; the stale-round edge re-enters the same round next poll"
             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, anchor.round,
                 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}",
                 anchor.cap,
             )
@@ -5920,6 +6089,12 @@ class ReviewWatcher:
                 "spawn row, and the name resolves to no single watched repo) — "
                 "%s → %s recorded in the log only", name, finding.kind, action.verb,
             )
+        # The `auth.rejected` record (issue #146): the two AUTH_KINDS are the
+        # same signal. 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.
+        if finding.kind in prompts_mod.AUTH_KINDS and live_mode:
+            self._record_auth_rejected(name, anchor, finding)
         return {
             "waiting": {
                 "session": name, "kind": finding.kind,

{alissa_tools_github_revloop-0.31.5 → alissa_tools_github_revloop-0.31.6}/src/main/alissa/tools/github/revloop/loop_events.py

@@ -46,13 +46,36 @@ Design rules, all load-bearing:
   between passes) is simply not observed; a row enriched from another table
   (`stability_notices` onto a `stability:` ping) reads whatever that table
   says NOW, which is also what the guard itself decides from.
+
+One event is not a table read but a ROW the watcher writes for it, and it is
+still ledger-derived: ``auth.rejected`` (issue #146; devloop #140's event,
+Studio design `managed-dark-factory-claude-auth.md` §2.6, lane L5) — a
+reviewer session REFUSED by Claude. 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. The watcher records ONE `auth-rejected:` ping per session
+(`auth_rejected_kind`), and the event is derived from it, keyed on the
+session name, so one session emits at most one whatever the pass count or a
+restart's backfill. ``data: { status: 401, source: "pane" | "exit", matched,
+envName, tokenSuffix }`` — devloop's shape exactly. `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 (`null` beside a `null`
+envName), computed in-process by `credential_identity` AT OBSERVATION and
+folded into the row -- never re-read at derivation, so a backfill after the
+operator replaced the token still carries the suffix of the token that was
+refused. 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.
 """
 
 from __future__ import annotations
 
 import logging
+import os
 import re
-from typing import Any
+from typing import Any, Mapping
 
 from .alissa_client import (
     AlissaAuthError,
@@ -90,6 +113,89 @@ _PROMPT_PAGE_RE = re.compile(
 )
 
 
+# The `auth.rejected` row (issue #146): one per SESSION,
+# `auth-rejected:<session>#<round>:<source>:<matched>:<envName>:<suffix>`.
+# The session leads so "already recorded for this session" is one prefix read
+# (`auth_rejected_prefix`); the suffix trails because it is the one field
+# whose characters this module does not choose. `round`, `envName` and the
+# suffix are empty when unknown / unset.
+AUTH_REJECTED_PREFIX = "auth-rejected:"
+_AUTH_REJECTED_RE = re.compile(
+    r"^auth-rejected:(?P<session>[^#:@]+)#(?P<round>\d*):(?P<source>pane|exit):"
+    r"(?P<matched>[a-z0-9_]+):(?P<env>[A-Z_]*):(?P<suffix>.{0,4})$"
+)
+
+# 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 `credential_identity` whole. devloop's constants.
+AUTH_ENV_NAMES = ("ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN")
+TOKEN_SUFFIX_CHARS = 4
+AUTH_STATUS = 401
+AUTH_SOURCES = ("pane", "exit")
+AUTH_MATCHED_DEFAULT = "api_error_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 reviewer'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
+    reviewers are spawned on this same container by `alissa tmux`, so the
+    daemon's environment IS theirs. devloop's function, verbatim in
+    behaviour: a blank value reads as unset, a value shorter than four
+    characters yields what there is."""
+    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_prefix(session: str) -> str:
+    """The prefix every `auth-rejected:` row of ONE session starts with --
+    the watcher's "already recorded" read (`State.ping_seen_since`)."""
+    return f"{AUTH_REJECTED_PREFIX}{session}#"
+
+
+def auth_rejected_kind(
+    session: str,
+    round_: "int | None",
+    source: str,
+    matched: "str | None",
+    env_name: "str | None",
+    suffix: "str | None",
+) -> str:
+    """The ledger kind of ONE refusal (see AUTH_REJECTED_PREFIX). `source`
+    outside AUTH_SOURCES reads as `pane`, a missing `matched` as the bare
+    401 -- the event's vocabulary is closed, and the row is its source."""
+    return (
+        f"{auth_rejected_prefix(session)}{'' if round_ is None else int(round_)}:"
+        f"{source if source in AUTH_SOURCES else 'pane'}:"
+        f"{matched or AUTH_MATCHED_DEFAULT}:{env_name or ''}:"
+        f"{(suffix or '')[-TOKEN_SUFFIX_CHARS:]}"
+    )
+
+
+def auth_rejected_key(session: str) -> str:
+    """One `auth.rejected` per SESSION (issue #146, devloop's key shape):
+    reviewer names are nonce-unique per spawn 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 _ms(seconds: "int | float") -> int:
     """A ledger stamp (epoch seconds) as the API's epoch-ms `at`."""
     return int(seconds) * 1000
@@ -253,7 +359,8 @@ def _capped_events(
 def _ping_events(
     rows: "list[dict]", notices: "dict[tuple[str, int], dict]"
 ) -> "list[tuple[int, dict]]":
-    """`stalled`, `stability.hold` and `checks.held` out of the ping ledger.
+    """`stalled`, `stability.hold`, `checks.held`, the prompt responder's
+    two families and `auth.rejected` out of the ping ledger.
 
     `kind` is free-form text carrying the episode identity, so it is parsed
     by prefix; kinds this module does not report (`activity-deferred:`,
@@ -336,6 +443,36 @@ def _ping_events(
                     "session": match.group("session"), "ledgerKind": kind,
                 },
             ))
+        elif kind.startswith(AUTH_REJECTED_PREFIX):
+            match = _AUTH_REJECTED_RE.match(kind)
+            if match is None:
+                continue
+            session = match.group("session")
+            source = match.group("source")
+            round_str = match.group("round")
+            out.append(_event(
+                "auth.rejected",
+                at,
+                auth_rejected_key(session),
+                repo=repo or None,
+                # An anchor-less refusal (the session resolved to no watched
+                # PR) is recorded under ('', 0): the event still goes, with
+                # no repo and no PR rather than a made-up one.
+                pr=number if number > 0 else None,
+                round_=int(round_str) if round_str else None,
+                session=session,
+                reason=AUTH_REASONS[source],
+                data={
+                    "status": AUTH_STATUS,
+                    "source": source,
+                    "matched": match.group("matched"),
+                    "envName": match.group("env") or None,
+                    "tokenSuffix": (
+                        match.group("suffix") or None
+                        if match.group("env") else None
+                    ),
+                },
+            ))
         elif kind.startswith(PROMPT_PREFIX):
             match = _PROMPT_RE.match(kind)
             if match is None:

{alissa_tools_github_revloop-0.31.5 → alissa_tools_github_revloop-0.31.6}/src/main/alissa/tools/github/revloop/prompts.py

@@ -66,6 +66,12 @@ KIND_PERMISSION = "permission"
 KIND_TRUST = "trust"
 KIND_RESUME_PICKER = "resume_picker"
 KIND_LOGIN_EXPIRED = "login_expired"
+# A 401 from the API on a reviewer's turn (issue #146, devloop #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"
@@ -76,6 +82,7 @@ KINDS = (
     KIND_TRUST,
     KIND_RESUME_PICKER,
     KIND_LOGIN_EXPIRED,
+    KIND_AUTH_REJECTED,
     KIND_USAGE_LIMIT,
     KIND_OUT_OF_CREDITS,
     KIND_UNKNOWN_DIALOG,
@@ -84,7 +91,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 #146, devloop #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 ----------------------------------------------------------------
 
@@ -138,6 +176,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 #146, devloop #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 reviewer'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
@@ -177,6 +225,34 @@ _LOGIN_EXPIRED_RE = re.compile(
     r"(?:Your )?(?:session|login|token) (?:has )?expired\b)",
     re.IGNORECASE,
 )
+# The 401 wordings Anthropic documents (issue #146, devloop #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 reviewer'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|"
@@ -194,6 +270,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 reviewer turn and the next, which is what releases the lines below
+# it from the `●` above (issue #146; devloop #140, its 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'\"]+$")
@@ -289,14 +370,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 #146, devloop #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
@@ -306,12 +404,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
@@ -339,7 +441,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 #146, devloop #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
@@ -347,6 +454,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":
@@ -441,6 +550,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 #146, devloop #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 its round's spawn), 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 reviewer'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 reviewer'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 reviewer'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 (devloop 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.
@@ -471,6 +670,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),
         ):
@@ -482,6 +682,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_revloop-0.31.6/src/main/alissa/tools/github/revloop/version

@@ -0,0 +1 @@
+0.31.6

{alissa_tools_github_revloop-0.31.5 → alissa_tools_github_revloop-0.31.6/src/main/alissa_tools_github_revloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.31.5
+Version: 0.31.6
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_revloop-0.31.5/src/main/alissa/tools/github/revloop/version

@@ -1 +0,0 @@
-0.31.5