alissa-tools-github-devloop 0.8.18__tar.gz → 0.8.20__tar.gz

{alissa_tools_github_devloop-0.8.18/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.8.20}/PKG-INFO

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

{alissa_tools_github_devloop-0.8.18 → alissa_tools_github_devloop-0.8.20}/src/main/alissa/tools/github/devloop/janitor.py

@@ -42,16 +42,58 @@ from .proc import CommandError, run
 
 log = logging.getLogger(__name__)
 
-# A task workspace's directory name, which is ALSO its branch name: the
-# directives mandate `git worktree add TASK-<n>-<DESC>` with <n> the worker's
-# own implementation task, and `pr_task_ref` in loop.py already reads the same
-# shape off a PR's head ref. Full-matched, never prefix-matched, for
-# `parse_worker_session`'s reason: this module's consumer deletes directories,
-# and `TASK-` matches anything an operator felt like naming that way. The
-# description charset is the branch charset the fix edge already refuses to
-# leave (`[A-Za-z0-9._-]+`), so a name that would need shell quoting is not
-# one of ours.
-TASK_WORKSPACE_RE = re.compile(r"TASK-(?P<task>\d+)(?:-(?P<desc>[A-Za-z0-9._-]+))?")
+# A task workspace's directory name. The directives mandate `git worktree add
+# TASK-<n>-<DESC>` with <n> the worker's own implementation task, and
+# `pr_task_ref` in loop.py reads the same shape off a PR's head ref -- and,
+# since issue #115, the PR-side directives tolerate a branch behind one
+# `task/` prefix and then say `git worktree add task--TASK-<n>-<DESC>
+# task/TASK-<n>-<DESC>`: the directory is the branch with `/` rewritten to
+# `--` (WORKTREE_DIR_SEPARATOR) so the worktree stays a flat direct child of
+# the hub. So a workspace directory is the flat shape, or the flat shape
+# behind `task--`, or `task--<n>-<desc>` (the `TASK-` literal dropped, the
+# third shape the incident's workers produced). Full-matched, never
+# prefix-matched, for `parse_worker_session`'s reason: this module's consumer
+# deletes directories, and `TASK-` matches anything an operator felt like
+# naming that way. The description charset is the branch charset the fix
+# edge already refuses to leave (`[A-Za-z0-9._-]+`), so a name that would
+# need shell quoting is not one of ours.
+TASK_WORKSPACE_RE = re.compile(
+    r"(?:task--(?:TASK-)?|TASK-)(?P<task>\d+)(?:-(?P<desc>[A-Za-z0-9._-]+))?"
+)
+
+# The same grammar as a BRANCH name -- the directory grammar with the
+# rewritten separator put back. `is_task_branch` asks this one; the two are
+# kept side by side so the pair a `task--…` directory promises (`task/…`
+# checked out in it) is one mapping stated once (`branch_of_dir`).
+TASK_BRANCH_RE = re.compile(
+    r"(?:task/(?:TASK-)?|TASK-)(?P<task>\d+)(?:-(?P<desc>[A-Za-z0-9._-]+))?"
+)
+
+# What a branch's `/` becomes in its worktree directory's name, and the
+# prefix that marks a directory as carrying one. Only a directory that BEGINS
+# with `task--` is ever read back as a prefixed branch, so a flat branch that
+# happens to contain `--` mid-name maps to itself in both directions.
+WORKTREE_DIR_SEPARATOR = "--"
+_PREFIXED_DIR = "task" + WORKTREE_DIR_SEPARATOR
+_PREFIXED_BRANCH = "task/"
+
+
+def dir_of_branch(branch: str) -> str:
+    """The worktree directory name for `branch`: `/` rewritten to `--`, so a
+    `task/TASK-<n>-<DESC>` branch lives in `task--TASK-<n>-<DESC>` and a flat
+    branch in a directory of its own name. Pure string mapping -- the shape
+    gates are the caller's (`loop.worktree_dir` applies them)."""
+    return branch.replace("/", WORKTREE_DIR_SEPARATOR)
+
+
+def branch_of_dir(name: str) -> str:
+    """The branch a workspace directory `name` promises: the inverse of
+    `dir_of_branch` for the one prefix the daemon tolerates. `task--X` ->
+    `task/X`; anything else is its own branch name."""
+    if name.startswith(_PREFIXED_DIR):
+        return _PREFIXED_BRANCH + name[len(_PREFIXED_DIR):]
+    return name
+
 
 # Where the `archive` holdout policy pushes unpushed work (issue #99): a NEW
 # ref under this prefix, named after the task branch. Never the task branch
@@ -85,12 +127,14 @@ DEFAULT_CACHE_PATHS: "tuple[str, ...]" = (
 class TaskWorkspace:
     """One per-task workspace directory, parsed back into what it is.
 
-    `branch` is the directory name verbatim -- the two are the same string by
-    construction (`git worktree add TASK-<n>-<DESC>` names the worktree
-    directory and the branch together), and keeping both names for one value
-    is what makes the removal code read honestly: the directory is removed by
-    path, the branch is deleted by name, and a future layout where they differ
-    has one place to fix.
+    `branch` is the branch the directory name PROMISES (`branch_of_dir`):
+    the directory name itself for the flat shape (`git worktree add
+    TASK-<n>-<DESC>` names the worktree directory and the branch together),
+    and `task/…` for a `task--…` directory (the PR-side directives' flat
+    worktree dir for a tolerated `task/`-prefixed branch, issue #115). The
+    removal code reads honestly either way: the directory is removed by path,
+    the branch is deleted by name, and the reclaim's first gate checks that
+    the checked-out branch IS the promised one.
     """
 
     path: Path
@@ -125,18 +169,23 @@ def parse_task_workspace(path: Path, hub: Path) -> "TaskWorkspace | None":
     if match is None:
         return None
     return TaskWorkspace(
-        path=path, branch=path.name, task=int(match["task"]), hub=hub
+        path=path,
+        branch=branch_of_dir(path.name),
+        task=int(match["task"]),
+        hub=hub,
     )
 
 
 def is_task_branch(name: str) -> bool:
-    """Is `name` one of devloop's own task branches (`TASK-<n>-<DESC>`)?
-
-    The same full-match grammar `parse_task_workspace` admits directories
-    with, re-asserted by name at the one place that pushes: the archive path
-    writes a ref to the remote, and its name is derived from this one, so a
-    branch the daemon did not create must never get a `holdout/` twin."""
-    return TASK_WORKSPACE_RE.fullmatch(name) is not None
+    """Is `name` one of devloop's own task branches (`TASK-<n>-<DESC>`, or the
+    tolerated `task/TASK-<n>-<DESC>` / `task/<n>-<desc>`)?
+
+    The branch twin of the full-match grammar `parse_task_workspace` admits
+    directories with, re-asserted by name at the one place that pushes: the
+    archive path writes a ref to the remote, and its name is derived from
+    this one, so a branch the daemon did not create must never get a
+    `holdout/` twin."""
+    return TASK_BRANCH_RE.fullmatch(name) is not None
 
 
 def holdout_ref(branch: str) -> str:

{alissa_tools_github_devloop-0.8.18 → alissa_tools_github_devloop-0.8.20}/src/main/alissa/tools/github/devloop/loop.py

@@ -27,11 +27,15 @@ and the merge, a finished session's PR sits open for the whole review loop.
 DEAD alone would therefore fire on the modal happy path. So the resume takes
 a FOURTH signal from the PR the session left behind: the handoff publishes
 itself (`gh pr ready` flips the draft off, then the re-request puts a
-reviewer on it), which makes a PR that is STILL A DRAFT with NO reviewer
-requested the one state that says "this session never handed off". That test
-also keeps the edges disjoint -- the moment a PR leaves draft it belongs to
-the review lifecycle and the fix edge owns it exclusively, so no `develop-*`
-resume can land on a branch a `fix-*` session is already working.
+reviewer on it), which makes a PR that is STILL A DRAFT the one state that
+says "this session never handed off" -- whatever reviewer is on it, because
+a review request on a draft publishes nothing (the reviewer daemon only
+reviews non-draft PRs and the fix edge refuses drafts, so nothing downstream
+can ever move a draft; studio.alissa.app#1204 sat 80 minutes behind exactly
+that shape). That test also keeps the edges disjoint -- the moment a PR
+leaves draft it belongs to the review lifecycle and the fix edge owns it
+exclusively, so no `develop-*` resume can land on a branch a `fix-*` session
+is already working.
 
 The signals so far all describe the PR's STATE, and a sibling task's young
 draft satisfies every one of them; a cross-reference is raised by ANY mention
