@jaguilar87/gaia 5.0.8 → 5.0.10

package/bin/cli/brief.py

@@ -380,16 +380,44 @@ def _cmd_edit(args) -> int:
 
 
 def _cmd_show(args) -> int:
-    from gaia.briefs import get_brief, serialize_brief_to_markdown
+    from gaia.briefs import (
+        get_brief,
+        get_brief_by_id,
+        find_brief_workspaces,
+        serialize_brief_to_markdown,
+    )
     workspace = _resolve_workspace(getattr(args, "workspace", None))
     name = args.name
+    as_json = getattr(args, "json", False)
+
+    # FIX 1: when the argument is all-digits, resolve by numeric id first.
+    if name.isdigit():
+        brief = get_brief_by_id(int(name))
+        if brief is not None:
+            if as_json:
+                out = {k: v for k, v in brief.items() if k != "id"}
+                print(json.dumps(out, indent=2, default=str))
+                return 0
+            print(serialize_brief_to_markdown(brief))
+            return 0
+        # Numeric id not found -- fall through to the slug path so that a
+        # name that happens to look like a number still gets a useful error.
 
     brief = get_brief(workspace, name)
     if brief is None:
-        return _err(f"brief '{name}' not found in workspace '{workspace}'",
-                    as_json=getattr(args, "json", False))
+        # FIX 2: cross-workspace hint instead of bare "not found".
+        other_workspaces = find_brief_workspaces(name)
+        if other_workspaces:
+            hint = ", ".join(repr(w) for w in other_workspaces)
+            msg = (
+                f"brief '{name}' not found in workspace '{workspace}', "
+                f"but exists in: {hint} -- use --workspace=<workspace> to show it"
+            )
+        else:
+            msg = f"brief '{name}' not found in workspace '{workspace}'"
+        return _err(msg, as_json=as_json)
 
-    if getattr(args, "json", False):
+    if as_json:
         # Drop internal SQL columns for cleanliness
         out = {k: v for k, v in brief.items() if k != "id"}
         print(json.dumps(out, indent=2, default=str))
@@ -431,10 +459,23 @@ def _cmd_list(args) -> int:
 
 def _cmd_close(args) -> int:
     from gaia.briefs import close_brief
+    from gaia.briefs.store import verify_brief
     workspace = _resolve_workspace(getattr(args, "workspace", None))
     name = args.name
     if close_brief(workspace, name):
         print(f"Closed brief '{name}'")
+        # AC-3 advisory: run invariant checker and surface any inconsistencies
+        # as non-blocking stderr warnings (mirrors D11 pattern in plan CLI).
+        # Close always succeeds (exit 0); warnings never gate the operation.
+        try:
+            result = verify_brief(workspace, name)
+            for issue in result.get("inconsistencies", []):
+                print(
+                    f"Warning: [{issue['kind']}] {issue['detail']}",
+                    file=sys.stderr,
+                )
+        except Exception:
+            pass  # advisory failure must never abort the close
         return 0
     return _err(f"brief '{name}' not found in workspace '{workspace}'")
 

package/bin/cli/cleanup.py

