alissa-tools-github-orcloop 0.3.3__tar.gz → 0.3.4__tar.gz

{alissa_tools_github_orcloop-0.3.3/src/main/alissa_tools_github_orcloop.egg-info → alissa_tools_github_orcloop-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-orcloop
-Version: 0.3.3
+Version: 0.3.4
 Summary: ALISSA-TOOLS-GITHUB-ORCLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_orcloop-0.3.3 → alissa_tools_github_orcloop-0.3.4}/src/main/alissa/tools/github/orcloop/alissa_client.py

@@ -95,6 +95,38 @@ Body of Work (otherwise 403 ``FORBIDDEN`` on attach/detach) -- an operator setup
 step, documented in the README. orcloop never attaches: attaching is the
 operator's trigger, detaching is orcloop's terminal release act.
 
+THE DEPENDENCY GATE'S DECLARED COUNT (O10)
+==========================================
+A task detail declares its dependencies in **two** arrays, not one, and the
+split is by dependency TYPE -- verified live against ``api.alissa.app`` while
+implementing issue #26:
+
+* ``dependsOn``     -- the ids of the **soft**-typed dependencies.
+* ``hardDependsOn`` -- the ids of the **hard**-typed ones (key ABSENT, not
+  empty, when there are none).
+* ``upstreamTasks`` -- the RESOLVED view of both, deduplicated, soft rows
+  first. There is no ``softDependsOn``.
+
+Reading only ``dependsOn`` -- which is what shipped from O2 through O9 -- sized
+the gate off the soft dependencies alone, so a task blocked purely by hard ones
+declared zero and released (the O4 dry-run finding, repo issue #11 -> #26). The
+count is now the size of the **union of the two id sets**.
+
+Why the union of ids and not ``len(upstreamTasks)``, the other option the issue
+offered: ``upstreamTasks`` is the resolved list, so counting it makes
+``loop.dependencies_clear``'s visibility guard (`resolved != declared`)
+tautologically true and an upstream this actor cannot see disappears from the
+gate entirely -- trading one silent release for another. The declared ids are
+the only count that comes from a source the actor's visibility cannot shrink.
+
+Why a SET union and not the sum of the two lengths: the same upstream can be
+linked BOTH ways (verified live -- the API accepts a second link of the other
+type and lists that one id in both arrays), while ``upstreamTasks`` reports it
+once. Summing would declare 2 against 1 resolved, and the conservative guard
+would then hold a task whose only dependency is fully validated -- forever,
+eventually paging ``release-blocked``. Deduplicating matches what the resolved
+view actually does.
+
 WHO AM I (O8)
 =============
 ``GET /v1/ping`` -- ``{"pong", "timestamp", "userId", "actorId",
@@ -254,10 +286,12 @@ class Task:
     criteria: tuple[Criterion, ...]
     priority: str = ""
     created_at: int = 0  # ms since epoch; 0 when the payload omits createdAt
-    # The resolved upstream tasks (statuses the dependsOn gate reads).
+    # The resolved upstream tasks (statuses the dependency gate reads).
     dependencies: tuple[Dependency, ...] = ()
-    # len(dependsOn): may EXCEED len(dependencies) when an upstream is invisible
-    # to this actor -- the gate treats that mismatch as "not provably clear".
+    # How many dependencies the payload DECLARES: |dependsOn ∪ hardDependsOn|,
+    # both types, deduplicated (see the module docstring, O10). May EXCEED
+    # len(dependencies) when an upstream is invisible to this actor -- the gate
+    # treats that mismatch as "not provably clear".
     depends_on_count: int = 0
 
 
@@ -542,11 +576,14 @@ class AlissaClient:
                 )
             )
 
-        # The dependsOn gate reads upstream statuses. `dependsOn` is the id
-        # list; `upstreamTasks` is the resolved view (id/title/status). We key
-        # the gate on the resolved statuses but remember the raw dependsOn
-        # count so an upstream this actor cannot see (present in dependsOn,
-        # absent from upstreamTasks) reads as "not provably clear".
+        # The dependency gate reads upstream statuses. `dependsOn` (soft) and
+        # `hardDependsOn` (hard) are the declared id lists; `upstreamTasks` is
+        # the resolved view of BOTH (id/title/status). We key the gate on the
+        # resolved statuses but remember the declared count so an upstream this
+        # actor cannot see (declared, absent from upstreamTasks) reads as "not
+        # provably clear". Both arrays are counted, deduplicated -- see the
+        # module docstring for why neither `len(upstreamTasks)` nor a plain sum
+        # of the two lengths is the right size.
         dependencies: list[Dependency] = []
         for up in task.get("upstreamTasks") or []:
             if not isinstance(up, dict):
@@ -558,8 +595,32 @@ class AlissaClient:
                 else str(up.get("_id") or "")
             )
             dependencies.append(Dependency(ref=up_ref, status=up.get("status") or ""))
-        depends_on = task.get("dependsOn")
-        depends_on_count = len(depends_on) if isinstance(depends_on, list) else 0
+        declared: set[str] = set()
+        unrecognised = 0
+        for raw in (task.get("dependsOn"), task.get("hardDependsOn")):
+            if not isinstance(raw, list):
+                continue  # absent (the common case for hardDependsOn) or junk
+            for entry in raw:
+                if isinstance(entry, str):
+                    declared.add(entry)
+                    continue
+                # These arrays hold bare id strings today, but they could grow
+                # into objects the way `upstreamTasks` already is -- so take the
+                # id when there is one, using the same extraction as the loop
+                # above. Counting an id we DID parse as unknown would inflate
+                # the declared count past the resolved one and hold a finished
+                # dependency forever, which is the very outcome the module
+                # docstring gives for rejecting a plain sum of the two lengths.
+                entry_id = entry.get("_id") if isinstance(entry, dict) else None
+                if isinstance(entry_id, str) and entry_id:
+                    declared.add(entry_id)
+                else:
+                    # Nothing parseable. DROPPING it would shrink the declared
+                    # count -- exactly the failure this whole change is about --
+                    # so count it: over-counting only holds the release, and it
+                    # cannot be deduplicated against anything anyway.
+                    unrecognised += 1
+        depends_on_count = len(declared) + unrecognised
 
         created_raw = task.get("createdAt")
         created_at = int(created_raw) if isinstance(created_raw, (int, float)) else 0

{alissa_tools_github_orcloop-0.3.3 → alissa_tools_github_orcloop-0.3.4}/src/main/alissa/tools/github/orcloop/loop.py

@@ -31,10 +31,12 @@ issues the develop daemon can pick up:
     open unlabeled trailer match is ADOPTED (ledger row + label, never a
     second issue), an open labeled one is skipped, a closed one follows the
     closed-match rule below. A check that cannot answer holds the release.
-* **The dependsOn gate**: a candidate is releasable only once every upstream
+* **The dependency gate**: a candidate is releasable only once every upstream
   task it depends on is `pending_validation` or `validated` (an unfinished
-  dependency holds the release). An upstream this actor cannot even see counts
-  as not-clear -- the gate is conservative.
+  dependency holds the release). BOTH dependency types count -- soft
+  (`dependsOn`) and hard (`hardDependsOn`); see `dependencies_clear` and the
+  declared-count rationale in `alissa_client`. An upstream this actor cannot
+  even see counts as not-clear -- the gate is conservative.
 * **Per-repo lane occupancy** bounds how much autonomous work runs at once in
   one repo: at most `repo_parallelism` in-flight released issues, AND -- when
   parallelism > 1 -- their `Autonomous-Scope` globs must be pairwise disjoint
@@ -245,8 +247,9 @@ from .state import State
 
 log = logging.getLogger(__name__)
 
-# The dependsOn gate: an upstream task is "clear" (no longer holding the
-# release) once it has reached validation. Anything earlier holds.
+# The dependency gate: an upstream task is "clear" (no longer holding the
+# release) once it has reached validation. Anything earlier holds. The type of
+# the dependency (soft/hard) does not enter here -- both hold identically.
 DEP_CLEAR_STATES = frozenset({"pending_validation", "validated"})
 
 # The close edge only mutates a task it left `committed` (or one mid-transition