@@ -91,8 +95,8 @@ above takes over as attempt k+1, counting toward attempt_cap like any
 resume. Nothing about the kill is new machinery on the resume side: it
 manufactures the one signal the matrix already acts on. The invariants are
 the matrix's own -- never on INDETERMINATE (absence of evidence keeps the
-defer), never on a PR that left draft or has a reviewer engaged (the wedge
-sits strictly behind `_resumable_pr`), never with `resume_enabled` false (a
+defer), never on a PR that left draft (the wedge sits strictly behind
+`_resumable_pr`), never with `resume_enabled` false (a
 kill whose resume cannot fire would only orphan the lane), and never a
 roster sweep.
 
@@ -173,7 +177,9 @@ self-heal needs an unanswered review, and the issue-edge resume keys off an
 OPEN labeled issue, which a draft replayed after its issue merged does not
 have (fahera-mx/studio.alissa.app#279, 2026-07-28: an operator found it by
 accident). So the PR search is widened to drafts and every draft is asked the
-handoff question instead of being skipped: self-authored, no reviewer on it,
+handoff question instead of being skipped: self-authored (a reviewer already
+requested on it is NOT a reason to skip -- a request on a draft arms nothing,
+so the sweep readies it and requests only the reviewers still missing),
 a daemon-shaped head ref naming an implementation task (a `TASK-<n>-<DESC>`
 branch or a task ref in the body -- the provenance test, `closes_issue`'s
 role here), no live worker session for the PR (the SAME liveness rule --
@@ -217,7 +223,9 @@ attempt number in, and a fresh budget reusing attempt 1 could collide with
 a prior epoch's zombie session. With no readable labeled event the budget
 conservatively stays lifetime-wide (the pre-epoch behavior). The re-fetch
 guards mirror the fix edge's: closed/merged between search and fetch, a
-foreign author, and a foreign-shaped head ref all skip.
+foreign author, and a foreign-shaped head ref all skip (a `task/`-prefixed
+worker branch is NOT foreign since issue #115 -- WORKER_HEAD_REF -- and the
+skip is paged on the PR once per head rather than logged every poll).
 
 All three edges share ONE backpressure valve, `max_sessions` (0 = unlimited,
 the default -- today's behavior preserved). The daemon spawns a session per
@@ -690,6 +698,23 @@ _REVIEW_SEAT = (
     "foreign session the daemon reaps, and its verdict reaches nobody. "
 )
 
+# The branch-NAME rule, stated as a hard MUST with its negative and its
+# consequence (issue #115). The 2026-09-09/10 studio incident: three workers
+# in one window named their branches `task/…` despite the golden-path line
+# above -- the common convention won over a directive that only stated the
+# positive. The daemon now TOLERATES exactly that one deviation on the way
+# back in (WORKER_HEAD_REF), but the rule is still the flat shape, because
+# every other prefix is still foreign and the tolerance is a repair, not a
+# licence. Shared by the issue edge (where the branch is created) and, as a
+# restatement, by the fix and maintain directives (where it is reused).
+_BRANCH_RULE = (
+    "The branch name is a hard rule, not a convention: name the branch "
+    "exactly `TASK-<n>-<DESC>` — NO `task/`, `feat/` or any other prefix, no "
+    "lowercase `task-`; the daemon's fix and maintain edges only spawn on "
+    "that shape, and a PR on any other shape gets no fix round, no "
+    "maintenance and no resume until an operator renames it. "
+)
+
 DEV_DIRECTIVE = (
     "You are an IMPLEMENTER, not a reviewer. Implement GitHub issue "
     "{issue_url} (attempt {attempt} of {cap}) — the issue is your "
@@ -702,7 +727,8 @@ DEV_DIRECTIVE = (
     "origin collides with every sibling of that origin), from there (one "
     "task = one branch = one worktree; never clone, never work directly on "
     "main). "
-    "Implement to the issue's acceptance criteria and VERIFY locally (run the "
+    + _BRANCH_RULE
+    + "Implement to the issue's acceptance criteria and VERIFY locally (run the "
     "repo's test/style/type scripts) before publishing. Open a DRAFT PR whose "
     "body contains `Closes #{number}` and BOTH task refs — the origin task "
     "AND your implementation task: the PR body is the canonical cross-actor "
@@ -741,8 +767,9 @@ RESUME_DIRECTIVE = (
     "previous developer session on GitHub issue {issue_url} died AFTER "
     "opening its pull request but BEFORE handing it off for review — the "
     "daemon confirmed its session `{dead_session}` is gone from the machine, "
-    "and its DRAFT pull request {pr_url} is still open with no reviewer on "
-    "it. This is attempt {attempt} of {cap}, and your job is to FINISH THAT "
+    "and its DRAFT pull request {pr_url} is still open (a reviewer may "
+    "already be requested on it — that is not a handoff; the ready flip is). "
+    "This is attempt {attempt} of {cap}, and your job is to FINISH THAT "
     "PULL REQUEST, not to start the work over. "
     "{task_instruction} "
     "FIRST hydrate the context you did not live through: read the issue (its "
@@ -751,10 +778,12 @@ RESUME_DIRECTIVE = (
     "session got. Golden path: your cwd is the repo's worktree hub ROOT and "
     "the PR's head branch `{head_ref}` ALREADY EXISTS — REUSE its worktree if "
     "one is still on the volume (the dead session's work is in it), otherwise "
-    "re-attach it with `git worktree add {head_ref} {head_ref}`. Work ONLY on "
-    "that branch: never a new branch, never a clone, never main, and NEVER a "
-    "second PR — the open one IS the deliverable, and pushing more commits to "
-    "it is how you deliver. "
+    "re-attach it with `git worktree add {worktree_dir} {head_ref}` (the "
+    "directory and the branch differ only when the branch carries a prefix: "
+    "`/` becomes `--` in the directory name). Work ONLY on that branch, "
+    "under its EXISTING name: never a new branch, never a rename, never a "
+    "clone, never main, and NEVER a second PR — the open one IS the "
+    "deliverable, and pushing more commits to it is how you deliver. "
     "Then complete the ORIGINAL acceptance criteria — the issue's criteria "
     "are unchanged and still authoritative — and VERIFY locally (run the "
     "repo's test/style/type scripts) before publishing. NEVER force-push: "
@@ -791,9 +820,13 @@ FIX_DIRECTIVE = (
     "of your job: the PR body is the canonical cross-actor record. "
     "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 {head_ref} {head_ref}` if it is missing, and work ONLY on "
-    "that branch (never a new branch, never a clone, never main). "
-    "FIRST verify the triage of every prior review finding per CR8: exactly "
+    "worktree add {worktree_dir} {head_ref}` if it is missing (the directory "
+    "and the branch differ only when the branch carries a prefix: `/` becomes "
+    "`--` in the directory name), and work ONLY on that branch under its "
+    "EXISTING name (never a new branch, never a rename, never a clone, never "
+    "main). "
+    + _BRANCH_RULE
+    + "FIRST verify the triage of every prior review finding per CR8: exactly "
     "one reasoned `[triage:*]` reply on each finding's thread — post any that "
     "are missing. Then fix the pursued findings on the same branch and VERIFY "
     "locally (run the repo's test/style/type scripts). "
@@ -840,10 +873,13 @@ FIX_RESUME_DIRECTIVE = (
     "far the dead session got. Golden path: your cwd is the repo's worktree "
     "hub ROOT and the PR's head branch `{head_ref}` ALREADY EXISTS — REUSE "
     "its worktree if one is still on the volume (the dead session's work is "
-    "in it), otherwise re-attach it with `git worktree add {head_ref} "
-    "{head_ref}`. Work ONLY on that branch: never a new branch, never a "
-    "clone, never main, and NEVER a second PR. "
-    "The dead session may have posted SOME of its CR8 triage replies already: "
+    "in it), otherwise re-attach it with `git worktree add {worktree_dir} "
+    "{head_ref}` (the directory and the branch differ only when the branch "
+    "carries a prefix: `/` becomes `--` in the directory name). Work ONLY on "
+    "that branch under its EXISTING name: never a new branch, never a "
+    "rename, never a clone, never main, and NEVER a second PR. "
+    + _BRANCH_RULE
+    + "The dead session may have posted SOME of its CR8 triage replies already: "
     "read every finding's thread and post exactly the ones that are missing — "
     "one reasoned `[triage:*]` reply per finding, NEVER a duplicate on a "
     "thread it already answered. Then fix the pursued findings, completing "
@@ -883,9 +919,13 @@ MAINTAIN_DIRECTIVE = (
     "freshen it. "
     "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 {head_ref} {head_ref}` if it is missing, and work ONLY on "
-    "that branch (never a new branch, never a clone, never main). "
-    "FIRST the idempotent no-op check: if the branch is already conflict-free "
+    "worktree add {worktree_dir} {head_ref}` if it is missing (the directory "
+    "and the branch differ only when the branch carries a prefix: `/` becomes "
+    "`--` in the directory name), and work ONLY on that branch under its "
+    "EXISTING name (never a new branch, never a rename, never a clone, never "
+    "main). "
+    + _BRANCH_RULE
+    + "FIRST the idempotent no-op check: if the branch is already conflict-free "
     "AND current vs origin/main, remove the `{label}` label from the PR "
     "(`gh pr edit {number} --remove-label \"{label}\"`) and exit — push "
     "nothing, re-request nobody; this no-op path is what makes retries safe. "
@@ -1025,6 +1065,21 @@ STACKED_BASE_COMMENT = (
     "belongs to release gating, not to the PR graph."
 )
 
+FOREIGN_HEAD_COMMENT = (
+    "**Dev loop: foreign-shaped head ref `{head_ref}`** — the daemon will not "
+    "run fix or maintain rounds on it. Worker branches must be named exactly "
+    "`TASK-<n>-<DESC>` (a single `task/` prefix is tolerated: "
+    "`task/TASK-<n>-<DESC>` or `task/<n>-<desc>`); any other prefix, a "
+    "second `/`, whitespace or shell metacharacters keep the daemon off the "
+    "branch, because the name is interpolated into a worker session's "
+    "prompt as a worktree path and a shell token. Until the head moves, "
+    "review findings on this PR reach no session and a maintenance label is "
+    "ignored. Operator options: rename the branch (`git branch -m` + push, "
+    "then re-open or retarget the PR), or re-open the PR from a "
+    "`TASK-<n>-<DESC>` branch. Paged once per head; a new head on the same "
+    "shape pages again."
+)
+
 ASSIGNMENT_REJECTED_COMMENT = (
     "**Dev loop cannot start** — the daemon tried to self-assign this issue "
     "as its in-flight marker, but GitHub silently dropped the assignment: "
@@ -1244,6 +1299,16 @@ ESCALATION_ORPHAN_REJECTED = "orphan-rejected"
 # number, like every other PR-side kind here.
 ESCALATION_STACKED_BASE = "stacked-base"
 
+# The fix/maintain edges' foreign-shaped-head skip, paged ON the PR once per
+# (PR, head) (`foreign_head_kind`, issue #115). Before it, the skip was one
+# WARNING per poll in a log nobody tails and NOTHING on the PR: three
+# reviewed studio PRs sat for 1-12 h behind it. Keyed per HEAD, not per PR,
+# because the remedy is to move the head (rename the branch, re-open from a
+# `TASK-<n>-<DESC>` one) and a PR whose head moved and is still foreign has
+# earned a second page. The `foreign-head` prefix keeps these rows from
+# colliding with any issue-edge kind when an issue and a PR share a number.
+ESCALATION_FOREIGN_HEAD = "foreign-head"
+
 # The `archive` holdout policy could not archive a workspace (issue #99): the
 # commit, the push to the holdout ref, or the ls-remote verification failed,
 # or the remote sha did not equal the local HEAD. Keyed per WORKSPACE slug
@@ -1334,6 +1399,11 @@ def rerequest_rejected_kind(round_: int, head_sha: str) -> str:
     return f"{ESCALATION_REREQUEST_REJECTED}:r{round_}@{head_sha}"
 
 
+def foreign_head_kind(head_sha: str) -> str:
+    """The ledger kind for the foreign-shaped-head page on ONE (PR, head)."""
+    return f"{ESCALATION_FOREIGN_HEAD}:{head_sha}"
+
+
 def orphan_kind(head_sha: str) -> str:
     """The ledger kind that marks ONE draft's mechanical handoff as DONE.
 
@@ -1514,16 +1584,60 @@ STALLED_DEFER_MULTIPLE = 2
 # long enough to need scrolling is one nobody reads.
 DISK_OFFENDERS = 3
 
-# The daemon's own branch shape. head_ref reaches every worker directive as
-# BOTH a worktree path and a shell token (`git worktree add {head_ref}
-# {head_ref}`), and a PR's head branch is not strictly self-authored (anyone
-# with push access can move it) -- so every PR-side spawn gates on it: the fix
-# and maintain edges via `_foreign_head_skip`, the issue edge's resume via
-# `_resumable_pr`. Slashes that would nest the worktree path, whitespace and
-# shell metacharacters are all outside it, and a ref outside this shape is not
-# this daemon's work anyway: skip conservatively rather than sanitize.
+# The daemon's own branch shape -- the one its directives NAME (`TASK-<n>-
+# <DESC>`, flat). head_ref reaches every worker directive as a shell token
+# (`git worktree add {worktree_dir} {head_ref}`), and a PR's head branch is
+# not strictly self-authored (anyone with push access can move it) -- so every
+# PR-side spawn gates on a shape test: the fix and maintain edges via
+# `_foreign_head_skip`, the issue edge's resume via `_resumable_pr`. This is
+# also the shape the WORKTREE DIRECTORY must have (`worktree_dir`), since a
+# slash there would nest the worktree under the hub. Whitespace and shell
+# metacharacters are all outside it: skip conservatively rather than sanitize.
 DAEMON_HEAD_REF = re.compile(r"[A-Za-z0-9._-]+")
 
+# The shape a WORKER'S branch is tolerated in: the daemon's own flat shape, or
+# that shape behind exactly one `task/` prefix (issue #115). The 2026-09-09/10
+# studio incident: three of five worker sessions in one window named their
+# branches `task/TASK-<n>-<desc>` / `task/<n>-<desc>` despite the directive,
+# and DAEMON_HEAD_REF -- flat by design, because head_ref used to be the
+# worktree PATH as well as the branch -- stranded all three: no fix round, no
+# maintain, no resume, a WARNING per poll for 12 h. The work was complete and
+# reviewed; only the gate stood between it and a fix session. So the PR-side
+# gates admit this ONE common deviation, with the worktree path derived by
+# `worktree_dir` so the directory stays flat. Everything else stays foreign:
+# any other prefix (`feat/x`), a second slash (`a/b/c`), whitespace, shell
+# metacharacters. `DAEMON_HEAD_REF` stays what the daemon itself names, and
+# DEV_DIRECTIVE still forbids the prefix -- tolerating it on the way back in
+# is not the same as licensing it on the way out.
+WORKER_HEAD_REF = re.compile(r"(?:task/)?[A-Za-z0-9._-]+")
+
+
+def worktree_dir(head_ref: str) -> str:
+    """The worktree DIRECTORY a PR-side directive tells its session to create
+    for `head_ref`: the branch name with `/` rewritten to `--`, so the
+    worktree stays a flat direct child of the hub whatever the branch is
+    called (`task/TASK-42384172-sales-chat-surface` ->
+    `task--TASK-42384172-sales-chat-surface`; a flat name maps to itself).
+
+    Both values are interpolated into an agent prompt as shell tokens, so
+    BOTH pass the shape tests before anything is rendered: the branch must be
+    WORKER_HEAD_REF and the directory DAEMON_HEAD_REF (flat, no metacharacters).
+    A `head_ref` that fails either raises rather than rendering -- the gates
+    upstream (`_foreign_head_skip`, `_resumable_pr`) are what keep such a ref
+    from reaching here, and this is the assertion that they did. The mapping
+    itself is the janitor's (`janitor.dir_of_branch`), so the directory the
+    directive names and the one the janitor reclaims cannot drift apart.
+    """
+    if not WORKER_HEAD_REF.fullmatch(head_ref or ""):
+        raise ValueError(f"head ref {head_ref!r} is not a worker branch shape")
+    directory = janitor.dir_of_branch(head_ref)
+    if not DAEMON_HEAD_REF.fullmatch(directory):
+        raise ValueError(
+            f"worktree dir {directory!r} for head ref {head_ref!r} is not flat"
+        )
+    return directory
+
+
 # GitHub's closing keywords, the PROVENANCE signal behind a resume. Every
 # other admission test the resume applies asks what STATE a PR is in (open,
 # draft, unreviewed, self-authored, daemon-shaped head) -- and a sibling
@@ -1614,6 +1728,14 @@ def closed_issue_numbers(body: str, owner: str, repo: str) -> "tuple[int, ...]":
 # mid-name is not the convention.
 DAEMON_TASK_BRANCH = re.compile(r"TASK-(\d+)(?:-|$)")
 
+# The same convention as a WORKER may have written it (issue #115, the
+# tolerated deviation WORKER_HEAD_REF admits): the flat form, or the flat form
+# behind one `task/`, or `task/<n>-<desc>` with the `TASK-` literal dropped --
+# the three shapes the studio incident's workers actually produced. The task
+# number is the segment after the prefix either way (`task/609837646-…` counts
+# as TASK-609837646). Still anchored at the start, still no other prefix.
+WORKER_TASK_BRANCH = re.compile(r"(?:task/(?:TASK-)?|TASK-)(\d+)(?:-|$)")
+
 # The follow-up PR's provenance trailer, mandated by _APPROVE_FOLLOWUP and read
 # by the orphan sweep's liveness matrix.
 #
@@ -1673,7 +1795,9 @@ def pr_task_ref(head_ref: str, body: str) -> "int | None":
     dead session cannot have failed to establish (it exists before the PR
     does), while a body ref can be missing precisely because the session died
     before writing it. Falling back to the body still catches the PR whose
-    branch was named some other way but whose record is intact.
+    branch was named some other way but whose record is intact. The branch is
+    read with WORKER_TASK_BRANCH, so a `task/`-prefixed worker branch names
+    its task exactly as a flat one does (issue #115).
 
     Deliberately NOT `parse_task_ref`: that reads the `Alissa-Task:` TRAILER an
     ISSUE carries, and a PR body's task refs are prose ("origin TASK-1, mine
@@ -1681,7 +1805,7 @@ def pr_task_ref(head_ref: str, body: str) -> "int | None":
     logging and the activity line only -- nothing keys off WHICH task it is,
     only that the PR names one.
     """
-    match = DAEMON_TASK_BRANCH.match(head_ref or "")
+    match = WORKER_TASK_BRANCH.match(head_ref or "")
     if match:
         return int(match.group(1))
     match = TASK_REF_RE.search(body or "")
@@ -2629,11 +2753,16 @@ class DevWatcher:
         # the session behind the open PR is not running -- but NOT that it was
         # abandoned, because a healthy handoff ends in `alissa tmux kill`. So
         # DEAD only opens the question, and `_resumable_pr` answers it: a
-        # still-draft, no-reviewer PR that CLOSES this issue is one of this
+        # still-draft PR that CLOSES this issue (a reviewer on the draft
+        # changes nothing -- a draft is never handed off) is one of this
         # issue's own sessions that was never handed off, and it
         # is the one case the deferral was always wrong about -- resumed as
         # attempt k+1 with RESUME_DIRECTIVE instead of parking the lane behind
-        # an operator ping. Everything else -- ALIVE, INDETERMINATE, and DEAD
+        # an operator ping. (When the orphan sweep is on it runs EARLIER in
+        # the same pass and readies such a draft mechanically, so the fetch
+        # here sees a non-draft PR and defers -- the sweep's handoff wins
+        # over a resume without any coordination between the edges.)
+        # Everything else -- ALIVE, INDETERMINATE, and DEAD
         # behind a PR already in the review lifecycle -- keeps the floored
         # defer: past STALLED_DEFER_MULTIPLE stale windows it posts a
         # "stalled" operator comment (this deferral sits above the cap check,
@@ -2708,9 +2837,9 @@ class DevWatcher:
                     # an operator reading the log must not have to guess.
                     why = (
                         "no linked PR is resumable (a handed-off PR — out of "
-                        "draft, or with a reviewer engaged — belongs to the "
-                        "review lifecycle, not to a resume; and a PR that "
-                        "only MENTIONS this issue is another task's work)"
+                        "draft — belongs to the review lifecycle, not to a "
+                        "resume; a PR that only MENTIONS this issue is "
+                        "another task's work)"
                         if liveness is Liveness.DEAD
                         and self.config.resume_enabled
                         else "work may be alive (the review loop can outlast "
@@ -2953,6 +3082,7 @@ class DevWatcher:
                 session=name,
                 pr_url=resume_pr.url,
                 head_ref=resume_pr.head_ref,
+                worktree_dir=worktree_dir(resume_pr.head_ref),
                 dead_session=dead_session,
             )
         else:
@@ -3080,12 +3210,23 @@ class DevWatcher:
 
         What separates the two is the PR the session left behind, because the
         handoff PUBLISHES itself: `gh pr ready` flips the draft off, then the
-        re-request puts a reviewer on it. So a PR that is STILL A DRAFT with
-        NO reviewer requested is one its session never handed off -- the only
-        state a resume is owed. (A session that died in the narrow window
-        between the ready flip and the re-request reads handed-off and keeps
-        the legacy floored defer: conservative on purpose, since that is also
-        exactly what a live review loop looks like from here.)
+        re-request puts a reviewer on it. So a PR that is STILL A DRAFT is one
+        its session never handed off -- the only state a resume is owed --
+        and a reviewer requested on that draft does not change the reading: a
+        request on a draft arms nothing (the reviewer daemon reviews only
+        non-draft PRs, the fix edge refuses drafts), so no automation
+        downstream can ever move it. The two half-states a session can die in
+        are therefore read differently: (a) READY + NO reviewer -- the ready
+        flip landed, the request did not -- reads handed-off here and keeps
+        the legacy floored defer, conservative on purpose since that is also
+        exactly what a live review loop looks like from this edge; where this
+        daemon's own sweep made that flip, the `orphan-ready@<head>` row lets
+        the PR edge's `_finish_orphan_handoff` complete it. (b) DRAFT +
+        reviewer -- the request landed, the flip did not (studio#1204: 80
+        minutes behind a draft with `alissa-app` on it) -- is resumable when
+        the session is DEAD, exactly like a review-less draft, and deferred
+        while ALIVE; with the orphan sweep on, that sweep readies it earlier
+        in the same pass, so the resume yields to the mechanical handoff.
 
         That same test settles the cross-edge race: the moment a PR leaves
         draft it belongs to the review lifecycle, and the fix edge -- which
@@ -3098,11 +3239,12 @@ class DevWatcher:
         timeline: still OPEN, authored by the token identity (a foreign PR
         must never grow a session pushing to its branch -- `linked_open_prs`
         filters on open + same-repo only, so a collaborator's or a fork's PR
-        qualifies there), and a head ref of this daemon's own flat shape.
-        Resolving head_ref here is also what lets RESUME_DIRECTIVE NAME the
-        branch instead of telling the agent to derive it from the PR -- an
-        unsanitized token read out of GitHub is exactly what DAEMON_HEAD_REF
-        exists to keep out of an agent prompt.
+        qualifies there), and a head ref of a worker branch shape
+        (WORKER_HEAD_REF: the daemon's own flat shape, or that shape behind
+        one tolerated `task/`). Resolving head_ref here is also what lets
+        RESUME_DIRECTIVE NAME the branch instead of telling the agent to
+        derive it from the PR -- an unsanitized token read out of GitHub is
+        exactly what the shape test exists to keep out of an agent prompt.
 
         Those four tests all ask what STATE a PR is in; none asks whether it
         is OURS. `linked_open_prs` admits any open same-repo PR that
@@ -3162,16 +3304,24 @@ class DevWatcher:
             # still a PR whose base can strand it, and the guard's own author
             # test is what keeps it off PRs that are not ours.
             self._check_stacked_base(pr)
-            if not pr.draft or pr.requested_reviewers:
+            if not pr.draft:
                 log.info(
-                    "%s: %s has been handed off (draft=%s, reviewers=%s) — "
-                    "not a resume candidate; the review lifecycle owns it",
+                    "%s: %s has been handed off (out of draft, reviewers=%s) "
+                    "— not a resume candidate; the review lifecycle owns it",
                     issue.issue_slug,
                     url,
-                    pr.draft,
                     ", ".join(pr.requested_reviewers) or "none",
                 )
                 continue
+            if pr.requested_reviewers:
+                log.info(
+                    "%s: %s is still a DRAFT with %s requested — a review "
+                    "request on a draft is not a handoff (the ready flip is), "
+                    "so this PR is a resume candidate",
+                    issue.issue_slug,
+                    url,
+                    ", ".join(pr.requested_reviewers),
+                )
             if pr.author != self.github.login:
                 log.warning(
                     "%s: %s is authored by %r, not the developer identity — "
@@ -3181,7 +3331,7 @@ class DevWatcher:
                     pr.author,
                 )
                 continue
-            if not DAEMON_HEAD_REF.fullmatch(pr.head_ref):
+            if not WORKER_HEAD_REF.fullmatch(pr.head_ref):
                 log.warning(
                     "%s: %s head ref %r does not match the daemon's own "
                     "branch shape — not resuming onto a foreign-shaped "
@@ -3258,12 +3408,13 @@ class DevWatcher:
 
         Two gates, in order. First `_resumable_pr`, verbatim -- the wedge
         path inherits every admission test the resume has (still a draft,
-        no reviewer, self-authored, daemon-shaped head, a body that CLOSES
-        this issue, exactly one candidate), because the kill it licenses is
+        self-authored, daemon-shaped head, a body that CLOSES this issue,
+        exactly one candidate; a reviewer requested on the draft is not a
+        handoff and does not exclude it), because the kill it licenses is
         only safe where the resume that follows it is: a PR that has left
-        draft or has a reviewer engaged belongs to the review lifecycle,
-        and a live review loop behind an ALIVE session is the healthy shape
-        this daemon was built around. Then the footprint (`_footprint_age`):
+        draft belongs to the review lifecycle, and a live review loop behind
+        an ALIVE session is the healthy shape this daemon was built around.
+        Then the footprint (`_footprint_age`):
         None means unreadable, and unreadable keeps the defer -- the same
         fail-safe every other presumed-dead decision here makes.
 
@@ -4459,24 +4610,26 @@ class DevWatcher:
                 f"identity — not this daemon's to hand off",
             )
 
-        # A draft already carrying a review request is not unhanded-off: a
-        # session (or a human) put a reviewer on it deliberately and simply has
-        # not flipped it ready. Nothing here is owed, and readying it would
-        # take that decision away from whoever made it.
-        if pr.requested_reviewers:
-            return Decision(
-                Action.SKIPPED,
-                f"draft already carries a review request "
-                f"({', '.join(pr.requested_reviewers)}) — its handoff is "
-                f"someone's deliberate work in progress, not an orphan",
-            )
+        # A draft already carrying a review request is NOT excluded (issue
+        # #113). The sweep used to read a reviewer on a draft as someone's
+        # deliberate work in progress, but a request on a draft arms nothing
+        # -- the reviewer daemon reviews only non-draft PRs and the fix edge
+        # refuses drafts -- and the issue edge read the same shape as "handed
+        # off", so a session that died between its `--add-reviewer` and its
+        # `gh pr ready` (studio.alissa.app#1204: 80 minutes of silence after
+        # a 10-hour attempt) left a draft NO edge would ever move. The
+        # liveness gate below is what protects a deliberately-parked draft:
+        # a live session behind it is never swept, and for a DEAD one the
+        # sweep does the FIRST half only -- the ready flip -- and requests
+        # just the configured reviewers that are not already on the PR.
 
         # head_ref reaches nothing but log lines here (the sweep spawns no
         # session, so it never becomes a worktree path or a shell token), but
         # the shape is still the provenance signal every other PR-side act
-        # gates on: this daemon only ever creates flat `TASK-<n>-<DESC>`
-        # branches, so a ref outside that shape is not its work.
-        if not DAEMON_HEAD_REF.fullmatch(pr.head_ref):
+        # gates on: this daemon's workers create flat `TASK-<n>-<DESC>`
+        # branches (or, tolerated, the same behind one `task/` -- issue
+        # #115), so a ref outside that shape is not its work.
+        if not WORKER_HEAD_REF.fullmatch(pr.head_ref):
             return Decision(
                 Action.SKIPPED,
                 f"draft head ref {pr.head_ref!r} does not match the daemon's "
@@ -4804,36 +4957,64 @@ class DevWatcher:
           not retried on this head (escalate-don't-retry, `_escalate_rejection`
           verbatim).
 
+        A draft that ALREADY carries a review request (issue #113) takes the
+        same walk minus the request: the session died between its
+        `--add-reviewer` and its `gh pr ready`, so the flip is the only act
+        still owed. `request_reviews` is skipped entirely when every
+        configured reviewer is already on the PR -- re-requesting an
+        already-requested reviewer is a no-op on GitHub, but it must not be
+        recorded as a fresh request -- and requests only the missing ones
+        otherwise. Both ledger rows still land, so the once-per-(PR, head)
+        guarantee and `_owes_orphan_handoff` keep holding on this shape.
+
         The activity line comes LAST and stays best-effort: it is telemetry
         about acts that have already happened, and it is written as a NON-SPAWN
         context because no session exists for it to claim a lane on behalf of.
         """
-        reviewers = self.config.reviewers
-        log.warning(
-            "ORPHAN DRAFT %s (%s): head %s has been public %.0f min, no "
-            "reviewer is requested, and no worker session for this PR is "
-            "listed — the session that opened it died before handing it off; "
-            "marking it ready and requesting %s mechanically (once per "
-            "PR/head)",
-            pr.pr_slug,
-            task_ref,
-            pr.head_sha[:8],
-            waited / 60,
-            ", ".join(reviewers),
-        )
+        already, missing = self._orphan_reviewers_split(pr)
+        if already:
+            log.warning(
+                "ORPHAN DRAFT %s (%s): head %s has been public %.0f min, %s "
+                "already requested on it, and no worker session for this PR "
+                "is listed — the session that opened it died after its "
+                "review request but before flipping it ready (a request on a "
+                "draft arms nothing); marking it ready mechanically%s (once "
+                "per PR/head)",
+                pr.pr_slug,
+                task_ref,
+                pr.head_sha[:8],
+                waited / 60,
+                ", ".join(already),
+                f" and requesting {', '.join(missing)}" if missing else "",
+            )
+        else:
+            log.warning(
+                "ORPHAN DRAFT %s (%s): head %s has been public %.0f min, no "
+                "reviewer is requested, and no worker session for this PR is "
+                "listed — the session that opened it died before handing it "
+                "off; marking it ready and requesting %s mechanically (once "
+                "per PR/head)",
+                pr.pr_slug,
+                task_ref,
+                pr.head_sha[:8],
+                waited / 60,
+                ", ".join(missing),
+            )
 
         if self.config.dry_run:
+            request = (
+                f"request {', '.join(missing)}"
+                if missing
+                else f"request nobody ({', '.join(already)} already requested)"
+            )
             log.info(
-                "[dry-run] would mark %s ready and request review from %s",
-                pr.pr_slug,
-                ", ".join(reviewers),
+                "[dry-run] would mark %s ready and %s", pr.pr_slug, request
             )
             return Decision(
                 Action.IN_FLIGHT,
                 f"[dry-run] would mechanically hand off draft head "
                 f"{pr.head_sha[:8]} (public {int(waited / 60)} min, its "
-                f"session gone): mark ready + request "
-                f"{', '.join(reviewers)}",
+                f"session gone): mark ready + {request}",
                 task_ref=task_ref,
             )
 
@@ -4863,6 +5044,28 @@ class DevWatcher:
 
         return self._request_orphan_reviewers(pr, task_ref, waited)
 
+    def _orphan_reviewers_split(
+        self, pr: PullRequest
+    ) -> "tuple[tuple[str, ...], tuple[str, ...]]":
+        """The configured reviewers, split by what the PR already carries:
+        (already requested, still missing), each in config order.
+
+        Casefolded like `_reviewer_reviews`: the configured set is
+        operator-typed and GitHub logins are case-insensitive, so `Alissa-App`
+        in the config and `alissa-app` on the PR are one reviewer, not a
+        missing one. Stated once because the sweep and the completion path
+        both need exactly this answer -- the request must never name a
+        reviewer who is already on the PR (a no-op on GitHub that would still
+        be recorded, and logged, as a fresh request)."""
+        on_pr = {r.casefold() for r in pr.requested_reviewers}
+        already = tuple(
+            r for r in self.config.reviewers if r.casefold() in on_pr
+        )
+        missing = tuple(
+            r for r in self.config.reviewers if r.casefold() not in on_pr
+        )
+        return already, missing
+
     def _owes_orphan_handoff(self, pr: PullRequest) -> bool:
         """Did THIS daemon ready this exact head and still owe it a reviewer?
 
@@ -4904,6 +5107,14 @@ class DevWatcher:
         entitled to finish its own handoff). Not re-run is the grace window --
         it was satisfied when the flip fired, and the head has not moved since
         (a moved head would be a different key with no ready row at all).
+
+        Reached only for a PR with NO pending request (evaluate_pr's own
+        guard sits above this). So a draft that already carried a reviewer
+        can never arrive here: it left draft carrying that reviewer, and the
+        pending-request guard reads it as in review. That is why
+        `_request_orphan_reviewers` never leaves that shape half-recorded --
+        a failed request for the MISSING reviewers there is given up on and
+        the handoff completed on the spot (round-1 review fix, PR #114).
         """
         if not self._owes_orphan_handoff(pr) or not self.config.reviewers:
             return None
@@ -4952,43 +5163,73 @@ class DevWatcher:
         this is the completion path (where that number is a poll or more old
         and would be reported as fact).
 
-        Failure handling mirrors `_rerequest_review`'s exactly: a
-        ReviewRequestRejected is permanent and operator-fixable (escalate,
-        don't retry, and never record the DONE marker); a CommandError is
-        transient (record nothing, retry next poll). The READY row stays in
-        both cases -- the flip really did happen, and re-flipping an
-        already-ready PR is not what the retry needs to do."""
-        reviewers = self.config.reviewers
-        try:
-            landed = self.github.request_reviews(
-                pr.owner, pr.repo, pr.number, reviewers
-            )
-        except ReviewRequestRejected as exc:
-            return self._escalate_orphan_rejected(pr, task_ref, exc)
-        except CommandError as exc:
-            log.error(
-                "could not request review from %s on %s: %s — NOT recording "
-                "the handoff; the sweep retries next poll",
-                ", ".join(reviewers),
-                pr.pr_slug,
-                exc,
-            )
-            return Decision(
-                Action.SKIPPED,
-                f"the PR was marked ready but the review request did not land "
-                f"({exc}) — transient; not recorded, retrying next poll",
-                task_ref=task_ref,
-            )
+        Only the configured reviewers NOT already on the PR are requested
+        (`_orphan_reviewers_split`, issue #113). When every one of them is
+        already requested -- the draft the session put a reviewer on before
+        dying, or a completion-path PR someone requested by hand between
+        polls -- no call is made at all: the DONE marker lands, the activity
+        line says who was already there, and the reviewer daemon already sees
+        the PR.
+
+        Failure handling on the review-less shape mirrors
+        `_rerequest_review`'s exactly: a ReviewRequestRejected is permanent
+        and operator-fixable (escalate, don't retry, and never record the
+        DONE marker); a CommandError is transient (record nothing, retry next
+        poll). The READY row stays in both cases -- the flip really did
+        happen, and re-flipping an already-ready PR is not what the retry
+        needs to do.
+
+        On the PARTIAL shape -- some configured reviewers already on the PR,
+        the call carrying only the missing rest -- neither doctrine applies
+        (round-1 review fix, PR #114). `request_reviews` raises only when
+        nothing in THAT call landed, which here does not mean nobody is on
+        the PR: the flip landed and `already` is requested, so the PR is in
+        review and the reviewer daemon sees it. The refusal page would be
+        false ("never marked ready or sent to a reviewer"), and a retry is
+        structurally impossible: next poll the pending-request guard in
+        evaluate_pr reads the PR as in review before `_finish_orphan_handoff`
+        is reached, so a ready row left down would stick on that head
+        forever. So a failed request for the missing subset, permanent or
+        transient, is logged as given up on -- naming who IS on the PR --
+        and the handoff is completed: DONE row, activity line."""
+        already, missing = self._orphan_reviewers_split(pr)
+        landed: tuple[str, ...] = ()
+        if missing:
+            try:
+                landed = self.github.request_reviews(
+                    pr.owner, pr.repo, pr.number, missing
+                )
+            except ReviewRequestRejected as exc:
+                if not already:
+                    return self._escalate_orphan_rejected(pr, task_ref, exc)
+                self._log_orphan_reviewers_given_up(pr, missing, already, exc)
+            except CommandError as exc:
+                if not already:
+                    log.error(
+                        "could not request review from %s on %s: %s — NOT "
+                        "recording the handoff; the sweep retries next poll",
+                        ", ".join(missing),
+                        pr.pr_slug,
+                        exc,
+                    )
+                    return Decision(
+                        Action.SKIPPED,
+                        f"the PR was marked ready but the review request "
+                        f"did not land ({exc}) — transient; not recorded, "
+                        f"retrying next poll",
+                        task_ref=task_ref,
+                    )
+                self._log_orphan_reviewers_given_up(pr, missing, already, exc)
 
-        dropped = tuple(r for r in reviewers if r not in landed)
-        if dropped:
-            log.warning(
-                "%s: GitHub silently dropped reviewer(s) %s from the "
-                "mechanical handoff; %s landed, so the PR IS in review",
-                pr.pr_slug,
-                ", ".join(dropped),
-                ", ".join(landed),
-            )
+            dropped = tuple(r for r in missing if r not in landed)
+            if dropped and landed:
+                log.warning(
+                    "%s: GitHub silently dropped reviewer(s) %s from the "
+                    "mechanical handoff; %s landed, so the PR IS in review",
+                    pr.pr_slug,
+                    ", ".join(dropped),
+                    ", ".join(landed + already),
+                )
 
         self.state.record_escalation(
             pr.full_name, pr.number, orphan_kind(pr.head_sha)
@@ -4998,6 +5239,23 @@ class DevWatcher:
             if waited is not None
             else ""
         )
+        if landed and already:
+            acted = (
+                f"marked ready and requested review from {', '.join(landed)} "
+                f"({', '.join(already)} already requested)"
+            )
+            died = "before handing it off"
+        elif landed:
+            acted = f"marked ready and requested review from {', '.join(landed)}"
+            died = "before handing it off"
+        else:
+            noun = "reviewer" if len(already) == 1 else "reviewers"
+            verb = "was" if len(already) == 1 else "were"
+            acted = (
+                f"marked ready ({noun} {', '.join(already)} {verb} already "
+                f"requested)"
+            )
+            died = "before flipping it"
         self._append_activity(
             pr.owner,
             pr.repo,
@@ -5005,22 +5263,51 @@ class DevWatcher:
             self._activity_line(
                 orphan_activity_lane(pr),
                 "orphan sweep",
-                f"{ACTIVITY_HANDED_OFF} — marked ready and requested review "
-                f"from {', '.join(landed)}; the session that opened this draft "
-                f"died before handing it off{age}, so the daemon completed its "
-                f"protocol (no session spawned, once per PR/head)",
+                f"{ACTIVITY_HANDED_OFF} — {acted}; the session that opened "
+                f"this draft died {died}, so the daemon completed its "
+                f"protocol{age} (no session spawned, once per PR/head)",
             ),
             pr.pr_slug,
         )
 
+        if landed:
+            requested = f"and review requested from {', '.join(landed)}"
+        else:
+            requested = (
+                f"(review already requested from {', '.join(already)}, no "
+                f"new request made)"
+            )
         return Decision(
             Action.IN_FLIGHT,
-            f"orphaned draft handed off — marked ready and review requested "
-            f"from {', '.join(landed)} for head {pr.head_sha[:8]}; the ball is "
-            f"in the reviewer's court",
+            f"orphaned draft handed off — marked ready {requested} for head "
+            f"{pr.head_sha[:8]}; the ball is in the reviewer's court",
             task_ref=task_ref,
         )
 
+    @staticmethod
+    def _log_orphan_reviewers_given_up(
+        pr: PullRequest,
+        missing: "tuple[str, ...]",
+        already: "tuple[str, ...]",
+        exc: Exception,
+    ) -> None:
+        """The partial shape's one failure path (see
+        `_request_orphan_reviewers`): the request for the configured
+        reviewers NOT yet on the PR failed, `already` IS on it, and no retry
+        can ever reach this PR again -- so the missing reviewers are given up
+        on, out loud, and the handoff completes with who is there."""
+        log.warning(
+            "%s: could not request review from %s on the mechanical handoff "
+            "(%s) — giving up on them: %s already requested and the PR is out "
+            "of draft, so it IS in review; the daemon will not retry (the "
+            "pending request reads as in review from here on), request them "
+            "by hand if wanted",
+            pr.pr_slug,
+            ", ".join(missing),
+            exc,
+            ", ".join(already),
+        )
+
     def _escalate_orphan_rejected(
         self, pr: PullRequest, task_ref: "str | None", exc: Exception
     ) -> Decision:
@@ -5256,28 +5543,92 @@ class DevWatcher:
 
     def _foreign_head_skip(self, pr: PullRequest, attempt: int) -> "Decision | None":
         """The head-ref shape guard for the PR-side edges that evaluate ONE
-        PR (fix and maintain): this daemon only ever creates flat
-        `TASK-<n>-<DESC>` branches, so a ref outside DAEMON_HEAD_REF is not
-        its work. Returns the SKIPPED Decision, or None when the ref is safe
-        to interpolate. (The issue edge's resume applies the same shape test
-        via `_resumable_pr`, which filters candidates rather than skipping
-        the item.)"""
-        if DAEMON_HEAD_REF.fullmatch(pr.head_ref):
+        PR (fix and maintain): this daemon's workers create flat
+        `TASK-<n>-<DESC>` branches -- or, tolerated since issue #115, the
+        same behind exactly one `task/` -- so a ref outside WORKER_HEAD_REF
+        is not its work. Returns the SKIPPED Decision, or None when the ref
+        is safe to interpolate (as `worktree_dir(head_ref)` + `head_ref`).
+        (The issue edge's resume applies the same shape test via
+        `_resumable_pr`, which filters candidates rather than skipping the
+        item.)
+
+        A skip is PAGED on the PR, once per (PR, head) -- `_page_foreign_head`
+        -- rather than logged at WARNING every poll: the skip is a standing
+        condition nothing else in the system will ever surface (no session is
+        spawned, so no activity line; the reviewer daemon has done its part),
+        and the 2026-09-09/10 incident measured the cost of a log-only signal
+        at 1-12 h per PR. The decision itself is unchanged by the page.
+        """
+        if WORKER_HEAD_REF.fullmatch(pr.head_ref):
             return None
-        log.warning(
-            "%s head ref %r does not match the daemon's own branch shape "
-            "— not spawning a worker session on a foreign-shaped branch",
-            pr.pr_slug,
-            pr.head_ref,
-        )
+        self._page_foreign_head(pr)
         return Decision(
             Action.SKIPPED,
             f"head ref {pr.head_ref!r} does not match the daemon's own "
-            f"branch shape ([A-Za-z0-9._-]+) — foreign-shaped branch, "
-            f"not this daemon's work",
+            f"branch shape (TASK-<n>-<DESC>, or task/ + that) — "
+            f"foreign-shaped branch, not this daemon's work",
             attempt,
         )
 
+    def _page_foreign_head(self, pr: PullRequest) -> bool:
+        """Page the operator ONCE per (PR, head) that the head-ref guard is
+        skipping this PR, on the PR. Returns whether the page was raised.
+
+        `_check_stacked_base`'s doctrine: advisory by construction (the guard
+        still skips; nothing renames or closes anything), and the row lands
+        only AFTER the comment posts, so a transient POST failure retries next
+        poll rather than being recorded as delivered. Dry-run logs and records
+        nothing. Every poll after the first sees the row and logs at DEBUG --
+        the per-poll WARNING this replaces was the silence the incident hid
+        behind. A head with no readable sha cannot be keyed and keeps the
+        per-poll WARNING instead of paging (only reachable from a malformed
+        payload).
+        """
+        if not pr.head_sha:
+            log.warning(
+                "%s head ref %r does not match the daemon's own branch shape "
+                "— not spawning a worker session on a foreign-shaped branch "
+                "(no head sha to key a page on)",
+                pr.pr_slug,
+                pr.head_ref,
+            )
+            return False
+        kind = foreign_head_kind(pr.head_sha)
+        if self.state.escalated(pr.full_name, pr.number, kind):
+            log.debug(
+                "%s head ref %r is foreign-shaped — skipped (already paged "
+                "on head %s)",
+                pr.pr_slug,
+                pr.head_ref,
+                pr.head_sha[:8],
+            )
+            return False
+
+        log.error(
+            "FOREIGN HEAD %s: head ref %r does not match the daemon's own "
+            "branch shape — no fix or maintain round will spawn on it; "
+            "paging the operator on the PR once for head %s",
+            pr.pr_slug,
+            pr.head_ref,
+            pr.head_sha[:8],
+        )
+        body = FOREIGN_HEAD_COMMENT.format(head_ref=pr.head_ref)
+        if self.config.dry_run:
+            log.info("[dry-run] would comment on %s:\n%s", pr.pr_slug, body)
+            return False
+        try:
+            self.github.comment(pr.owner, pr.repo, pr.number, body)
+        except CommandError as exc:
+            log.error(
+                "could not post the foreign-head comment on %s: %s — not "
+                "recording the page; it retries next poll",
+                pr.pr_slug,
+                exc,
+            )
+            return False
+        self.state.record_escalation(pr.full_name, pr.number, kind)
+        return True
+
     def _spawn_fix(
         self,
         pr: PullRequest,
@@ -5354,6 +5705,7 @@ class DevWatcher:
             attempt=attempt,
             cap=self.config.attempt_cap,
             head_ref=pr.head_ref,
+            worktree_dir=worktree_dir(pr.head_ref),
             # Re-request the reviewer whose request_changes this round
             # answers -- precise, and always resolvable (the review exists).
             reviewer=review.author,
@@ -5613,6 +5965,7 @@ class DevWatcher:
             attempt=attempt,
             cap=self.config.attempt_cap,
             head_ref=pr.head_ref,
+            worktree_dir=worktree_dir(pr.head_ref),
             reviewers=reviewers,
             session=name,
         )

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

@@ -0,0 +1 @@
+0.8.20

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

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

@@ -1 +0,0 @@
-0.8.18