@maudecode/talaria-web 1.17.2 → 1.19.0

package/sidecar/talaria_sidecar/methods/process.py

@@ -8,12 +8,13 @@ import json
 import logging
 import queue
 import sqlite3
+import threading
 import time
 from contextlib import closing
 from pathlib import Path
 
 from ..errors import InvalidParams, RpcError
-from ..home import profile_home_param, scoped_home
+from ..home import _PROCESS_HOME, _is_named_profile, profile_home_param, scoped_home
 from ..rpc import CallContext
 
 log = logging.getLogger("talaria_sidecar.process")
@@ -27,11 +28,23 @@ def _registry():
     return process_registry
 
 
+def _is_child_process(row: dict) -> bool:
+    """TAL-933: a subagent's own process notice, which the server surfaces only when the owning profile opts in."""
+    try:
+        from tools.process_registry_notifications import is_child_process_notification
+    except Exception:  # noqa: BLE001 - before Agent 0.21.7, the same rule inline
+        if row.get("type") in ("async_delegation", "async_delegation_work_closeout"):
+            return False
+        return str(row.get("owner_task_id") or row.get("task_id") or "").startswith("sa-")
+    return bool(is_child_process_notification(row))
+
+
 def _event_row(evt: dict) -> dict:
     registry = _registry()
     row = {str(k): v for k, v in evt.items()} if isinstance(evt, dict) else {}
     process_id = str(row.get("delegation_id") or row.get("session_id") or row.get("task_id") or "") if row.get("type") == "async_delegation" else str(row.get("session_id") or "")
     row["process_id"] = process_id
+    row["child_process"] = _is_child_process(row)
     if registry is not None and process_id and (not row.get("session_key") or not row.get("origin_ui_session_id")):
         try:
             proc = registry.get(process_id)
@@ -42,26 +55,186 @@ def _event_row(evt: dict) -> dict:
             if not row.get("origin_ui_session_id"):
                 row["origin_ui_session_id"] = str(getattr(proc, "origin_ui_session_id", "") or "") or str(getattr(proc, "spawn_session_id", "") or "")
     try:
-        row["consumed"] = bool(registry is not None and process_id and row.get("type") != "async_delegation" and registry.is_completion_consumed(process_id))
+        # Only the exit is consumed by the agent's wait or poll; a watch notice from the same process still wakes (TAL-724).
+        row["consumed"] = bool(registry is not None and process_id and row.get("type") in (None, "completion") and registry.is_completion_consumed(process_id))
     except Exception:  # noqa: BLE001
         row["consumed"] = False
     return row
 
 
+# Recovered sessions, held so their exit is seen even when an Agent call other than drain prunes them first.
+_RECOVERED: dict[str, object] = {}
+_RECOVERED_LOCK = threading.Lock()
+
+
+def _reports_recovered_exits(registry) -> bool:
+    """Agent 0.21.6 (hermes-agent 7550800d) closes or prunes a recovered session whose PID is gone without queuing a
+    completion, since it never collected an exit status. Talaria still wakes the session with an unknown exit code."""
+    return callable(getattr(registry, "_detached_host_fate", None)) and callable(getattr(registry, "_publish_finished", None))
+
+
+def track_recovered(registry) -> None:
+    if not _reports_recovered_exits(registry):
+        return
+    try:
+        with registry._lock:
+            detached = [s for s in registry._running.values() if getattr(s, "detached", False)]
+    except Exception:  # noqa: BLE001 - recovery itself succeeded; only the exit report is lost
+        log.warning("Failed to track recovered processes", exc_info=True)
+        return
+    with _RECOVERED_LOCK:
+        _RECOVERED.update((s.id, s) for s in detached)
+
+
+def _publish_recovered_exits(registry) -> None:
+    with _RECOVERED_LOCK:
+        exited = [s for s in _RECOVERED.values() if s.exited]
+        for session in exited:
+            del _RECOVERED[session.id]
+    for session in exited:
+        # A kill (or any path that collected a status) already queued its own completion through _move_to_finished.
+        if session.exit_code is not None or getattr(session, "_finish_claimed", False):
+            continue
+        try:
+            # Best effort, as in the Agent: a durable result must not block the live completion.
+            from tools.process_registry_results import save_completed_result
+
+            save_completed_result(session)
+        except Exception:  # noqa: BLE001
+            log.debug("Failed to retain the result of recovered process %s", session.id, exc_info=True)
+        try:
+            with registry._lock:
+                registry._running.pop(session.id, None)
+                session.exited_at = session.exited_at or time.time()
+                registry._finished[session.id] = session
+            registry._publish_finished(session, True)
+        except Exception:  # noqa: BLE001 - retried on the next drain
+            log.warning("Failed to report the exit of recovered process %s", session.id, exc_info=True)
+            with _RECOVERED_LOCK:
+                _RECOVERED.setdefault(session.id, session)
+
+
+_COMPLETION_BASE_HOME: Path | None = None
+_RESTORED_COMPLETION_HOMES: set[Path] = set()
+
+
+def _completion_homes() -> list[Path]:
+    from hermes_constants import get_hermes_home
+    from .profiles import named_profile_homes
+
+    homes = [_PROCESS_HOME, Path(get_hermes_home())]
+    if _COMPLETION_BASE_HOME is not None:
+        # The server drains one global queue. Re-enumerate so new profiles join and removed/escaped ones leave.
+        homes += [_COMPLETION_BASE_HOME, *(home for _, home in named_profile_homes(_COMPLETION_BASE_HOME))]
+    return list(dict.fromkeys(home.resolve() for home in homes))
+
+
+def _restore_and_sweep_completions(registry) -> None:
+    from tools import async_delegation
+
+    restore = getattr(registry, "restore_completions", None)
+    if not callable(restore):
+        return  # Older Agents already restore at registry import and have no orphan sweep.
+    # The Agent binds the launch home itself, even when the first drain is in a named profile.
+    restore()
+    for home in _completion_homes():
+        try:
+            with scoped_home(home):
+                if _is_named_profile(home) and home not in _RESTORED_COMPLETION_HOMES:
+                    async_delegation.restore_undelivered_completions(registry.completion_queue)
+                    _RESTORED_COMPLETION_HOMES.add(home)
+                sweep = getattr(async_delegation, "maybe_sweep_orphaned_completions", None)
+                if callable(sweep):
+                    sweep(registry.completion_queue)
+        except Exception:  # noqa: BLE001 - retry this home without blocking other profiles or queued events
+            log.debug("Failed to restore or sweep delegation completions for %s", home, exc_info=True)
+
+
+_DELIVERY_RECONCILE_INTERVAL_S = 30
+_LAST_DELIVERY_RECONCILE: dict[Path, float] = {}
+_DELIVERY_RECONCILE_CURSOR: dict[Path, str] = {}
+_DELIVERY_RECONCILE_PAGE_SIZE = 200
+
+
+def _delivered_notifications(home: Path, delegation_id: str | None = None, after: str = "") -> tuple[list[dict], str]:
+    """Only typed transcript deliveries, never every delivered ledger row. No Agent state is changed."""
+    db_path = home / "state.db"
+    if not db_path.exists():
+        return [], ""
+    with closing(sqlite3.connect(f"{db_path.resolve().as_uri()}?mode=ro", uri=True, timeout=5)) as conn:
+        tables = {r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")}
+        if not {"async_delegations", "messages", "sessions"} <= tables:
+            return [], ""
+        rows = conn.execute("""WITH RECURSIVE candidates AS (
+            SELECT delegation_id, origin_ui_session_id, parent_session_id, origin_session_id, event_json
+            FROM async_delegations WHERE delivery_state='delivered' AND state NOT IN ('running','finalizing')
+            AND event_json IS NOT NULL AND origin_ui_session_id != '' AND delivered_at >= ?
+            AND (? IS NULL OR delegation_id=?) AND delegation_id > ?
+        ), lineage(delegation_id, id) AS (
+            SELECT delegation_id, parent_session_id FROM candidates WHERE parent_session_id != ''
+            UNION SELECT delegation_id, origin_session_id FROM candidates WHERE origin_session_id != ''
+            UNION SELECT l.delegation_id, s.id FROM lineage l
+                JOIN sessions parent ON parent.id=l.id AND parent.end_reason='compression'
+                JOIN sessions s ON s.parent_session_id=l.id
+        ) SELECT DISTINCT c.delegation_id, c.origin_ui_session_id, c.event_json
+        FROM candidates c JOIN lineage l ON l.delegation_id=c.delegation_id
+        JOIN messages m ON m.session_id=l.id
+        WHERE m.role='user' AND m.display_kind='async_delegation_complete'
+        AND json_valid(m.display_metadata)
+        AND json_extract(m.display_metadata, '$.delegation_id')=c.delegation_id
+        AND coalesce(json_extract(m.display_metadata, '$.delivery_notice'), '')=''
+        AND coalesce(json_extract(m.display_metadata, '$.presentation_suppressed'), 0)=0
+        ORDER BY c.delegation_id LIMIT ?""", (time.time() - 48 * 3600, delegation_id, delegation_id, after, _DELIVERY_RECONCILE_PAGE_SIZE)).fetchall()
+    events = []
+    for did, owner, payload in rows:
+        event = _json(payload)
+        if event.get("type") != "async_delegation" or event.get("delegation_id") != did or event.get("origin_ui_session_id") != owner or event.get("task_failure_notice"):
+            continue
+        events.append({**event, "reconciliation_profile_home": str(home.resolve())})
+    return events, rows[-1][0] if len(rows) == _DELIVERY_RECONCILE_PAGE_SIZE else ""
+
+
+def _reconcile_delivered_notifications() -> list[dict]:
+    out = []
+    for home in _completion_homes():
+        now = time.monotonic()
+        if now - _LAST_DELIVERY_RECONCILE.get(home, -float("inf")) < _DELIVERY_RECONCILE_INTERVAL_S:
+            continue
+        try:
+            events, cursor = _delivered_notifications(home, after=_DELIVERY_RECONCILE_CURSOR.get(home, ""))
+            out.extend(events)
+            _DELIVERY_RECONCILE_CURSOR[home] = cursor
+            _LAST_DELIVERY_RECONCILE[home] = now
+        except Exception:  # retry unreadable homes; never block live queue delivery
+            log.warning("Failed to reconcile typed delegation deliveries for %s", home, exc_info=True)
+    return out
+
+
 def drain(max_events: int) -> list[dict]:
     """Pop every queued completion event; the server requeues what it does not own."""
     registry = _registry()
     completion_queue = getattr(registry, "completion_queue", None) if registry is not None else None
     if completion_queue is None:
         return []
+    try:
+        _restore_and_sweep_completions(registry)
+    except Exception:  # noqa: BLE001 - maintenance must not prevent delivery of live queued events
+        log.debug("Failed to reconcile delegation completions", exc_info=True)
     try:
         # A recovered process has no reader thread; only this probe notices its exit and queues its completion (TAL-533).
         with registry._lock:
             detached = [s for s in registry._running.values() if getattr(s, "detached", False)]
         for session in detached:
             registry._refresh_detached_session(session)
+        _publish_recovered_exits(registry)
     except Exception:  # noqa: BLE001
         log.debug("Failed to reconcile recovered processes", exc_info=True)
+    # Use the existing queue and its bound, so reconciliation cannot starve live or foreign events.
+    try:
+        for event in _reconcile_delivered_notifications():
+            completion_queue.put_nowait(event)
+    except Exception:
+        log.warning("Failed to offer typed delegation deliveries", exc_info=True)
     out = []
     while len(out) < max_events:
         try:
@@ -83,7 +256,7 @@ def requeue(events: list[dict]) -> int:
     count = 0
     for evt in events:
         try:
-            completion_queue.put_nowait({k: v for k, v in evt.items() if k not in ("process_id", "consumed")})
+            completion_queue.put_nowait({k: v for k, v in evt.items() if k not in ("process_id", "consumed", "child_process")})
             count += 1
         except Exception:  # noqa: BLE001
             log.debug("Failed to requeue process completion", exc_info=True)
@@ -141,6 +314,15 @@ def claim_delivery(evt: dict, consumer: str) -> str | None:
     if api is None:
         return ""
     claim_id = api.claim_event_delivery(_ledger_event(evt), consumer)
+    if claim_id is None and consumer == "webui" and evt.get("origin_ui_session_id"):
+        from hermes_constants import get_hermes_home
+        home = Path(get_hermes_home()).resolve()
+        if evt.get("reconciliation_profile_home", str(home)) == str(home):
+            # A live queue copy can race the transcript-only consumer too. Recheck the same proof here.
+            transport = {"process_id", "consumed", "child_process", "restored", "reconciliation_profile_home"}
+            for candidate in _delivered_notifications(home, str(evt.get("delegation_id") or ""))[0]:
+                if {k: v for k, v in candidate.items() if k not in transport} == {k: v for k, v in evt.items() if k not in transport}:
+                    return ""  # Web's session receipt acknowledges this admission, not the Agent ledger.
     return None if claim_id is None else str(claim_id)
 
 
@@ -175,11 +357,14 @@ def defer_delivery(evt: dict, claim_id: str) -> bool:
 
 
 def format_notification(evt: dict) -> str:
-    if evt.get("type") == "async_delegation":
+    if evt.get("type") in ("async_delegation", "heartbeat", "watch_match", "watch_disabled", "watch_overflow_tripped", "watch_overflow_released"):
         try:
-            from tools.process_registry import format_process_notification
+            from tools import process_registry
 
-            return format_process_notification(evt) or ""
+            # Older formatters fall through unknown events to an exit notification.
+            if evt.get("type") == "heartbeat" and not callable(getattr(getattr(process_registry, "ProcessRegistry", None), "_emit_heartbeat", None)):
+                return ""
+            return process_registry.format_process_notification(evt) or ""
         except Exception:  # noqa: BLE001
             return ""
     if evt.get("type") != "completion":
@@ -349,12 +534,21 @@ def _goal_text(content) -> str:
         return ""
     if content.startswith(_CONTENT_JSON_PREFIX):
         try:
-            parts = json.loads(content[len(_CONTENT_JSON_PREFIX):])
-        except ValueError:
-            return ""
-        texts = [p.get("text") for p in parts if isinstance(p, dict) and p.get("type") == "text"] if isinstance(parts, list) else []
+            from hermes_state import SessionDB
+            decode = getattr(SessionDB, "_decode_content", None)
+        except ImportError:
+            decode = None
+        if callable(decode):
+            content = decode(content)
+        else:
+            try:
+                content = json.loads(content[len(_CONTENT_JSON_PREFIX):])
+            except ValueError:
+                pass  # Legacy malformed marker rows remain literal text, as in the Agent.
+    if isinstance(content, list):
+        texts = [p.get("text") for p in content if isinstance(p, dict) and p.get("type") == "text"]
         return str(texts[0]) if texts and texts[0] else ""
-    return content.split(_IMAGE_HINTS, 1)[0]
+    return content.split(_IMAGE_HINTS, 1)[0] if isinstance(content, str) else ""
 
 
 def unit_children(unit: dict, owner: str, live: list[dict], finished: list[dict], now: float) -> list[dict]:
@@ -415,10 +609,11 @@ def recover(base_home: Path) -> int:
     """TAL-533: re-adopt every profile's checkpointed processes when a sidecar starts, so a process in a profile nobody
     uses yet is watched (and its exit reported) from the start. Entering a home's scope recovers it once; a failed
     recovery fails the call, so the server retries."""
-    from hermes_cli.profiles import _PROFILE_ID_RE
+    from .profiles import named_profile_homes
 
-    profiles_root = base_home / "profiles"
-    named = sorted(p for p in profiles_root.iterdir() if p.is_dir() and _PROFILE_ID_RE.match(p.name)) if profiles_root.is_dir() else []
+    global _COMPLETION_BASE_HOME
+    _COMPLETION_BASE_HOME = base_home
+    named = [home for _, home in named_profile_homes(base_home)]
     failed = []
     for home in [base_home, *named]:
         try:
@@ -479,7 +674,15 @@ def register(registry_) -> None:
         if not consumer:
             raise InvalidParams("consumer is required")
         with scoped_home(profile_home_param(params)):
-            return {"claim_id": claim_delivery(evt, consumer)}
+            claim = claim_delivery(evt, consumer)
+            result = {"claim_id": claim}
+            if claim is None:
+                api = _delivery_api()
+                lookup = getattr(api, "get_durable_delegation", None)
+                row = lookup(str(evt.get("delegation_id") or "")) if callable(lookup) else None
+                if row and row.get("delivery_state") == "pending":
+                    result["retryable"] = True
+            return result
 
     @registry_.method("process.complete_delivery")
     def complete_(ctx: CallContext, params: dict) -> dict:

package/sidecar/talaria_sidecar/methods/profiles.py

@@ -24,6 +24,9 @@ log = logging.getLogger("talaria_sidecar.profiles")
 _PROFILE_ID_RE = re.compile(r"[a-z0-9][a-z0-9_-]{0,63}")
 _PROFILE_DIRS = ("skills", "memories", "sessions", "logs", "cron")
 _CLONE_CONFIG_FILES = ("config.yaml", ".env", "SOUL.md")
+_AVATAR_EXTS = ("png", "jpg", "webp")
+# The Agent's ``INTERNAL_LISTING_SOURCES``: worker sessions are never a profile's conversation.
+_INTERNAL_SOURCES = ("kanban", "tool", "oneshot")
 _TERMINAL_ENV = {
     "backend": "TERMINAL_ENV", "env_type": "TERMINAL_ENV", "cwd": "TERMINAL_CWD", "timeout": "TERMINAL_TIMEOUT", "lifetime_seconds": "TERMINAL_LIFETIME_SECONDS",
     "modal_mode": "TERMINAL_MODAL_MODE", "docker_image": "TERMINAL_DOCKER_IMAGE", "docker_forward_env": "TERMINAL_DOCKER_FORWARD_ENV", "docker_env": "TERMINAL_DOCKER_ENV",
@@ -96,36 +99,141 @@ def _visible(profile_dir: Path) -> bool:
     return not (isinstance(data, dict) and data.get("visible") is False)
 
 
+def _bounded(value, limit: int) -> str:
+    """One printable line of at most ``limit`` characters; anything but a string reads as empty."""
+    if not isinstance(value, str):
+        return ""
+    text = " ".join("".join(c if c.isprintable() else " " for c in value).split())
+    return text if len(text) <= limit else text[: limit - 1].rstrip() + "\u2026"
+
+
+def bot_identity(home: Path) -> dict:
+    """The presentation-only Bot Mode identity from ``profile.yaml`` and ``assets/``; never the raw ``ui_meta``."""
+    meta = _yaml_load(home / "profile.yaml") or {}
+    ui_meta = meta.get("ui_meta") if isinstance(meta.get("ui_meta"), dict) else {}
+    bots = ui_meta.get("hermes-bots") if isinstance(ui_meta.get("hermes-bots"), dict) else {}
+    return {
+        # Bot Mode's roster name (``ui_meta['hermes-bots'].title``) wins over the profile's own display name.
+        "display_name": _bounded(bots.get("title"), 80) or _bounded(meta.get("display_name"), 80),
+        "description": _bounded(meta.get("description"), 280), "has_avatar": any((home / "assets" / f"avatar.{ext}").is_file() for ext in _AVATAR_EXTS),
+    }
+
+
+def canonical_bot_chat(home: Path) -> dict | None:
+    """The profile's canonical Bot Chat: its session titled exactly ``Bot Chat`` (Bot Mode's registry) and live
+    compression tip, read through a read-only handle. Missing, unreadable, archived, worker-owned, or an Agent
+    without Bot Mode answers None; the gateway's resurrection of accidental archives is a write and stays there."""
+    db_path = home / "state.db"
+    if not db_path.is_file():
+        return None
+    try:
+        from hermes_state import SessionDB
+
+        title = getattr(SessionDB, "CANONICAL_BOT_CHAT_TITLE", None)
+        if not title:
+            return None
+        db = SessionDB(db_path=db_path, read_only=True)
+    except Exception:  # noqa: BLE001
+        return None
+    try:
+        row = db.get_session_by_title(title)
+        if not row or row.get("title") != title or row.get("archived") or str(row.get("source") or "").strip().lower() in _INTERNAL_SOURCES:
+            return None
+        session_id = str(row["id"])
+        return {"session_id": session_id, "tip_session_id": str(db.get_compression_tip(session_id) or session_id)}
+    except Exception:  # noqa: BLE001
+        log.debug("canonical Bot Chat lookup failed for %s", db_path, exc_info=True)
+        return None
+    finally:
+        try:
+            db.close()
+        except Exception:  # noqa: BLE001
+            pass
+
+
+GATEWAY_RUNNING_MODES = ("own", "served")
+
+
+def gateway_mode(home: Path, name: str, is_default: bool) -> str:
+    """The profile's gateway under the host multiplexer (TAL-805): ``served`` by the live host gateway, ``own`` gateway
+    process, ``parked`` (``hermes -p X gateway stop`` left its marker and nothing runs; the marker records intent, so a
+    live ``--force`` gateway still counts, as in ``hermes -p X gateway status``), ``standalone`` (opted out of the host and
+    not running), else ``stopped``. The default profile is the host itself.
+    A helper the installed Agent lacks answers no, so an Agent without the multiplexer helpers reports ``own`` or
+    ``stopped``; a helper that fails answers no too, except the parked check, which fails closed to ``stopped``."""
+    from hermes_cli import profiles as agent
+
+    def probe(helper: str, arg) -> bool | None:
+        check = getattr(agent, helper, None)
+        if check is None:
+            return False
+        try:
+            return bool(check(arg))
+        except Exception:  # noqa: BLE001
+            log.debug("gateway mode probe %s failed for %s", helper, home, exc_info=True)
+            return None
+
+    def asks(helper: str, arg) -> bool:
+        return probe(helper, arg) is True
+
+    named = not is_default
+    parked = probe("profile_is_parked", home) if named else False
+    if parked is None:
+        return "stopped"
+    if named and asks("_served_by_running_multiplexer", name):
+        return "served"
+    if asks("_check_gateway_running", home):
+        return "own"
+    if parked:
+        return "parked"
+    if named and asks("profile_is_standalone", home):
+        return "standalone"
+    return "stopped"
+
+
 def _row(home: Path, name: str, is_default: bool) -> dict:
-    from hermes_cli.profiles import _check_gateway_running, _read_config_model
+    from hermes_cli.profiles import _read_config_model
 
     try:
         model, provider = _read_config_model(home)
     except Exception:  # noqa: BLE001
         model, provider = None, None
-    try:
-        gateway_running = bool(_check_gateway_running(home))
-    except Exception:  # noqa: BLE001
-        gateway_running = False
+    mode = gateway_mode(home, name, is_default)
     enabled, total = skills_stats(home)
     return {
-        "name": name, "path": str(home), "is_default": is_default, "gateway_running": gateway_running, "model": model, "provider": provider,
+        "name": name, "path": str(home), "is_default": is_default, "gateway_running": mode in GATEWAY_RUNNING_MODES, "gateway_mode": mode,
+        "model": model, "provider": provider,
         "has_env": (home / ".env").exists(), "visible": _visible(home), "skill_count": enabled, "enabled_skills": enabled, "total_skills": total,
+        **bot_identity(home), "canonical_session": canonical_bot_chat(home),
     }
 
 
-def list_profiles(base_home: Path) -> list[dict]:
-    """Profile rows for the base Hermes home: the root profile plus ``profiles/*``."""
+def named_profile_homes(base_home: Path) -> list[tuple[str, Path]]:
+    """(name, home) for the ``profiles/*`` directories named like profiles, skipping any that resolve outside the resolved
+    profiles root (a symlink leading elsewhere is never read as a profile; TAL-579). A contained symlink answers the
+    target it was checked against, so retargeting the link afterwards cannot redirect the caller."""
     from hermes_cli.profiles import _PROFILE_ID_RE as UPSTREAM_ID_RE
 
+    profiles_root = base_home / "profiles"
+    if not profiles_root.is_dir():
+        return []
+    root = profiles_root.resolve()
+    homes = []
+    for entry in sorted(profiles_root.iterdir()):
+        if not (entry.is_dir() and UPSTREAM_ID_RE.match(entry.name)):
+            continue
+        real = entry.resolve()
+        if real.is_relative_to(root):
+            homes.append((entry.name, real if entry.is_symlink() else entry))
+    return homes
+
+
+def list_profiles(base_home: Path) -> list[dict]:
+    """Profile rows for the base Hermes home: the root profile plus ``profiles/*``."""
     rows = []
     if base_home.is_dir():
         rows.append(_row(base_home, "default", True))
-    profiles_root = base_home / "profiles"
-    if profiles_root.is_dir():
-        for entry in sorted(profiles_root.iterdir()):
-            if entry.is_dir() and UPSTREAM_ID_RE.match(entry.name):
-                rows.append(_row(entry, entry.name, False))
+    rows.extend(_row(home, name, False) for name, home in named_profile_homes(base_home))
     return rows