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

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

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

@@ -516,6 +516,44 @@ from .state import State
 
 log = logging.getLogger(__name__)
 
+# The criteria-typing rule (issue #194). orcloop ticks only `evidence`
+# criteria when a PR merges, and the soft validator answers "needs a human"
+# for every `human` one -- so a worker that types a FACT ("PR ready for
+# review", "screenshots committed") as `human` parks its task at
+# pending_validation forever (TASK-183426950, PR #2652: 103 fleet tasks piled
+# up and the backlog brake paused every release). The worker picks the type,
+# so the directive must say how: by who can close the criterion. The
+# operator-gate list stays out of the criteria because orcloop already
+# harvests it from the PR body into the origin task's "Needs a look"
+# checklist; copied in, it would turn every unverifiable item into a human
+# criterion again. The legacy type words are deliberately never written here
+# (a test pins their absence from every directive): naming them, even to
+# forbid them, is how they get copied.
+_CRITERIA_RULE = (
+    "Type every validation criterion on your implementation task by WHO CAN "
+    "CLOSE IT, writing the type as exactly one of `evidence`, `check` or "
+    "`human`: `evidence` is the default — it closes from what the PR, the "
+    "delivery note, a merged commit, a test run or a committed file shows "
+    "(orcloop ticks these on merge); `check`, with a `source`, when "
+    "a machine signal names it (`ci:<owner>/<repo>[#<check>]` for \"CI "
+    "green\"); `human` ONLY for a person's judgment (taste, a live phone "
+    "check, a pilot user, a decision) — and then say so in the criterion's "
+    "text. Facts are never `human`: \"PR ready / review requested / approved "
+    "/ merged\", \"tests X pass\", \"screenshots at <path> committed\", "
+    "\"doc section added\", \"delivery note registered\" are all "
+    "`evidence`. Never copy the PR body's \"Not verified — operator's gate\" "
+    "list into task criteria: orcloop harvests it into a \"Needs a look\" "
+    "checklist on the origin task by itself."
+)
+
+# The adopt half: a resumed or fix-round session inherits a task some other
+# session typed, possibly before this rule existed.
+_CRITERIA_ADOPT = (
+    " On a task you ADOPT, retype any criterion that breaks this rule (a fact "
+    "typed `human` becomes `evidence`), and type any criterion you add the "
+    "same way."
+)
+
 # The origin-task instruction is split in two because the downstream rule is
 # the same either way -- only the starting point differs: a present ref is
 # authoritative; an absent one (spawn_anyway / warn_and_spawn) makes locating
@@ -525,6 +563,8 @@ _TASK_WITH_ORIGIN = (
     "implementation task DOWNSTREAM of it (create_downstream_task), and keep "
     "its status honest: in_progress while you work, pending_validation at "
     "handoff."
+    + " "
+    + _CRITERIA_RULE
 )
 
 _TASK_WITHOUT_ORIGIN = (
@@ -532,6 +572,8 @@ _TASK_WITHOUT_ORIGIN = (
     "behind this issue, or create one, then create your implementation task "
     "DOWNSTREAM of it before writing code, and keep its status honest: "
     "in_progress while you work, pending_validation at handoff."
+    + " "
+    + _CRITERIA_RULE
 )
 
 # The resume counterparts. A resumed attempt inherits a PR the dead session
@@ -547,6 +589,9 @@ _RESUME_TASK_WITH_ORIGIN = (
     "in_progress while you work, pending_validation at handoff. Only if the "
     "PR body names none, create your implementation task DOWNSTREAM of the "
     "origin (create_downstream_task) before writing code."
+    + " "
+    + _CRITERIA_RULE
+    + _CRITERIA_ADOPT
 )
 
 _RESUME_TASK_WITHOUT_ORIGIN = (
@@ -555,6 +600,9 @@ _RESUME_TASK_WITHOUT_ORIGIN = (
     "in_progress while you work, pending_validation at handoff); otherwise "
     "locate the origin task behind this issue, or create one, and create "
     "your implementation task DOWNSTREAM of it before writing code."
+    + " "
+    + _CRITERIA_RULE
+    + _CRITERIA_ADOPT
 )
 
 # The delivery note (issue #63). A worker's highest-value output is not the
@@ -1514,6 +1562,9 @@ FIX_DIRECTIVE = (
     "keep its status honest — in_progress while you work, pending_validation "
     "at handoff. If a ref is missing from the PR body, restoring both is part "
     "of your job: the PR body is the canonical cross-actor record. "
+    + _CRITERIA_RULE
+    + _CRITERIA_ADOPT
+    + " "
     "Golden path: your cwd is the repo's worktree hub ROOT and the PR's head "
     "branch `{head_ref}` already exists — re-attach its worktree with `git "
     "worktree add {worktree_dir} {head_ref}` if it is missing (the directory "
@@ -1567,6 +1618,9 @@ FIX_RESUME_DIRECTIVE = (
     "in_progress while you work, pending_validation at handoff. If a ref is "
     "missing from the PR body, restoring both is part of your job: the PR "
     "body is the canonical cross-actor record. "
+    + _CRITERIA_RULE
+    + _CRITERIA_ADOPT
+    + " "
     "FIRST hydrate the context you did not live through: read the PR (body, "
     "commits, and every review thread) and the issue behind it, to see how "
     "far the dead session got. Golden path: your cwd is the repo's worktree "
@@ -1835,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
@@ -2199,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
@@ -4778,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
@@ -10123,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.57 → 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.57 → 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.57 → 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.57
+Version: 0.8.59
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.8.57