@@ -1,10 +1,19 @@
 """
-gaia cleanup -- Remove temporary caches, old logs, and `__pycache__`;
-preserves project-context.json and .claude/ symlinks.
+gaia cleanup -- Remove Gaia's workspace footprint and apply data retention.
+
+The full-cleanup footprint mirrors what `gaia install` writes, in reverse:
+  - CLAUDE.md and .claude/settings.json (removed outright -- Gaia-owned)
+  - .claude/ symlinks incl. skills (removed -- Gaia-owned)
+  - .claude/.plugin-initialized marker (removed -- Gaia-owned)
+  - .claude/plugin-registry.json (surgical: only Gaia's installed[] entry is
+    removed; the file is shared with Claude Code's plugin system)
+  - .claude/settings.local.json (surgical: only Gaia-injected keys are removed
+    -- agent, two env vars, Gaia's permission entries; user config preserved)
+The user DB at ~/.gaia/gaia.db is never touched here.
 
 Modes:
-  --prune / --retain  Apply data retention policy only (no symlink/settings removal)
-  (default)           Remove CLAUDE.md, settings.json, symlinks + run retention
+  --prune / --retain  Apply data retention policy only (no footprint removal)
+  (default)           Remove the footprint above + run retention
 
 Flags:
   --dry-run           Print what would be pruned/removed without modifying files
@@ -16,6 +25,11 @@ import os
 import sys
 from pathlib import Path
 
+# bin/cli/cleanup.py -> bin/cli -> bin -> gaia/
+_PACKAGE_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(_PACKAGE_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PACKAGE_ROOT))
+
 
 # ---------------------------------------------------------------------------
 # Project root detection (mirrors JS findProjectRoot)
@@ -334,6 +348,7 @@ SYMLINKS_TO_REMOVE = [
     ".claude/hooks",
     ".claude/commands",
     ".claude/config",
+    ".claude/skills",
     ".claude/CHANGELOG.md",
     ".claude/README.en.md",
     ".claude/README.md",
@@ -358,6 +373,271 @@ def _remove_settings_json(root: Path, dry_run: bool) -> dict:
     return {"found": True, "removed": not dry_run, "dry_run": dry_run}
 
 
+# ---------------------------------------------------------------------------
+# Gaia-owned data-dir markers (.plugin-initialized, plugin-registry.json)
+#
+# Both live in get_plugin_data_dir(), which falls back to .claude/ when
+# CLAUDE_PLUGIN_DATA is unset (the common npm-install case). The marker is a
+# pure Gaia artifact -- removed outright. The registry is shared with Claude
+# Code's plugin system, so only Gaia's own entry is removed surgically.
+# ---------------------------------------------------------------------------
+
+# Plugin names Gaia registers in plugin-registry.json (see _read_plugin_name
+# in _install_helpers.py: package "gaia" maps to the canonical "gaia-ops").
+_GAIA_PLUGIN_NAMES = {"gaia-ops", "gaia-security", "gaia"}
+
+
+def _remove_plugin_initialized(root: Path, dry_run: bool) -> dict:
+    """Remove the .plugin-initialized first-run marker.
+
+    Written by plugin_setup.mark_initialized() into get_plugin_data_dir().
+    A pure Gaia artifact (timestamp + mode), safe to delete outright.
+    """
+    path = root / ".claude" / ".plugin-initialized"
+    if not path.exists():
+        return {"found": False}
+    if not dry_run:
+        try:
+            path.unlink()
+        except OSError as exc:
+            return {"found": True, "removed": False, "error": str(exc)}
+    return {"found": True, "removed": not dry_run, "dry_run": dry_run}
+
+
+def _remove_plugin_registry_entry(root: Path, dry_run: bool) -> dict:
+    """Remove Gaia's entry from plugin-registry.json, preserving other plugins.
+
+    plugin-registry.json is shared with Claude Code's plugin system. Install
+    (register_plugin / ensure_plugin_registry) writes Gaia's entry into the
+    ``installed`` list. Uninstall is symmetric: drop only Gaia-owned entries
+    from ``installed``. If that empties the registry of all plugins, the file
+    is equivalent to its pre-Gaia state and is removed; otherwise it is
+    rewritten with the surviving entries.
+
+    Idempotent: a registry with no Gaia entry returns found=False.
+    """
+    path = root / ".claude" / "plugin-registry.json"
+    if not path.exists():
+        return {"found": False}
+
+    data = _read_json_file(path)
+    if not isinstance(data, dict):
+        # Malformed/unexpected shape -- leave it untouched rather than risk
+        # destroying a file Gaia did not write.
+        return {"found": False, "skipped": "registry not a JSON object"}
+
+    installed = data.get("installed")
+    if not isinstance(installed, list):
+        return {"found": False, "skipped": "no installed[] array"}
+
+    kept = [
+        e for e in installed
+        if not (isinstance(e, dict) and e.get("name") in _GAIA_PLUGIN_NAMES)
+    ]
+    removed_entries = [
+        e for e in installed
+        if isinstance(e, dict) and e.get("name") in _GAIA_PLUGIN_NAMES
+    ]
+
+    if not removed_entries:
+        return {"found": False}
+
+    # Only Gaia keys present (installed + source) and nothing survives ->
+    # the file existed solely for Gaia; remove it entirely.
+    only_gaia_keys = set(data.keys()) <= {"installed", "source"}
+    delete_file = not kept and only_gaia_keys
+
+    result = {
+        "found": True,
+        "removed_entries": [e.get("name") for e in removed_entries],
+        "file_removed": delete_file and not dry_run,
+        "dry_run": dry_run,
+    }
+
+    if dry_run:
+        return result
+
+    try:
+        if delete_file:
+            path.unlink()
+        else:
+            data["installed"] = kept
+            _write_json_file(path, data)
+    except OSError as exc:
+        result["error"] = str(exc)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# settings.local.json -- surgical removal of Gaia-injected config
+#
+# Install (merge_local_permissions) MERGES into a user-owned file: it sets
+# agent=gaia-orchestrator, adds two env vars, and authoritative-merges its
+# permission entries. Uninstall must mirror that injection key-for-key and
+# leave everything the user added intact -- never delete the whole file.
+#
+# Note on permissions: install's authoritative merge already overwrote any
+# user-scoped variants of tool names Gaia manages (e.g. a prior Edit(/tmp/*)
+# became Edit). That loss is not recoverable at uninstall time; the symmetric
+# action is to drop the tool names Gaia manages and its deny rules, leaving
+# only entries for tools Gaia never touched.
+# ---------------------------------------------------------------------------
+
+_GAIA_ENV_KEYS = {
+    "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "1",
+}
+
+
+def _gaia_managed_permission_sets():
+    """Return (managed_tool_names, deny_entries) Gaia injects into settings.
+
+    Pulled from the canonical OPS/SECURITY permission constants in
+    plugin_setup.py (the same source install merges from). Falls back to a
+    minimal set if the hooks package cannot be imported (partial install).
+    """
+    try:
+        from hooks.modules.core.plugin_setup import (  # type: ignore
+            OPS_PERMISSIONS,
+            SECURITY_PERMISSIONS,
+            _tool_name,
+        )
+        allow = (
+            set(OPS_PERMISSIONS["permissions"]["allow"])
+            | set(SECURITY_PERMISSIONS["permissions"]["allow"])
+        )
+        deny = (
+            set(OPS_PERMISSIONS["permissions"]["deny"])
+            | set(SECURITY_PERMISSIONS["permissions"]["deny"])
+        )
+        managed_names = {_tool_name(e) for e in allow}
+        return managed_names, deny
+    except Exception:  # noqa: BLE001
+        return {"Bash"}, set()
+
+
+def _clean_settings_local_json(root: Path, dry_run: bool) -> dict:
+    """Remove only Gaia-injected keys from settings.local.json; preserve user config.
+
+    Mirrors merge_local_permissions:
+      - agent: removed only if it equals "gaia-orchestrator".
+      - env: removes the two Gaia keys only when their value matches what
+        install set (a user override of the value is preserved).
+      - permissions.allow: drops entries whose tool name Gaia manages.
+      - permissions.deny: drops Gaia's deny rules.
+      - Empty containers (env / permissions / allow / deny) are pruned so the
+        file does not retain hollow Gaia scaffolding.
+
+    If nothing Gaia-owned remains and the file becomes ``{}``, it is removed.
+    Idempotent: a file with no Gaia keys returns found=False.
+    """
+    path = root / ".claude" / "settings.local.json"
+    if not path.exists():
+        return {"found": False}
+
+    data = _read_json_file(path)
+    if not isinstance(data, dict):
+        return {"found": False, "skipped": "settings.local.json not a JSON object"}
+
+    removed_fields: list[str] = []
+
+    # agent identity
+    if data.get("agent") == "gaia-orchestrator":
+        removed_fields.append("agent")
+        if not dry_run:
+            del data["agent"]
+
+    # env vars (only when value still matches what install set)
+    env = data.get("env")
+    if isinstance(env, dict):
+        for key, expected in _GAIA_ENV_KEYS.items():
+            if env.get(key) == expected:
+                removed_fields.append(f"env.{key}")
+                if not dry_run:
+                    del env[key]
+        if not dry_run and not env:
+            del data["env"]
+
+    # permissions
+    perms = data.get("permissions")
+    if isinstance(perms, dict):
+        managed_names, gaia_deny = _gaia_managed_permission_sets()
+
+        allow = perms.get("allow")
+        if isinstance(allow, list):
+            kept_allow = [e for e in allow if _perm_tool_name(e) not in managed_names]
+            if len(kept_allow) != len(allow):
+                removed_fields.append("permissions.allow")
+                if not dry_run:
+                    if kept_allow:
+                        perms["allow"] = kept_allow
+                    else:
+                        del perms["allow"]
+
+        deny = perms.get("deny")
+        if isinstance(deny, list):
+            kept_deny = [e for e in deny if e not in gaia_deny]
+            if len(kept_deny) != len(deny):
+                removed_fields.append("permissions.deny")
+                if not dry_run:
+                    if kept_deny:
+                        perms["deny"] = kept_deny
+                    else:
+                        del perms["deny"]
+
+        # Drop hollow empty lists (ask/allow/deny) and an empty permissions
+        # block -- these are Gaia scaffolding, not user data.
+        if not dry_run:
+            for empty_key in ("ask", "allow", "deny"):
+                if perms.get(empty_key) == []:
+                    del perms[empty_key]
+            if not perms:
+                del data["permissions"]
+
+    if not removed_fields:
+        return {"found": False}
+
+    result = {
+        "found": True,
+        "removed_fields": removed_fields,
+        "file_removed": False,
+        "dry_run": dry_run,
+    }
+
+    if dry_run:
+        return result
+
+    try:
+        if not data:
+            path.unlink()
+            result["file_removed"] = True
+        else:
+            _write_json_file(path, data)
+    except OSError as exc:
+        result["error"] = str(exc)
+    return result
+
+
+def _perm_tool_name(entry: str) -> str:
+    """Base tool name from a permission entry (mirror of plugin_setup._tool_name)."""
+    if not isinstance(entry, str):
+        return ""
+    paren = entry.find("(")
+    return entry[:paren] if paren != -1 else entry
+
+
+def _read_json_file(path: Path):
+    """Read JSON, returning None on any error."""
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _write_json_file(path: Path, data) -> None:
+    """Write JSON with indent=2 + trailing newline (gaia convention)."""
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+
 def _remove_symlinks(root: Path, dry_run: bool) -> dict:
     removed = []
     skipped = []
@@ -513,11 +793,17 @@ def cmd_cleanup(args) -> int:
 
     claude_md = _remove_claude_md(root, dry_run)
     settings = _remove_settings_json(root, dry_run)
+    settings_local = _clean_settings_local_json(root, dry_run)
+    plugin_initialized = _remove_plugin_initialized(root, dry_run)
+    plugin_registry = _remove_plugin_registry_entry(root, dry_run)
     symlinks = _remove_symlinks(root, dry_run)
     retention_actions = _apply_retention_policy(root, dry_run)
 
     result["claude_md"] = claude_md
     result["settings_json"] = settings
+    result["settings_local_json"] = settings_local
+    result["plugin_initialized"] = plugin_initialized
+    result["plugin_registry"] = plugin_registry
     result["symlinks"] = symlinks
     result["retention_actions"] = retention_actions
     result["retention_policy"] = retention_policy_info
@@ -529,6 +815,9 @@ def cmd_cleanup(args) -> int:
         anything_done = (
             claude_md.get("found")
             or settings.get("found")
+            or settings_local.get("found")
+            or plugin_initialized.get("found")
+            or plugin_registry.get("found")
             or symlinks.get("removed")
             or retention_actions
         )
@@ -539,6 +828,17 @@ def cmd_cleanup(args) -> int:
         if settings.get("found"):
             verb = "Would remove" if dry_run else "Removed"
             print(f"  {verb}: .claude/settings.json")
+        if settings_local.get("found"):
+            verb = "Would clean" if dry_run else "Cleaned"
+            fields = ", ".join(settings_local.get("removed_fields", []))
+            print(f"  {verb}: .claude/settings.local.json ({fields})")
+        if plugin_initialized.get("found"):
+            verb = "Would remove" if dry_run else "Removed"
+            print(f"  {verb}: .claude/.plugin-initialized")
+        if plugin_registry.get("found"):
+            verb = "Would remove" if dry_run else "Removed"
+            entries = ", ".join(plugin_registry.get("removed_entries", []))
+            print(f"  {verb}: plugin-registry.json entry ({entries})")
         for rel in symlinks.get("removed", []):
             verb = "Would remove symlink" if dry_run else "Removed symlink"
             print(f"  {verb}: {rel}")

package/bin/cli/doctor.py

@@ -185,7 +185,7 @@ def _package_root() -> Path:
 # in lock-step with the INSERT it adds to bootstrap_database.sh. If a user
 # upgrades the CLI past a schema bump but does not re-run `gaia install`,
 # `check_schema_version` raises a warning telling them how to repair.
-EXPECTED_SCHEMA_VERSION = 18
+EXPECTED_SCHEMA_VERSION = 20
 
 # Locations the doctor reads outside the workspace.
 _INSTALL_ERROR_MARKER = Path("~/.gaia/last-install-error.json").expanduser()
@@ -854,10 +854,6 @@ def check_settings(project_root: Path) -> dict:
     if deny_count == 0:
         issues.append("No deny rules (destructive commands not blocked)")
 
-    env = data.get("env", {})
-    if not env.get("CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"):
-        infos.append("AGENT_TEAMS env not set")
-
     if issues:
         return _result("Settings", "error", "; ".join(issues), "Run `gaia scan` or `gaia update`")
 

package/bin/cli/uninstall.py

@@ -38,8 +38,11 @@ from pathlib import Path
 # duplicating retention policy, symlink lists, or root detection.
 from cli.cleanup import (  # type: ignore  # noqa: E402
     _apply_retention_policy,
+    _clean_settings_local_json,
     _find_project_root,
     _remove_claude_md,
+    _remove_plugin_initialized,
+    _remove_plugin_registry_entry,
     _remove_settings_json,
     _remove_symlinks,
 )
@@ -250,6 +253,9 @@ def cmd_uninstall(args: argparse.Namespace) -> int:
     try:
         result["claude_md"] = _remove_claude_md(workspace, dry_run)
         result["settings_json"] = _remove_settings_json(workspace, dry_run)
+        result["settings_local_json"] = _clean_settings_local_json(workspace, dry_run)
+        result["plugin_initialized"] = _remove_plugin_initialized(workspace, dry_run)
+        result["plugin_registry"] = _remove_plugin_registry_entry(workspace, dry_run)
         result["symlinks"] = _remove_symlinks(workspace, dry_run)
         result["retention_actions"] = _apply_retention_policy(workspace, dry_run)
     except Exception as exc:  # noqa: BLE001
@@ -345,6 +351,9 @@ def _print_human(result: dict, *, preuninstall: bool, purge: bool, dry_run: bool
 
     claude_md = result.get("claude_md") or {}
     settings = result.get("settings_json") or {}
+    settings_local = result.get("settings_local_json") or {}
+    plugin_initialized = result.get("plugin_initialized") or {}
+    plugin_registry = result.get("plugin_registry") or {}
     symlinks = result.get("symlinks") or {}
     retention = result.get("retention_actions") or []
     db = result.get("db") or {}
@@ -355,6 +364,17 @@ def _print_human(result: dict, *, preuninstall: bool, purge: bool, dry_run: bool
     if settings.get("found"):
         verb = "Would remove" if dry_run else "Removed"
         print(f"  {verb}: .claude/settings.json")
+    if settings_local.get("found"):
+        verb = "Would clean" if dry_run else "Cleaned"
+        fields = ", ".join(settings_local.get("removed_fields", []))
+        print(f"  {verb}: .claude/settings.local.json ({fields})")
+    if plugin_initialized.get("found"):
+        verb = "Would remove" if dry_run else "Removed"
+        print(f"  {verb}: .claude/.plugin-initialized")
+    if plugin_registry.get("found"):
+        verb = "Would remove" if dry_run else "Removed"
+        entries = ", ".join(plugin_registry.get("removed_entries", []))
+        print(f"  {verb}: plugin-registry.json entry ({entries})")
     for rel in symlinks.get("removed", []):
         verb = "Would remove symlink" if dry_run else "Removed symlink"
         print(f"  {verb}: {rel}")

package/dist/gaia-ops/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gaia-ops",
-  "version": "5.0.8",
+  "version": "5.0.10",
   "description": "Full DevOps orchestration for Claude Code. Eight specialized agents handle the complete development lifecycle \u2014 analysis, planning, execution, and deployment. Gaia-Ops scans your codebase to understand it and injects the right context into each sub-agent. Every command is classified by risk: read-only runs freely, state changes pause for your approval, and irreversible operations are permanently blocked.",
   "author": {
     "name": "jaguilar87",

package/dist/gaia-ops/hooks/adapters/claude_code.py

@@ -1117,19 +1117,15 @@ class ClaudeCodeAdapter(HookAdapter):
           2. Load the specific pending file by prefix (any session).
           3. Activate the grant under the CURRENT session.
 
-        Falls back to session-wide activation when no nonce is present in
-        the answer (backward compatibility with older approval labels).
+        DB-only since the grant-lifecycle FS retirement: REQUESTED writes go
+        to the DB, so the approved pending is resolved by nonce prefix straight
+        from the DB via ``activate_db_pending_by_prefix()``.
 
         Never blocks (no exceptions raised to caller).
         """
         from modules.security.approval_grants import (
-            activate_cross_session_pending,
             activate_db_pending_by_prefix,
-            activate_grants_for_session,
-            activate_pending_approval,
             extract_nonce_from_label,
-            get_pending_approvals_for_session,
-            load_pending_by_nonce_prefix,
         )
 
         session_id = hook_data.get("session_id", "") or os.environ.get("CLAUDE_SESSION_ID", "")
