CUST-WP-0074-T02 follow-up: blocked_on / wait_until reach the hub read model

Migration f9a0b1c2d3e4 (revises e8f9a0b1c2d3) adds tasks.blocked_on
(String 200) and tasks.wait_until (Date); TaskCreate/Update/Read carry both.

Read model (api/services/wait_kind.py): a wait task is external when it has
a dependency edge, a blocked_on matching ^message-from: (rule 6), or a
wait_until date (a window clears by itself). human/both/unqualified and
blocked_kind are unchanged in shape.

fix-consistency: _task_wait_fields carries blocked_on and wait_until (ISO
date, PyYAML date objects normalised), so the C-06/C-11 creates and the
C-10 status PATCH send them, and C-41 compares and syncs them like the
other qualifiers. C-39 accepts wait_until: YYYY-MM-DD as a qualifier; C-40
also fires when wait_until is before UTC today (report only).

/state/deps: depends_on stubs gain from_task_id / from_task_title so
consumers see task-scoped edges; both optional, response otherwise as before.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Assistant: claude-code
Assistant-Model: sonnet
Assistant-Process: 237582@bnt-lap001
Assistant-Session: f2b3d9f1-8fb9-4b9c-bc2b-837ec5dfc826

api/services/wait_kind.py

@@ -1,16 +1,20 @@
 """Derived wait qualifiers (CUST-WP-0074 rule 5) — read model only.
 
 A ``wait`` task is *external* when it carries at least one dependency edge
-(``workplan_dependencies.from_task_id``), *human* when ``needs_human`` is set,
-*both* when both hold and *unqualified* otherwise. A ``blocked`` workplan is
+(``workplan_dependencies.from_task_id``), an owner-return marker
+(``blocked_on: message-from:<agent>``, rule 6) or a ``wait_until`` date (a
+time window clears by itself); *human* when ``needs_human`` is set, *both*
+when both hold and *unqualified* otherwise. A ``blocked`` workplan is
 *human* when any of its wait tasks is human or both, else *external* when any
 is external, else *none*. Nothing here is stored; the routers call the
 ``annotate_*`` helpers and Pydantic picks the attributes up on serialisation.
 """
 from __future__ import annotations
 
+import re
 import uuid
 from collections.abc import Iterable, Sequence
+from datetime import date
 from typing import Any
 
 from sqlalchemy import select
@@ -31,16 +35,41 @@ BLOCKED_KIND_EXTERNAL = "external"
 BLOCKED_KIND_HUMAN = "human"
 BLOCKED_KIND_NONE = "none"
 
+# Rule 6 owner-return marker; mirrors _BLOCKED_ON_RE in scripts/consistency_check.py.
+MESSAGE_FROM_RE = re.compile(r"^message-from:.+$")
 
-def derive_wait_kind(status: Any, *, needs_human: bool, has_dependency: bool) -> str | None:
+
+def is_external_wait(
+    *,
+    has_dependency: bool,
+    blocked_on: str | None = None,
+    wait_until: date | None = None,
+) -> bool:
+    """Case A holds for a dependency edge, an owner-return marker or a wait window."""
+    if has_dependency or wait_until is not None:
+        return True
+    return bool(blocked_on and MESSAGE_FROM_RE.match(blocked_on.strip()))
+
+
+def derive_wait_kind(
+    status: Any,
+    *,
+    needs_human: bool,
+    has_dependency: bool,
+    blocked_on: str | None = None,
+    wait_until: date | None = None,
+) -> str | None:
     """Rule 1 / rule 5 for one task. ``None`` unless the task is waiting."""
     if normalize_task_status(status, default="todo") != "wait":
         return None
-    if has_dependency and needs_human:
+    external = is_external_wait(
+        has_dependency=has_dependency, blocked_on=blocked_on, wait_until=wait_until
+    )
+    if external and needs_human:
         return WAIT_KIND_BOTH
     if needs_human:
         return WAIT_KIND_HUMAN
-    if has_dependency:
+    if external:
         return WAIT_KIND_EXTERNAL
     return WAIT_KIND_UNQUALIFIED
 
@@ -79,6 +108,8 @@ async def annotate_tasks(session: AsyncSession, tasks: Sequence[Task]) -> Sequen
             task.status,
             needs_human=bool(task.needs_human),
             has_dependency=task.id in with_deps,
+            blocked_on=task.blocked_on,
+            wait_until=task.wait_until,
         )
     return tasks