@@ -497,12 +500,27 @@ def priority_rank(priority: str) -> int:
 def dependencies_clear(task: Task) -> bool:
     """Whether every dependency of `task` has reached validation.
 
-    Vacuously true with no dependencies. Conservative on partial visibility: if
-    the resolved `dependencies` are fewer than the raw `depends_on_count`, some
-    upstream is invisible to this actor and the gate must NOT pass on the ones
-    it can see -- an unfinished-but-hidden dependency would otherwise leak."""
-    if task.depends_on_count == 0:
-        return True
+    Two conditions, in this order, and the order is the whole point:
+
+    1. The declared count must match what was RESOLVED. `depends_on_count` is
+       what the payload declared (soft + hard, deduplicated); `dependencies` is
+       what came back resolved. Fewer resolved means an upstream is invisible to
+       this actor, and the gate must NOT pass on the ones it can see -- an
+       unfinished-but-hidden dependency would otherwise leak.
+    2. Every resolved upstream must have reached validation.
+
+    Vacuously true with no dependencies: 0 declared and 0 resolved match, and
+    `all()` over an empty tuple is True. That is deliberately reached THROUGH
+    the visibility guard rather than by an `if depends_on_count == 0: return
+    True` shortcut ahead of it, which is what made this function release a task
+    whose only blockers were hard dependencies (issue #26): `dependsOn` held the
+    soft ids only, so a hard-only task declared zero and took the shortcut --
+    while `upstreamTasks`, and therefore `dependencies`, listed the blocker the
+    whole time. The declared count is fixed in `alissa_client.get_task`; the
+    shortcut is gone from here so that a count that ever again understates
+    reality is HELD by the mismatch instead of waved through. Do not reintroduce
+    an early return above the guard.
+    """
     if len(task.dependencies) != task.depends_on_count:
         return False
     return all(dep.status in DEP_CLEAR_STATES for dep in task.dependencies)
@@ -1299,14 +1317,30 @@ class Orchestrator:
         return self._release(task, target, scope, occupancy, bow=bow)
 
     def _release_blocked(self, task: Task) -> tuple[str, Decision]:
-        """The dependsOn gate holds. Below the floor this is a quiet per-poll
+        """The dependency gate holds. Below the floor this is a quiet per-poll
         hold; past `release_blocked_floor_days` (measured on the task's own age)
         it pages the operator once. `created_at` is ms since epoch; a task with
         no timestamp (created_at 0) is treated as old enough to page, so a stuck
         release is never silent forever."""
-        deps = ", ".join(f"{d.ref}={d.status or '?'}" for d in task.dependencies) or (
-            f"{task.depends_on_count} dependency(ies) not visible to this actor"
-        )
+        parts = [f"{d.ref}={d.status or '?'}" for d in task.dependencies]
+        hidden = task.depends_on_count - len(task.dependencies)
+        if hidden > 0:
+            # Report the invisible remainder ALONGSIDE the resolved ones: a
+            # partially-visible task holds on something the operator cannot see
+            # in the list, and naming only the resolved deps reads as "these are
+            # all of them" when it is precisely the missing one doing the hold.
+            # When NOTHING resolved there is no list to be a remainder OF, and
+            # "3 more" would be more than what -- so that shape keeps its own
+            # count-only wording. This string goes onto the `release-blocked`
+            # page an operator reads to decide what to unblock.
+            parts.append(
+                f"{hidden} more not visible to this actor" if parts
+                else f"{hidden} dependency(ies) not visible to this actor"
+            )
+        # `parts` is never empty here: this runs only after `dependencies_clear`
+        # returned False, which needs either a count mismatch (hidden > 0,
+        # handled just above) or a resolved dep that has not validated.
+        deps = ", ".join(parts)
         floor_seconds = self.config.release_blocked_floor_days * 86400
         age_seconds = self._now() - (task.created_at / 1000.0 if task.created_at else 0.0)
         if age_seconds >= floor_seconds:

alissa_tools_github_orcloop-0.3.4/src/main/alissa/tools/github/orcloop/version

@@ -0,0 +1 @@
+0.3.4

{alissa_tools_github_orcloop-0.3.3 → alissa_tools_github_orcloop-0.3.4/src/main/alissa_tools_github_orcloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-orcloop
-Version: 0.3.3
+Version: 0.3.4
 Summary: ALISSA-TOOLS-GITHUB-ORCLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_orcloop-0.3.3/src/main/alissa/tools/github/orcloop/version

@@ -1 +0,0 @@
-0.3.3