@@ -1163,93 +1159,31 @@ class ClaudeCodeAdapter(HookAdapter):
                 logger.info("AskUserQuestion: no session_id available, skipping grant activation")
                 return
 
-            # Try nonce-targeted activation first: extract nonce from answer labels
+            # Nonce-targeted activation: extract the nonce from answer labels.
             nonce_prefix = None
             for v in answers.values():
                 nonce_prefix = extract_nonce_from_label(str(v))
                 if nonce_prefix:
                     break
 
-            if nonce_prefix:
-                # Nonce-targeted: load this specific pending regardless of session
-                pending_data = load_pending_by_nonce_prefix(nonce_prefix)
-                if pending_data:
-                    pending_session = pending_data.get("session_id", "")
-                    full_nonce = pending_data.get("nonce", "")
-
-                    if pending_session == session_id:
-                        # Same session -- use standard activation
-                        result = activate_pending_approval(
-                            nonce=full_nonce,
-                            session_id=session_id,
-                        )
-                    else:
-                        # Cross session -- activate under current session
-                        result = activate_cross_session_pending(
-                            pending_data,
-                            session_id=session_id,
-                        )
-
-                    if result.success:
-                        logger.info(
-                            "AskUserQuestion nonce-targeted activation: prefix=%s, "
-                            "pending_session=%s, current_session=%s, status=%s",
-                            nonce_prefix, pending_session[:12], session_id[:12],
-                            getattr(result.status, "value", str(result.status)),
-                        )
-                        return
-                    else:
-                        logger.warning(
-                            "AskUserQuestion nonce-targeted activation failed: "
-                            "prefix=%s, status=%s, reason=%s",
-                            nonce_prefix,
-                            getattr(result.status, "value", str(result.status)),
-                            result.reason,
-                        )
-                else:
-                    # Filesystem pending not found -- try DB lookup (M2 bridge).
-                    # Since M2, REQUESTED writes go to DB only; no pending-{nonce}.json
-                    # is written to the filesystem any more.
-                    logger.info(
-                        "AskUserQuestion: nonce prefix %s found in label but no "
-                        "matching pending file -- trying DB lookup (M2 bridge)",
-                        nonce_prefix,
-                    )
-                    result = activate_db_pending_by_prefix(
-                        nonce_prefix, current_session_id=session_id,
-                    )
-                    if result.success:
-                        logger.info(
-                            "AskUserQuestion DB-bridge activation: prefix=%s status=%s",
-                            nonce_prefix,
-                            getattr(result.status, "value", str(result.status)),
-                        )
-                        return
-                    else:
-                        logger.warning(
-                            "AskUserQuestion DB-bridge activation failed: "
-                            "prefix=%s status=%s reason=%s -- falling back to session-wide",
-                            nonce_prefix,
-                            getattr(result.status, "value", str(result.status)),
-                            result.reason,
-                        )
-                    # Fall through to session-wide activation below
-                    nonce_prefix = None
-
             if not nonce_prefix:
-                # No nonce in label (or all targeted paths failed) -- fall back to
-                # session-wide activation for backward compatibility
-                pending = get_pending_approvals_for_session(session_id)
-                if not pending:
-                    logger.info("AskUserQuestion: no pending grants for session %s", session_id)
-                    return
-
-                results = activate_grants_for_session(session_id)
-                activated = sum(1 for r in results if r.success)
                 logger.info(
-                    "AskUserQuestion session-wide activation: %d/%d pending grants for session %s",
-                    activated, len(results), session_id,
+                    "AskUserQuestion: no nonce prefix in answer labels -- "
+                    "nothing to activate for session %s", session_id[:12],
                 )
+                return
+
+            # Resolve the approved pending straight from the DB.
+            result = activate_db_pending_by_prefix(
+                nonce_prefix, current_session_id=session_id,
+            )
+            logger.info(
+                "AskUserQuestion DB activation: prefix=%s success=%s status=%s reason=%s",
+                nonce_prefix,
+                result.success,
+                getattr(result.status, "value", str(result.status)),
+                result.reason,
+            )
 
         except Exception as e:
             logger.error("Error in _handle_ask_user_question_result: %s", e, exc_info=True)