alissa-tools-github-devloop 0.5.1__tar.gz → 0.6.1__tar.gz

{alissa_tools_github_devloop-0.5.1/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.6.1}/PKG-INFO

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

{alissa_tools_github_devloop-0.5.1 → alissa_tools_github_devloop-0.6.1}/src/main/alissa/tools/github/devloop/__main__.py

@@ -147,6 +147,42 @@ def build_parser() -> argparse.ArgumentParser:
         "sessions, even if the config enables it",
     )
 
+    resume = over.add_mutually_exclusive_group()
+    resume.add_argument(
+        "--resume",
+        dest="resume_enabled",
+        action="store_true",
+        default=None,
+        help="auto-resume a stale attempt whose session is provably dead "
+        "(absent from a successful `alissa tmux ls`) while its PR stays open, "
+        "instead of deferring behind an operator ping (the default)",
+    )
+    resume.add_argument(
+        "--no-resume",
+        dest="resume_enabled",
+        action="store_false",
+        help="legacy two-signal staleness: never read session liveness, "
+        "never auto-resume — a dead-with-PR lane waits for an operator",
+    )
+
+    claims = over.add_mutually_exclusive_group()
+    claims.add_argument(
+        "--activity-claims",
+        dest="activity_claims_enabled",
+        action="store_true",
+        default=None,
+        help="read the trigger artifact's activity comment for another "
+        "instance's fresh spawn line and defer on it, so spawn dedupe "
+        "survives a ledger the local instance never wrote (the default)",
+    )
+    claims.add_argument(
+        "--no-activity-claims",
+        dest="activity_claims_enabled",
+        action="store_false",
+        help="ledger-only spawn dedupe: never read external claim evidence "
+        "(two overlapping instances can then both spawn on one item)",
+    )
+
     dry = over.add_mutually_exclusive_group()
     dry.add_argument(
         "--dry-run",
@@ -184,6 +220,8 @@ def overrides_from(args: argparse.Namespace) -> dict:
         "fix_rounds_enabled": args.fix_rounds_enabled,
         "maintain_label": args.maintain_label,
         "maintain_enabled": args.maintain_enabled,
+        "resume_enabled": args.resume_enabled,
+        "activity_claims_enabled": args.activity_claims_enabled,
         "dry_run": args.dry_run,
     }
 
@@ -215,12 +253,15 @@ def log_effective_config(config: Config, login: str) -> None:
     log.info("reviewers: %s", ", ".join(config.reviewers) or "none")
     log.info(
         "poll every %ss; dry_run=%s; attempt_cap=%s; stale after %s min; "
-        "max_sessions=%s; fix_rounds=%s; maintain=%s (label %r)",
+        "max_sessions=%s; fix_rounds=%s; maintain=%s (label %r); resume=%s; "
+        "activity_claims=%s",
         config.poll_interval, config.dry_run, config.attempt_cap,
         config.stale_minutes,
         config.max_sessions or "unlimited",
         config.fix_rounds_enabled,
         config.maintain_enabled, config.maintain_label,
+        config.resume_enabled,
+        config.activity_claims_enabled,
     )
     log.debug("hub_template: %s", config.hub_template)
     log.debug("agent_profile: %s", config.agent_profile)

{alissa_tools_github_devloop-0.5.1 → alissa_tools_github_devloop-0.6.1}/src/main/alissa/tools/github/devloop/config.py

@@ -62,6 +62,8 @@ CONFIG_KEYS = (
     "fix_rounds_enabled",
     "maintain_label",
     "maintain_enabled",
+    "resume_enabled",
+    "activity_claims_enabled",
     "dry_run",
 )
 
@@ -161,6 +163,38 @@ class Config:
     maintain_label: str = "alissa:maintain"
     maintain_enabled: bool = True
 
