alissa-tools-github-devloop 0.8.58__tar.gz → 0.8.59__tar.gz

{alissa_tools_github_devloop-0.8.58/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.8.59}/PKG-INFO

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

{alissa_tools_github_devloop-0.8.58 → alissa_tools_github_devloop-0.8.59}/src/main/alissa/tools/github/devloop/loop.py

@@ -1889,6 +1889,16 @@ LIVE_STALLED_COMMENT = (
     "`{classified}`."
 )
 
+ASSIGNED_OUTSIDE_COMMENT = (
+    "**Dev loop skipping this issue** — it has been assigned to `{login}` for "
+    "at least {minutes} min, but this daemon has no spawn for it on its "
+    "ledger and no spawn line of its own on the activity comment, so the "
+    "assignment was made outside the loop (by hand, or under another "
+    "workspace's ledger). The daemon will not spawn over it. Operator "
+    "options: unassign `{login}` to let the loop take the issue, or leave it "
+    "if someone is working it by hand. (One-time notice.)"
+)
+
 # The operator page for an account-level prompt kind (issue #127): an
 # expired login, a hit usage limit, an empty credit balance. No keystroke
 # answers these, so the page is the act -- one per kind per
@@ -2253,6 +2263,16 @@ ESCALATION_FIX_HANDOVER = "fix-handover"
 # neither ping may silence the other.
 ESCALATION_LIVE_STALLED = "live-stalled"
 
+# The assigned-outside skip's once-per-issue operator page (issue #200): the
+# issue is assigned to this login, the ledger has no row and its activity
+# comment no spawn line of ours, so nothing the daemon can see explains the
+# assignment. Once-ever like ESCALATION_ASSIGNMENT -- the remedy (unassign,
+# or leave it to whoever is working it by hand) does not change per poll.
+# ASSIGNED_OUTSIDE_SEEN is the episode's durable first-seen clock, kept in the
+# activity_log ledger so a daemon restart does not restart the wait.
+ESCALATION_ASSIGNED_OUTSIDE = "assigned-outside"
+ASSIGNED_OUTSIDE_SEEN = "assigned-outside-seen"
+
 # The wedge kill's once-per-episode marker (see wedge_kind). Not an operator
 # page -- the daemon acted instead of asking -- but, like ESCALATION_REREQUEST,
 # a once-per-key act the `escalations` table is the ledger of: it dedupes the
@@ -4832,14 +4852,21 @@ class DevWatcher:
             return self._claim_deferral(claim, attempts)
 
         if login in issue.assignees and age is None:
-            # Self-assigned but the ledger never spawned: assigned outside this
-            # daemon (by hand, or under another workspace's ledger). Not a
-            # fresh self-spawn, so not ours to double-book.
-            return Decision(
-                Action.SKIPPED,
-                f"assigned to {login} outside this daemon (no spawn on the "
-                f"ledger) — unassign the issue to let the loop take it",
-            )
+            # Self-assigned but the ledger never spawned. Issue #200: when the
+            # issue's own activity comment carries an EXPIRED spawn line by
+            # this login on this lane (the claim above already let it age
+            # out), the assignment is a dead attempt of ours whose ledger row
+            # was lost (an overlapping deploy wrote it) -- adopt it into the
+            # ledger and let the ordinary stale matrix below decide, exactly
+            # as if the row had been there all along.
+            orphans = self._orphaned_spawns(issue, session_name(issue, 1))
+            if orphans:
+                attempts, age = self._adopt_orphaned_spawns(issue, orphans)
+            else:
+                # No spawn line at all: assigned outside this daemon (by
+                # hand, or under another workspace's ledger). Not ours to
+                # double-book -- but not silent forever either.
+                return self._assigned_outside(issue, login)
 
         # Staleness needs THREE signals, not one: the ledger timer says the
         # newest spawn is old, but elapsed time alone cannot tell a dead
@@ -10177,6 +10204,148 @@ class DevWatcher:
             defer_token=loop_events_mod.DEFER_CLAIM,
         )
 
+    def _orphaned_spawns(
+        self, issue: Issue, session: str
+    ) -> "list[ActivityClaim]":
+        """The EXPIRED spawn lines this login wrote on the issue's activity
+        comment for `session`'s lane, oldest first and one per session name
+        (issue #200). Called only when the issue is self-assigned and the
+        ledger has no row for it, i.e. after `external_claim` has already
+        turned down every line as not fresh: what is left is a dead attempt
+        of ours whose ledger row was lost (written by an overlapping
+        deployment, or before a ledger loss).
+
+        Own authorship comes from `marked_comment`, the lane from
+        `activity_lane`. Same switch and fail-open rule as `external_claim`:
+        with claims disabled, or on any read failure, the answer is "no
+        lines", which keeps today's skip."""
+        if not self.config.activity_claims_enabled:
+            return []
+        try:
+            comment = self.github.marked_comment(
+                issue.owner, issue.repo, issue.number, ACTIVITY_MARKER
+            )
+        except Exception as exc:
+            log.warning(
+                "could not read the activity comment on %s (%s) — no "
+                "orphaned attempt to adopt this poll",
+                issue.issue_slug,
+                exc,
+            )
+            return []
+        if comment is None:
+            return []
+        lane = activity_lane(session)
+        window = self.config.stale_minutes * 60
+        oldest: "dict[str, ActivityClaim]" = {}
+        for claim in activity_claims(comment.body):
+            if activity_lane(claim.session) != lane or claim.age < window:
+                continue
+            known = oldest.get(claim.session)
+            if known is None or claim.at < known.at:
+                oldest[claim.session] = claim
+        return sorted(oldest.values(), key=lambda claim: claim.at)
+
+    def _adopt_orphaned_spawns(
+        self, issue: Issue, orphans: "list[ActivityClaim]"
+    ) -> "tuple[int, float]":
+        """Record each orphaned spawn line as a ledger row stamped with the
+        line's own time, so attempt_cap counts it and the ordinary stale
+        matrix (linked-PR probe, tmux liveness, resume) judges it exactly as
+        a row that was never lost. Returns the (attempts, age) the caller
+        continues with.
+
+        Rows are numbered 1..k in line order (the ledger has none for this
+        issue), keeping the session name the line carries; numbering by the
+        name's own suffix could REPLACE a row when a line is missing. Not
+        written on a dry run (no ledger write is), but the returned values
+        let the dry pass reach the same decision."""
+        for attempt, orphan in enumerate(orphans, start=1):
+            log.warning(
+                "%s: adopted orphaned attempt %d from activity log (`%s`, "
+                "spawned %d min ago by this login, no local ledger row) — "
+                "taking the stale path",
+                issue.issue_slug,
+                attempt,
+                orphan.session,
+                int(orphan.age / 60),
+            )
+            if self.config.dry_run:
+                continue
+            self.state.record_spawn(
+                repo_slug=issue.full_name,
+                issue=issue.number,
+                attempt=attempt,
+                session=orphan.session,
+            )
+            # The row just written is the newest; move its clock back to the
+            # line's, so its age says what the line says.
+            self.state.age_out_spawn(issue.full_name, issue.number, orphan.at)
+        return len(orphans), orphans[-1].age
+
+    def _assigned_outside(self, issue: Issue, login: str) -> Decision:
+        """The skip for an issue assigned to this login with nothing on the
+        ledger or the activity comment to explain it -- assigned by hand.
+        Not silent forever (issue #200): once the skip has persisted for
+        STALLED_DEFER_MULTIPLE stale windows (clock: the episode's durable
+        first-seen row) it posts ONE operator comment, recorded only after
+        it lands so a failed post retries next poll."""
+        full_name, number = issue.full_name, issue.number
+        reason = (
+            f"assigned to {login} outside this daemon (no spawn on the "
+            f"ledger) — unassign the issue to let the loop take it"
+        )
+        if self.state.escalated(full_name, number, ESCALATION_ASSIGNED_OUTSIDE):
+            return Decision(Action.SKIPPED, reason)
+        if self.config.dry_run:
+            return Decision(Action.SKIPPED, reason)
+        first_seen = self.state.activity_logged_at(
+            full_name, number, ASSIGNED_OUTSIDE_SEEN
+        )
+        if first_seen is None:
+            self.state.record_activity(full_name, number, ASSIGNED_OUTSIDE_SEEN)
+            first_seen = int(time.time())
+        stalled_after = STALLED_DEFER_MULTIPLE * self.config.stale_minutes * 60
+        waited = time.time() - first_seen
+        if waited < stalled_after:
+            # The page's clock is the seat's: no parking across it, or it
+            # would fire on the first pass after the wake (issue #153).
+            return Decision(
+                Action.SKIPPED,
+                reason,
+                owed=True,
+                timer=(
+                    parking_mod.TIMER_STALE_WINDOW, first_seen + stalled_after
+                ),
+            )
+        body = ASSIGNED_OUTSIDE_COMMENT.format(
+            login=login, minutes=int(waited / 60)
+        )
+        log.warning(
+            "%s has been assigned to %s outside this daemon for %.0f min — "
+            "escalating to operator (once)",
+            issue.issue_slug,
+            login,
+            waited / 60,
+        )
+        try:
+            self.github.comment(issue.owner, issue.repo, number, body)
+        except CommandError as exc:
+            log.error(
+                "could not post the assigned-outside comment on %s: %s — "
+                "the page retries next poll",
+                issue.issue_slug,
+                exc,
+            )
+            return Decision(Action.SKIPPED, reason, owed=True)
+        self.state.record_escalation(
+            full_name, number, ESCALATION_ASSIGNED_OUTSIDE
+        )
+        return Decision(
+            Action.ESCALATED,
+            f"{reason}; operator paged after {int(waited / 60)} min",
+        )
+
     def _log_deferral(
         self,
         owner: str,

{alissa_tools_github_devloop-0.8.58 → alissa_tools_github_devloop-0.8.59}/src/main/alissa/tools/github/devloop/loop_events.py

@@ -189,7 +189,7 @@ _LIMIT_LIFTED_RE = re.compile(r"^usage-limit-lifted:(?P<session>[^@]+)@(?P<since
 # points the operator at an unrelated PR or at nothing.
 _ISSUE_ANCHORED = (
     "cap", "assignment", "stalled", "live-stalled", "wedged", "first-run-dialog",
-    "claude-exited",
+    "claude-exited", "assigned-outside",
 )
 
 

{alissa_tools_github_devloop-0.8.58 → alissa_tools_github_devloop-0.8.59}/src/main/alissa/tools/github/devloop/state.py

@@ -1245,6 +1245,23 @@ class State:
         ).fetchone()
         return row is not None
 
+    def activity_logged_at(
+        self, repo_slug: str, number: int, kind: str
+    ) -> "int | None":
+        """When this activity KIND was first recorded (unix seconds), or None.
+        The durable first-seen clock of an episode that must outlive a daemon
+        restart (issue #200: the assigned-outside skip escalates once it has
+        persisted long enough). A row held in memory by a failed write answers
+        with the timestamp it would have carried."""
+        pending = self._pending_gates.get(("activity_log", repo_slug, number, kind))
+        if pending is not None:
+            return int(pending)
+        row = self._db.execute(
+            "SELECT logged_at FROM activity_log WHERE repo_slug=? AND number=? AND kind=?",
+            (repo_slug, number, kind),
+        ).fetchone()
+        return None if row is None else int(row["logged_at"])
+
     def record_activity(self, repo_slug: str, number: int, kind: str) -> None:
         """Idempotent per kind: OR IGNORE keeps the first line's timestamp.
         Recorded by the caller only AFTER the append lands, so a transient

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

@@ -0,0 +1 @@
+0.8.59

{alissa_tools_github_devloop-0.8.58 → alissa_tools_github_devloop-0.8.59/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.58
+Version: 0.8.59
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.8.58