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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-orcloop
-Version: 0.3.3
+Version: 0.3.5
 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.5}/src/main/alissa/tools/github/orcloop/__main__.py

@@ -126,7 +126,9 @@ def build_parser() -> argparse.ArgumentParser:
         action="append",
         metavar="ACTOR_ID",
         help="bow feed only: trust bodies of work OWNED by this Alissa actor "
-        "as release feeds; repeatable. When given, REPLACES the config "
+        "as release feeds; repeatable, and one flag may carry several ids "
+        "separated by `|` (the daemon-family convention) or `,`, the same as "
+        "--repo. When given, REPLACES the config "
         "`bow_owners` list. OPTIONAL — left unset, the daemon resolves its own "
         "token's actor at boot and trusts only its own containers; give this "
         "flag only when the containers belong to someone else. Being SHARED a "

{alissa_tools_github_orcloop-0.3.3 → alissa_tools_github_orcloop-0.3.5}/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.5}/src/main/alissa/tools/github/orcloop/config.py

@@ -21,19 +21,36 @@ watch nothing, but boot anyway), an empty orcloop allowlist is **fatal at
 startup** — the orchestrator releases work into `alissa:develop` issues and
 closes the loop on merge, so it never runs against an unbounded repo set.
 
-REPOS SEPARATOR (O7). A repo list written as one string — `ALISSA_ORC_REPOS`,
-a `--repo a/b|c/d` flag, or a single-element list in the config file — is split
-on **both `|` and `,`**, mixed freely. `|` is the daemon **family convention**
-(devloop's `ALISSA_DEV_REPOS` has always been pipe-separated); comma stays
-accepted for backward compatibility with every orcloop release up to 0.3.0.
-The convention matters because the operator points several Railway services at
-ONE list through a variable reference — `ALISSA_ORC_REPOS=${{dev.ALISSA_DEV_REPOS}}`
-— which only works if both daemons read the same separator. Entries are
-whitespace-stripped, empties from splitting are dropped (so a trailing
-separator is harmless), duplicates collapse, and each surviving entry must look
-like `owner/repo` (a bare word or a pasted URL is a fatal startup error naming
-the offending entry). An allowlist that is empty *after* parsing stays fatal —
-fail-closed is unchanged.
+LIST SEPARATORS (O7, O11). **Every** list-valued key parses the same way. A
+list written as one string — `ALISSA_ORC_REPOS`, `ALISSA_ORC_BOW_OWNERS`, a
+`--repo a/b|c/d` flag, or a single element of the config file's list — is split
+on **both `|` and `,`**, mixed freely, by the one shared splitter
+(`split_entries`). `|` is the daemon **family convention** (devloop's
+`ALISSA_DEV_REPOS` has always been pipe-separated); comma stays accepted for
+backward compatibility with every orcloop release up to 0.3.0. The convention
+matters because the operator points several Railway services at ONE list
+through a variable reference —
+`ALISSA_ORC_REPOS=${{dev.ALISSA_DEV_REPOS}}` — which only works if both daemons
+read the same separator. Entries are whitespace-stripped, empties from
+splitting are dropped (so a trailing separator is harmless), and duplicates
+collapse.
+
+What differs per key is the SHAPE check and what an empty result means — never
+the syntax:
+
+* `repos` entries must look like `owner/repo` (a bare word or a pasted URL is a
+  fatal startup error naming the offending entry), and an allowlist that is
+  empty *after* parsing stays fatal — fail-closed is unchanged.
+* `bow_owners` entries must look like an Alissa actor id (see below), and an
+  empty result means "not overridden", not "trust everyone" (see FEED
+  AUTHORITY).
+
+That the two keys once disagreed is the defect O11 closed: through 0.3.4
+`bow_owners` split on `,` only, so an operator following the documented
+convention got a single entry containing a `|`. Since 0.3.2's shape check that
+at least aborted startup, but phrased as though a username had been typed;
+before it, the entry simply matched no actor and the fail-closed feed released
+nothing at all. Both are why the splitter is shared rather than copied.
 
 The marker contract (`Autonomous-Dev` / `Autonomous-Scope` issue-body
 trailers) is parsed in `markers.py`; the keys that name those trailers live
@@ -119,17 +136,17 @@ RELEASE_FEEDS = (FEED_SCAN, FEED_BOW)
 # Keys carrying a boolean; env strings for these need real parsing (bool("false")
 # is True, which would silently invert the setting).
 _BOOL_KEYS = frozenset({"dry_run", "close_loop_enabled"})
-# Keys carrying a list of strings. In an env value they are separator-delimited;
-# `repos` accepts the family's `|` as well as `,` (see REPO_SEPARATORS), every
-# other list key is comma-separated.
+# Keys carrying a list of strings. Every one of them is separator-delimited when
+# it arrives as a single string, with the SAME separators (see LIST_SEPARATORS
+# and `split_entries`) — a per-key syntax is exactly the drift O11 removed.
 _LIST_KEYS = frozenset({"repos", "bow_owners"})
 
-# The separators a one-string repo list may use, in preference order. `|` is the
-# daemon-family convention (devloop's ALISSA_DEV_REPOS), which is what lets one
-# Railway variable reference feed both daemons; `,` is what orcloop shipped
+# The separators any one-string list value may use, in preference order. `|` is
+# the daemon-family convention (devloop's ALISSA_DEV_REPOS), which is what lets
+# one Railway variable reference feed both daemons; `,` is what orcloop shipped
 # through 0.3.0 and stays accepted. Mixing them in one value is fine.
-REPO_SEPARATORS = ("|", ",")
-_REPO_SPLIT_RE = re.compile("[" + re.escape("".join(REPO_SEPARATORS)) + "]")
+LIST_SEPARATORS = ("|", ",")
+_LIST_SPLIT_RE = re.compile("[" + re.escape("".join(LIST_SEPARATORS)) + "]")
 
 # What an allowlist entry must look like once split: exactly one `/`, a GitHub
 # owner (alphanumerics and hyphens, not leading/trailing) and a repo name
@@ -205,19 +222,41 @@ def _string_list(value: Any, key: str) -> tuple[str, ...]:
     return tuple(value)
 
 
-def split_repo_entries(raw: str) -> list[str]:
-    """Split one repo-list string into entries on `|` and/or `,`.
+def split_entries(raw: str) -> list[str]:
+    """Split one list-valued string into entries on `|` and/or `,`.
 
     Whitespace around an entry is stripped and empties are dropped, so a
     trailing separator, a doubled one, and `a/b | c/d` all behave. This is the
-    ONE place the separator set is applied: the library's env layer, the CLI
-    flag, the config file, and the container's `render_config.py` all route
-    through it, so no surface can end up accepting a different syntax.
-
-    Splitting only — shape validation is `normalize_repos`, because the config
-    file may also hand over an already-split JSON list.
+    ONE place the separator set is applied, for EVERY list key: the library's
+    env layer, the CLI flags, the config file, and the container's
+    `render_config.py` all route through it, so neither a surface nor a key can
+    end up accepting a different syntax (through 0.3.4 `bow_owners` did — see
+    the module docstring).
+
+    Splitting only — the per-key shape check is `normalize_repos` /
+    `normalize_bow_owners`, because the config file may also hand over an
+    already-split JSON list.
     """
-    return [entry for part in _REPO_SPLIT_RE.split(raw) if (entry := part.strip())]
+    return [entry for part in _LIST_SPLIT_RE.split(raw) if (entry := part.strip())]
+
+
+# The 0.3.1-0.3.4 name, kept as an alias rather than deleted. The container's
+# `render_config.py` resolves the splitter through `getattr(cfg, ...)` so that a
+# dist too OLD to carry it dies naming it; an image built from an older
+# docker/claude directory against a NEWER dist would hit that same branch on a
+# pure rename and be told its library is too old, which is both false and the
+# opposite of the fix. One line keeps that message honest. New code uses
+# `split_entries`; there is no second implementation to drift.
+#
+# `REPO_SEPARATORS` — the constant renamed in the same release — deliberately
+# gets NO alias, because the two names fail differently. The function is
+# resolved dynamically, so a missing one produces a MISDIRECTING message; the
+# constant was never resolved at runtime by any shipped renderer (0.3.1-0.3.4
+# only name it in a comment), so a stale import of it is an ImportError naming
+# the symbol — loud and self-explanatory. There is no lie for an alias to
+# prevent there, and a `REPO_*` name for a list-neutral concept would invite the
+# next reader straight back into the drift this release closed.
+split_repo_entries = split_entries
 
 
 def normalize_repos(values: tuple[str, ...] | list[str]) -> tuple[str, ...]:
@@ -236,7 +275,7 @@ def normalize_repos(values: tuple[str, ...] | list[str]) -> tuple[str, ...]:
     out: list[str] = []
     seen: set[str] = set()
     for value in values:
-        for entry in split_repo_entries(value):
+        for entry in split_entries(value):
             _validate_repo_entry(entry)
             if (key := entry.casefold()) not in seen:
                 seen.add(key)
@@ -288,11 +327,14 @@ def _validate_repo_entry(entry: str) -> None:
 def normalize_bow_owners(values: tuple[str, ...] | list[str]) -> tuple[str, ...]:
     """Turn the raw `bow_owners` layer value into the validated authority list.
 
-    Entries are whitespace-stripped, empties dropped (so a trailing comma is
-    harmless, matching `repos`), duplicates collapsed — EXACTLY, with no
-    casefolding, because actor ids are opaque: two spellings that differ in case
-    are two different strings on the wire, and folding them would silently widen
-    the match. Every survivor must look like an actor id.
+    Parsed EXACTLY like `repos`, through the same `split_entries`: an element
+    may itself carry a whole `|`- and/or `,`-separated list (that is what
+    `ALISSA_ORC_BOW_OWNERS` and a Railway variable reference look like),
+    whitespace is stripped and empties dropped, so a trailing separator is
+    harmless. Duplicates collapse EXACTLY, with no casefolding — unlike `repos`,
+    because actor ids are opaque: two spellings that differ in case are two
+    different strings on the wire, and folding them would silently widen the
+    match. Every survivor must look like an actor id.
 
     Emptiness is fine here and means "not overridden": the boot path resolves
     the authority to this token's own actor (see the module docstring). There is
@@ -303,13 +345,11 @@ def normalize_bow_owners(values: tuple[str, ...] | list[str]) -> tuple[str, ...]
     out: list[str] = []
     seen: set[str] = set()
     for value in values:
-        entry = value.strip()
-        if not entry:
-            continue
-        _validate_actor_id(entry)
-        if entry not in seen:
-            seen.add(entry)
-            out.append(entry)
+        for entry in split_entries(value):
+            _validate_actor_id(entry)
+            if entry not in seen:
+                seen.add(entry)
+                out.append(entry)
     return tuple(out)
 
 
@@ -353,7 +393,18 @@ def _validate_actor_id(entry: str) -> None:
                 f"it contains {offending!r}, which no actor id does"
             )
         hint = " — " + " and ".join(problems)
-        if offending:
+        parts = entry.split()
+        if len(parts) > 1 and all(_ACTOR_ID_RE.match(part) for part in parts):
+            # Splitting has already run, so an entry that STILL holds whitespace
+            # was never separated at all. Say so ONLY when every part is itself
+            # an id, which is the only evidence that this is two ids and not a
+            # display name: "Alissa Code PR Review" also contains spaces, and
+            # telling its author to fix their separator loses the hint below —
+            # the diagnostic O8 added, in the change that is about diagnostics.
+            # A mixed `<id> not-an-id` falls through here on purpose: that
+            # operator's problem is the entry, not the separator.
+            hint += "; separate several ids with `|` or `,`, not a space"
+        elif offending:
             hint += "; that looks like a username or a display name"
     raise ValueError(
         f"bow_owners entry {entry!r} is not an Alissa actor id{hint}. Use the "
@@ -362,8 +413,9 @@ def _validate_actor_id(entry: str) -> None:
         f"username or display name: names are renameable, so an ownership "
         f"check against one is a spoof surface, and since no id on the wire "
         f"ever equals a name it would fail as a silently empty feed rather "
-        f"than an error. Leave bow_owners unset to trust this token's own "
-        f"actor, which needs no id at all."
+        f"than an error. Several ids are separated by `|` (the daemon-family "
+        f"convention) or `,`, the same as repos. Leave bow_owners unset to "
+        f"trust this token's own actor, which needs no id at all."
     )
 
 
@@ -397,15 +449,13 @@ def env_overrides(environ: Mapping[str, str] | None = None) -> dict[str, Any]:
         raw = env[env_name]
         if key in _BOOL_KEYS:
             out[key] = _env_bool(env_name, raw)
-        elif key == "repos":
-            # Separator-tolerant (`|` and `,`); shape-validated in `build`
-            # alongside the file and CLI layers, so one bad entry reports the
-            # same way wherever it came from.
-            out[key] = tuple(split_repo_entries(raw))
         elif key in _LIST_KEYS:
-            out[key] = tuple(
-                item for part in raw.split(",") if (item := part.strip())
-            )
+            # ONE branch for every list key, separator-tolerant (`|` and `,`).
+            # `repos` had its own until 0.3.4 while the rest split on `,` alone,
+            # which is precisely how the two syntaxes drifted apart. Shape is
+            # validated in `build` alongside the file and CLI layers, so one bad
+            # entry reports the same way wherever it came from.
+            out[key] = tuple(split_entries(raw))
         else:
             out[key] = raw
     return out
@@ -465,8 +515,11 @@ class Config:
     # allowed to OWN a feed container. The title tells the daemon which repo a
     # container targets; it says nothing about who created it, and the daemon
     # lists containers it merely collaborates on, which anyone in the tenant can
-    # arrange unilaterally. So provenance is decided here. Ids are opaque and
-    # compared EXACTLY (unlike `repos`, which casefolds GitHub names).
+    # arrange unilaterally. So provenance is decided here. Entries reach `build`
+    # as `|`- and/or `,`-separated text from any layer, exactly like `repos`, and
+    # land here split, shape-checked and de-duplicated — but de-duplicated
+    # EXACTLY: ids are opaque, so unlike `repos` (case-insensitive GitHub names)
+    # nothing here is casefolded, in the comparison or in the collapse.
     #
     # Empty means "not overridden", NOT "trust everyone": the boot path resolves
     # it to this token's own actor and dies if it cannot (O8), and until it does

{alissa_tools_github_orcloop-0.3.3 → alissa_tools_github_orcloop-0.3.5}/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.5/src/main/alissa/tools/github/orcloop/version

@@ -0,0 +1 @@
+0.3.5

{alissa_tools_github_orcloop-0.3.3 → alissa_tools_github_orcloop-0.3.5/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.5
 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