+    # The third staleness signal (session liveness, read from the reaper's own
+    # tmux listing) and the auto-resume it unlocks: a stale attempt whose
+    # ledger session is provably gone is respawned with RESUME_DIRECTIVE /
+    # FIX_RESUME_DIRECTIVE instead of parking the lane behind an operator
+    # ping. Provably gone is necessary, not sufficient: a healthy handoff ends
+    # in `alissa tmux kill` too, so on the ISSUE edge the resume additionally
+    # requires the linked PR to show the handoff never happened AND to be this
+    # issue's own work -- exactly one linked open PR, still a DRAFT, no
+    # reviewer requested, authored by the token identity, daemon-shaped head
+    # ref, and a body that CLOSES this issue (a cross-reference is raised by
+    # any mention, so a sibling task's PR would otherwise qualify). Default ON
+    # -- it closes the loop's one
+    # deliberate self-healing gap, and every side effect still honors dry_run.
+    # false restores the legacy two-signal matrix WHOLESALE on both edges (the
+    # floored defer, no liveness lookup, no resume): the escape hatch for an
+    # operator who wants a dead-with-PR lane to wait for a human.
+    resume_enabled: bool = True
+
+    # Cross-instance spawn dedupe (issue #53): before spawning on any edge,
+    # read the trigger artifact's mechanical activity comment and treat a
+    # spawn line younger than stale_minutes as an in-flight claim EVEN when
+    # the local ledger has no row. The ledger is instance-local and its volume
+    # follows the active deployment, so during a deploy overlap or a
+    # crashloop two daemons run with one GitHub identity and two ledgers and
+    # both spawn; the activity comment is the one claim record either can
+    # read. Default ON -- it closes a thrice-observed duplicate-PR incident,
+    # it can only ever DEFER a spawn, and a claim expires with the same
+    # stale_minutes window a ledger row does. false restores the
+    # ledger-only dedupe: the escape hatch for a single-instance deployment
+    # that would rather not pay the extra comments fetch.
+    activity_claims_enabled: bool = True
+
     dry_run: bool = False
 
     # Derived at build time: `repos` casefolded for matching. GitHub names are
@@ -316,6 +350,12 @@ class Config:
             maintain_enabled=bool(
                 raw.get("maintain_enabled", cls.maintain_enabled)
             ),
+            resume_enabled=bool(
+                raw.get("resume_enabled", cls.resume_enabled)
+            ),
+            activity_claims_enabled=bool(
+                raw.get("activity_claims_enabled", cls.activity_claims_enabled)
+            ),
             dry_run=bool(raw.get("dry_run", cls.dry_run)),
         )
 

{alissa_tools_github_devloop-0.5.1 → alissa_tools_github_devloop-0.6.1}/src/main/alissa/tools/github/devloop/ghclient.py

@@ -107,6 +107,13 @@ class PullRequest:
     head_sha: str
     draft: bool
     url: str
+    # The PR description. Carried for PROVENANCE: a cross-reference proves
+    # only that a PR mentioned an issue, while a closing keyword ("Closes
+    # #<n>") is the author's claim that this PR is the issue's work -- the
+    # one the developer directives mandate, and the only thing that tells
+    # THIS issue's PR from a sibling task's PR that merely said "related to
+    # #<n>". Empty when the PR has no body.
+    body: str
     # Logins/slugs whose review is CURRENTLY requested (users and teams
     # merged): non-empty means the ball is in a reviewer's court, so the
     # review-response edge is closed. GitHub clears an entry when that
@@ -536,9 +543,11 @@ class GitHub:
         return newest
 
     def pull_request(self, owner: str, repo: str, number: int) -> PullRequest:
-        """The evaluate_pr() re-fetch: draft state, head, author, and the
-        pending review requests -- the consistency guard over search
-        staleness, like issue() is for the issue edge."""
+        """The evaluate_pr() re-fetch: draft state, head, author, body, and
+        the pending review requests -- the consistency guard over search
+        staleness, like issue() is for the issue edge. (The body is what the
+        issue edge's resume probe reads for provenance; it rides along on the
+        same GET rather than costing a call of its own.)"""
         data = self._api(f"repos/{owner}/{repo}/pulls/{number}") or {}
         head = data.get("head") or {}
         # Users carry `login`, teams `slug`; both hold the edge closed -- a
@@ -564,6 +573,8 @@ class GitHub:
             head_sha=head.get("sha") or "",
             draft=bool(data.get("draft")),
             url=data.get("html_url", ""),
+            # `or ""`: GitHub sends null for an empty description.
+            body=data.get("body") or "",
             requested_reviewers=requested,
         )
 
@@ -619,7 +630,14 @@ class GitHub:
             ),
         )
 
-    def linked_open_prs(self, owner: str, repo: str, number: int) -> list[str]:
+    def linked_open_prs(
+        self,
+        owner: str,
+        repo: str,
+        number: int,
+        *,
+        exhaustive: bool = False,
+    ) -> list[str]:
         """URLs of OPEN same-repo pull requests linked to the issue -- the
         external liveness signal behind the stale-retry decision.
 
@@ -647,10 +665,9 @@ class GitHub:
         comments, labeled/assigned/mentioned events, bot noise -- ahead of
         the cross-reference, so a long pre-label discussion can push it past
         the first page, and a first-page-only probe would mis-read live work
-        as dead (and respawn over it). The walk is bounded: it stops as soon
-        as a page has yielded any open same-repo PR (every caller's question
-        is effectively boolean -- further pages could only lengthen a
-        comment's URL list), it stops at the
+        as dead (and respawn over it). The walk is bounded: by default it
+        stops as soon as a page has yielded any open same-repo PR (see
+        `exhaustive` below), it stops at the
         first short page (the timeline is exhausted) and hard-caps at
         TIMELINE_MAX_PAGES pages (TIMELINE_MAX_PAGES * TIMELINE_PAGE_SIZE
         events) -- a cross-reference past that ceiling is invisible to the
@@ -660,6 +677,21 @@ class GitHub:
         explicit `page=` loop is the safe shape for this client. Malformed
         events are skipped, never fatal -- one odd timeline entry must not
         wedge the staleness decision.
+
+        `exhaustive` picks WHICH question the walk answers. Default False is
+        the boolean one -- is ANY open same-repo PR linked? -- and stops at
+        the first page that yields a URL, because for that question later
+        pages can only lengthen a log message. True keeps walking to the
+        short page (or the TIMELINE_MAX_PAGES ceiling) and returns the
+        COMPLETE set within it: the issue edge's resume probe does not ask
+        whether a PR is linked but WHICH one, and it deliberately refuses to
+        act on more than one candidate -- against a truncated list that
+        refusal is unreachable, because "exactly one survivor" can just mean
+        the second was on the next page, and the daemon would push to the one
+        it happened to page in. The ceiling applies to both modes: a
+        cross-reference past TIMELINE_MAX_PAGES * TIMELINE_PAGE_SIZE events
+        is invisible either way, so `exhaustive` means complete UP TO the
+        documented ceiling, not unbounded.
         """
         same_repo_pull = f"https://github.com/{owner}/{repo}/pull/"
         urls: list[str] = []
@@ -696,11 +728,13 @@ class GitHub:
                 if not url.startswith(same_repo_pull):
                     continue  # a mention from another repo says nothing here
                 urls.append(url)
-            if urls:
-                # The caller's question is boolean -- is ANY open same-repo
-                # PR linked? -- so once a page yields one, later pages can
-                # only add more URLs to a message, never change the
-                # decision: stop paying for them.
+            if urls and not exhaustive:
+                # The DEFAULT caller's question is boolean -- is ANY open
+                # same-repo PR linked? -- so once a page yields one, later
+                # pages can only add more URLs to a message, never change the
+                # decision: stop paying for them. An `exhaustive` caller is
+                # asking which PR, not whether, and for THAT question the
+                # later pages are the whole point -- so it keeps walking.
                 break
             if len(events) < TIMELINE_PAGE_SIZE:
                 break  # short page: the timeline is exhausted
@@ -787,6 +821,29 @@ class GitHub:
             if isinstance(c, dict)
         ]
 
+    def marked_comment(
+        self, owner: str, repo: str, number: int, marker: str
+    ) -> "IssueComment | None":
+        """THE own-authored comment carrying `marker` on this issue/PR, or None.
+
+        The find half of the activity comment's find-or-create, lifted out of
+        the writer so the READER shares one definition of "the daemon's
+        activity comment" with it -- a marker/author filter that drifted
+        between the two would let a spawn append to one comment while the
+        cross-instance claim check read another.
+
+        Both halves of the filter are load-bearing. The marker names the
+        mechanical log (an operator page on the same artifact must never be
+        mistaken for it), and OWN AUTHORSHIP is what keeps a marker anyone can
+        paste from being PATCHed by the writer -- or, for the reader, from
+        being able to park a lane by spoofing a claim line. First match wins,
+        matching the writer's `mine[0]`.
+        """
+        for comment in self.issue_comments(owner, repo, number):
+            if comment.author == self.login and marker in comment.body:
+                return comment
+        return None
+
     def update_comment(
         self, owner: str, repo: str, comment_id: int, body: str
     ) -> None: