livepilot 1.16.1 → 1.17.0

package/mcp_server/atlas/tools.py

@@ -149,6 +149,297 @@ def atlas_compare(ctx: Context, device_a: str, device_b: str, role: str = "") ->
     return atlas.compare(device_a, device_b, role=role)
 
 
+@mcp.tool()
+def atlas_describe_chain(
+    ctx: Context,
+    description: str,
+    genre: str = "",
+    limit_per_role: int = 3,
+) -> dict:
+    """Free-text describe-a-chain: "a granular pad that sounds like Tim Hecker"
+    → device chain proposal.
+
+    The mirror of `splice_describe_sound` for the device library. Where
+    `atlas_chain_suggest(role, genre)` takes structured inputs, this takes
+    a free-form sentence and proposes a chain by:
+
+      1. Parsing role hints from the description ("bass", "pad", "lead",
+         "percussion", "drum", "texture", "vocal", "keys")
+      2. Parsing aesthetic hints (artist names → `artist-vocabularies.md`,
+         genre names → `genre-vocabularies.md`, character words → atlas tags)
+      3. Searching the atlas with those terms
+      4. Proposing the top devices per role with brief rationale
+
+    This does NOT autoload anything — it returns a proposal the caller can
+    review, adjust, then execute with `load_browser_item` + a chain of FX.
+
+    description: free text. Examples:
+        "a granular pad that sounds like Tim Hecker"
+        "warm analog bass for minimal techno, deep and dubby"
+        "chopped vocal melody, Akufen-style microhouse"
+        "brittle mallet percussion with long reverb, Stars of the Lid territory"
+    genre:       optional genre bias if the description is genre-agnostic
+    limit_per_role: max devices to suggest per detected role (default 3)
+
+    Returns {description, detected_roles, detected_aesthetic,
+             per_role_suggestions: [...], chain_proposal: [...]}.
+    """
+    atlas = _get_atlas()
+    if atlas is None:
+        return {"error": "Atlas not loaded. Run scan_full_library first."}
+    if not description or not description.strip():
+        return {"error": "description is required"}
+
+    desc_lower = description.lower().strip()
+
+    # ── Detect roles ──────────────────────────────────────────────
+    ROLE_KEYWORDS = {
+        "bass":       ["bass", "sub", "808", "low end", "bottom"],
+        "lead":       ["lead", "melody", "topline", "hook"],
+        "pad":        ["pad", "texture", "atmosphere", "atmos", "drone", "ambient"],
+        "keys":       ["keys", "piano", "rhodes", "wurli", "wurly", "chord"],
+        "percussion": ["percussion", "perc", "shaker", "conga", "claves", "tambourine"],
+        "drums":      ["drums", "drum kit", "kick", "snare", "hat", "hi-hat", "hihat", "break"],
+        "vocal":      ["vocal", "vox", "voice", "chop", "chant"],
+        "fx":         ["fx", "riser", "downlifter", "sweep", "whoosh", "impact"],
+    }
+    detected_roles = []
+    for role, keywords in ROLE_KEYWORDS.items():
+        if any(k in desc_lower for k in keywords):
+            detected_roles.append(role)
+    if not detected_roles:
+        detected_roles = ["pad"]  # sensible default
+
+    # ── Detect aesthetic / artist cues ────────────────────────────
+    ARTIST_TO_TAGS = {
+        "villalobos":     ["minimal_techno", "deep_minimal"],
+        "hawtin":         ["minimal_techno", "deep_minimal"],
+        "plastikman":     ["minimal_techno"],
+        "basic channel":  ["dub_techno", "dub"],
+        "rhythm and sound": ["dub_techno", "dub"],
+        "voigt":          ["ambient", "dub_techno"],
+        "gas":            ["ambient"],
+        "basinski":       ["ambient", "drone"],
+        "stars of the lid": ["ambient", "drone", "modern_classical"],
+        "hecker":         ["ambient", "drone", "experimental"],
+        "aphex":          ["idm", "experimental"],
+        "autechre":       ["idm", "experimental"],
+        "dilla":          ["hip_hop", "lo_fi"],
+        "burial":         ["dubstep", "uk_garage", "ambient"],
+        "akufen":         ["microhouse"],
+        "isolee":         ["microhouse", "deep_house"],
+        "henke":          ["minimal_techno", "experimental"],
+        "monolake":       ["minimal_techno", "experimental"],
+        "tycho":          ["synthwave", "electronica"],
+        "boards of canada": ["downtempo", "lo_fi"],
+    }
+    CHARACTER_TAGS = [
+        "warm", "cold", "bright", "dark", "lush", "thin", "fat", "metallic",
+        "granular", "glitch", "gritty", "clean", "wet", "dry", "resonant",
+        "breathy", "analog", "digital", "vintage", "modern", "organic", "synthetic",
+    ]
+    GENRE_KEYWORDS = [
+        "microhouse", "minimal", "techno", "house", "deep house", "ambient",
+        "drone", "idm", "experimental", "dubstep", "dnb", "drum and bass",
+        "hip hop", "hip-hop", "lo-fi", "lo fi", "lofi", "trap", "garage",
+        "dub techno", "dub", "jazz", "classical", "cinematic", "synthwave",
+        "vaporwave", "ambient techno", "deep minimal",
+    ]
+    detected_aesthetic = []
+    for artist, tags in ARTIST_TO_TAGS.items():
+        if artist in desc_lower:
+            detected_aesthetic.extend(tags)
+    for tag in CHARACTER_TAGS:
+        if f" {tag}" in f" {desc_lower}":
+            detected_aesthetic.append(tag)
+    for g in GENRE_KEYWORDS:
+        if g in desc_lower:
+            detected_aesthetic.append(g.replace(" ", "_").replace("-", "_"))
+    if genre:
+        detected_aesthetic.append(genre.lower())
+    # Dedupe preserving order
+    seen = set()
+    detected_aesthetic = [
+        t for t in detected_aesthetic
+        if not (t in seen or seen.add(t))
+    ]
+
+    # ── Build per-role suggestions via atlas.suggest ─────────────
+    per_role_suggestions = []
+    for role in detected_roles:
+        # Build an intent string that combines role + aesthetic cues
+        intent_parts = [role]
+        intent_parts.extend(detected_aesthetic[:3])  # top 3 aesthetic tags
+        intent = " ".join(intent_parts)
+        results = atlas.suggest(
+            intent=intent,
+            genre=(detected_aesthetic[0] if detected_aesthetic else genre),
+            energy="medium",
+            limit=int(limit_per_role),
+        )
+        per_role_suggestions.append({
+            "role": role,
+            "intent_used": intent,
+            "suggestions": [
+                {
+                    "device_id": r["device"].get("id", ""),
+                    "device_name": r["device"].get("name", ""),
+                    "uri": r["device"].get("uri", ""),
+                    "rationale": r.get("rationale", ""),
+                    "recipe": r.get("recipe"),
+                }
+                for r in results
+            ],
+        })
+
+    # ── Propose a simple chain from the highest-ranked suggestions ─
+    chain_proposal = []
+    position = 0
+    for role_block in per_role_suggestions:
+        if not role_block["suggestions"]:
+            continue
+        top = role_block["suggestions"][0]
+        chain_proposal.append({
+            "position": position,
+            "role": role_block["role"],
+            "device_name": top["device_name"],
+            "device_id": top["device_id"],
+            "uri": top["uri"],
+            "why": top["rationale"],
+        })
+        position += 1
+
+    # ── Cross-reference aesthetic to the vocabulary files ──────────
+    next_steps = []
+    if any("villalobos" in desc_lower or a in detected_aesthetic for a in
+           ("microhouse", "deep_minimal", "minimal_techno", "dub_techno",
+            "ambient", "drone", "idm", "experimental")):
+        next_steps.append(
+            "Cross-reference "
+            "`livepilot/skills/livepilot-core/references/artist-vocabularies.md` "
+            "and `genre-vocabularies.md` for deeper aesthetic guidance."
+        )
+    if not detected_aesthetic:
+        next_steps.append(
+            "No aesthetic or genre cues detected. If the description "
+            "should have matched, add it to the ARTIST_TO_TAGS map or "
+            "provide genre= explicitly."
+        )
+    next_steps.append(
+        "Call `atlas_techniques_for_device(device_id)` on any proposal "
+        "to see what techniques reference it."
+    )
+
+    return {
+        "description": description,
+        "detected_roles": detected_roles,
+        "detected_aesthetic": detected_aesthetic,
+        "per_role_suggestions": per_role_suggestions,
+        "chain_proposal": chain_proposal,
+        "next_steps": next_steps,
+    }
+
+
+@mcp.tool()
+def atlas_techniques_for_device(ctx: Context, device_id: str) -> dict:
+    """Reverse-lookup: what techniques / principles reference this device?
+
+    Answers questions like "what can I do with Granulator III?" by returning
+    every technique across the knowledge base that mentions this device —
+    the device's own `signature_techniques`, sample-manipulation principles
+    that use it, sound-design-deep.md references. Complements
+    `atlas_device_info` (which returns the device's own curated fields) by
+    showing the device's OUTWARD connections — how it fits into techniques
+    that weren't written from the device's perspective.
+
+    device_id: atlas ID (e.g. "granulator_iii", "simpler", "analog"). Use
+               `atlas_search` or `atlas_device_info` to discover IDs.
+
+    Returns {device_id, technique_count, techniques: [...]}, where each
+    technique entry has:
+      - technique: short name (e.g. "Vocal micro-chop (Akufen)")
+      - description: one-line
+      - aesthetic: list of aesthetic/genre tags
+      - source: where this technique lives (`atlas/<id>`,
+                `sample-techniques.md`, `sound-design-deep.md`)
+      - kind: signature_technique | sample_technique | sound_design_principle
+
+    Index is auto-generated from the knowledge base; regenerate via the
+    companion script when adding new techniques (rare — most additions
+    happen through enrichment YAMLs, which the index reads directly).
+    """
+    import json, os
+    index_path = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        "device_techniques_index.json",
+    )
+    if not os.path.isfile(index_path):
+        return {
+            "error": "device_techniques_index.json not found",
+            "hint": "regenerate via the post-v1.17 reverse-index builder script",
+        }
+    try:
+        with open(index_path, "r") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError) as exc:
+        return {"error": f"Failed to load index: {exc}"}
+
+    if not device_id:
+        # Return a summary of indexed devices
+        devices = data.get("devices", {})
+        return {
+            "indexed_device_count": len(devices),
+            "total_cross_references": data.get("entry_count", 0),
+            "devices": sorted(devices.keys()),
+            "hint": "Pass a device_id for per-device techniques",
+        }
+
+    entries = data.get("devices", {}).get(device_id)
+    if entries is None:
+        return {
+            "device_id": device_id,
+            "technique_count": 0,
+            "techniques": [],
+            "hint": (
+                "No techniques indexed for this device. Try a different ID "
+                "or use `atlas_search` to find the correct one. Devices "
+                "with no cross-references either haven't been enriched yet "
+                "or aren't referenced in any technique doc."
+            ),
+        }
+
+    return {
+        "device_id": device_id,
+        "technique_count": len(entries),
+        "techniques": entries,
+    }
+
+
+@mcp.tool()
+def atlas_pack_info(ctx: Context, pack_name: str = "") -> dict:
+    """Inspect a single Ableton pack — device list + enrichment coverage.
+
+    pack_name: the pack name (e.g., "Drone Lab", "Core Library",
+               "Creative Extensions", "Inspired by Nature"). Case-insensitive.
+               Pass an empty string to get the full list of packs known to
+               the atlas with device counts.
+
+    Returns {pack, device_count, enriched_count, devices[...]} for a
+    specific pack, or {packs: [...]} when called with no name.
+
+    Use this to answer questions like "what's in Drone Lab?" or "how
+    much of Creative Extensions do we have aesthetic knowledge about?"
+    """
+    atlas = _get_atlas()
+    if atlas is None:
+        return {"error": "Atlas not loaded. Run scan_full_library first."}
+
+    if not pack_name:
+        return {"packs": atlas.list_packs()}
+
+    return atlas.pack_info(pack_name)
+
+
 @mcp.tool()
 def scan_full_library(
     ctx: Context,

package/mcp_server/m4l_bridge.py

@@ -479,7 +479,16 @@ class SpectralReceiver(asyncio.DatagramProtocol):
         /response_chunk i i s      — chunked response (index, total, data)
     """
 
-    BAND_NAMES = ["sub", "low", "low_mid", "mid", "high_mid", "high", "presence", "air"]
+    # Band names keyed by how many bands the .amxd emits. 8 bands is the v1.x
+    # layout (sub starts at 20 Hz, ~octave per band). 9 bands is v1.16.x+
+    # with an explicit sub_low (20-60 Hz) split off so Villalobos-style kicks
+    # at 40-50 Hz are no longer hidden inside the sub band. The .amxd is the
+    # source of truth for band count — this server picks the right names
+    # based on how many floats actually arrive on /spectrum.
+    BAND_NAMES_8 = ["sub", "low", "low_mid", "mid", "high_mid", "high", "presence", "air"]
+    BAND_NAMES_9 = ["sub_low", "sub", "low", "low_mid", "mid", "high_mid", "high", "presence", "air"]
+    # Default alias kept for any external reader.
+    BAND_NAMES = BAND_NAMES_9
 
     def __init__(self, cache: SpectralCache, miditool_cache: Optional["MidiToolCache"] = None):
         self.cache = cache
@@ -571,8 +580,16 @@ class SpectralReceiver(asyncio.DatagramProtocol):
 
     def _handle_message(self, address: str, args: list) -> None:
         if address == "/spectrum" and len(args) >= 8:
+            # Pick the right name set based on how many bands the .amxd emits.
+            # 9-band payloads come from v1.16.x+ devices with the sub_low split.
+            # 8-band payloads come from older frozen .amxd builds — we keep
+            # working against them until every user has re-frozen.
+            if len(args) >= 9:
+                names = self.BAND_NAMES_9
+            else:
+                names = self.BAND_NAMES_8
             bands = {}
-            for i, name in enumerate(self.BAND_NAMES):
+            for i, name in enumerate(names):
                 if i < len(args):
                     bands[name] = round(float(args[i]), 4)
             self.cache.update("spectrum", bands)

package/mcp_server/sample_engine/tools.py

@@ -1496,23 +1496,29 @@ async def splice_describe_sound(
     bpm: Optional[int] = None,
     key: Optional[str] = None,
     limit: int = 20,
+    rephrase: bool = True,
 ) -> dict:
     """Natural-language sample search — the Sounds Plugin's "Describe a Sound".
 
     Splice's AI matches free-form descriptions like "dark ambient pad with
-    shimmer" or "tight 90s house hi-hat" to catalog samples. This is NOT
-    on the local gRPC — the bridge proxies to api.splice.com using your
-    session token.
+    shimmer" or "tight 90s house hi-hat" to catalog samples. Hits the
+    GraphQL `SamplesSearch` operation on `surfaces-graphql.splice.com`
+    with `semantic=1` + `rephrase=true` enabled.
 
-    **Status: scaffolding complete, endpoint pending real-traffic capture.**
-    Until `SPLICE_DESCRIBE_ENDPOINT` env var is set (or
-    `SPLICE_ALLOW_UNVERIFIED_ENDPOINTS=1`), this tool returns a structured
-    ENDPOINT_NOT_CONFIGURED error with actionable setup steps.
+    **Status: LIVE** as of 2026-04-22. Endpoint captured via mitmproxy
+    against Splice desktop 5.4.9 + Sounds Plugin.
 
     description: free-text prompt ("warm analog bass under 80bpm")
     bpm:         optional BPM filter
     key:         optional musical key ("Dm", "F#")
     limit:       max results (default 20)
+    rephrase:    let Splice's ML rephrase the query for better matches
+                 (default True). Returned as `rephrased_query_string`.
+
+    Returns `{ok, query, samples[], total_hits, rephrased_query_string,
+    tag_summary[], ...}`. Each sample has uuid/name/bpm/key/duration/
+    instrument/tags/pack_name/files. Use the uuid with
+    `splice_download_sample(uuid)` to pull the audio file.
     """
     bridge, err = _build_http_bridge(ctx)
     if err:
@@ -1524,95 +1530,161 @@ async def splice_describe_sound(
         result = await bridge.describe_sound(
             description=description.strip(),
             bpm=bpm, key=key, limit=int(limit),
+            rephrase=bool(rephrase),
         )
     except SpliceHTTPError as exc:
         return exc.to_dict()
     except Exception as exc:
         return {"ok": False, "error": f"describe_sound failed: {exc}"}
-    return {"ok": True, "query": description, **(result if isinstance(result, dict) else {"raw": result})}
+    # Don't expose the full GraphQL `raw` dict in the user-facing response
+    # unless they asked — it adds ~270KB noise per call. Keep it for
+    # power users via an explicit future flag.
+    out = dict(result) if isinstance(result, dict) else {"raw": result}
+    out.pop("raw", None)
+    return {"ok": True, "query": description, **out}
 
 
 @mcp.tool()
 async def splice_generate_variation(
     ctx: Context,
-    file_hash: str,
-    target_key: Optional[str] = None,
-    target_bpm: Optional[int] = None,
-    count: int = 1,
+    uuid: str,
+    is_legacy: bool = True,
 ) -> dict:
-    """Generate AI variations of a Splice sample — the Sounds Plugin's "Variations".
-
-    Splice's AI produces unique re-keyed / re-tempo'd versions of any
-    sample. Costs additional credits per variation (on top of the base
-    license). NOT on the local gRPC — bridged via api.splice.com.
-
-    **Status: scaffolding complete, endpoint pending real-traffic capture.**
-    Until `SPLICE_VARIATION_ENDPOINT` env var is set (or
-    `SPLICE_ALLOW_UNVERIFIED_ENDPOINTS=1`), this tool returns a structured
-    ENDPOINT_NOT_CONFIGURED error with actionable setup steps.
-
-    file_hash:  sample identifier (from search results)
-    target_key: desired key (e.g. "Am")
-    target_bpm: desired tempo
-    count:      number of variations to generate (1-5)
-
-    WARNING: this WILL spend credits when the endpoint is live.
-    Consider previewing the source sample with splice_preview_sample first.
+    """Find catalog samples similar to a given Splice sample — the "Variations" feature.
+
+    Splice's right-click "Variations" menu item surfaces other catalog
+    samples with similar sonic character. The GraphQL operation name
+    is `AssetSimilarSoundsQuery`. Up to 10 results per call. No credit
+    cost (this is a recommender lookup, not AI audio synthesis — the
+    original naming in the handoff was aspirational).
+
+    **Status: LIVE** as of 2026-04-22. Endpoint captured via mitmproxy
+    against Splice desktop v5.4.9.
+
+    uuid:       source sample's catalog uuid (from `splice_describe_sound`
+                results or any other Splice metadata call)
+    is_legacy:  match how Splice's own client sets it — default True is
+                correct for all mainstream catalog samples; set False only
+                if working with post-catalog-v2 assets
+
+    Returns `{ok, uuid, similar_samples[], count}`. Each entry has the
+    same flat shape as a describe_sound sample (uuid/name/bpm/key/
+    duration/tags/pack_name/files). Use the uuid of any result with
+    `splice_download_sample()` to pull the audio.
     """
     bridge, err = _build_http_bridge(ctx)
     if err:
         return err
     from ..splice_client.http_bridge import SpliceHTTPError
-    if not file_hash or not file_hash.strip():
-        return {"ok": False, "error": "file_hash is required"}
-    if count < 1 or count > 5:
-        return {"ok": False, "error": "count must be 1-5"}
+    if not uuid or not uuid.strip():
+        return {"ok": False, "error": "uuid is required"}
     try:
         result = await bridge.generate_variation(
-            file_hash=file_hash.strip(),
-            target_key=target_key,
-            target_bpm=target_bpm,
-            count=int(count),
+            uuid=uuid.strip(),
+            is_legacy=bool(is_legacy),
         )
     except SpliceHTTPError as exc:
         return exc.to_dict()
     except Exception as exc:
         return {"ok": False, "error": f"generate_variation failed: {exc}"}
-    return {"ok": True, "file_hash": file_hash, **(result if isinstance(result, dict) else {"raw": result})}
+    out = dict(result) if isinstance(result, dict) else {"raw": result}
+    out.pop("raw", None)  # drop verbose debug payload
+    return {"ok": True, "uuid": uuid, **out}
 
 
-@mcp.tool()
-async def splice_search_with_sound(
-    ctx: Context,
-    audio_path: str,
-    limit: int = 20,
-) -> dict:
-    """Reference-audio search — the Sounds Plugin's "Search with Sound".
+# NOTE: splice_search_with_sound was removed 2026-04-22 — user does this
+# in-Splice manually. If someone wants to resurrect it, the capture recipe
+# is still at docs/2026-04-22-splice-https-capture-recipe.md.
 
-    Uploads a local audio file to Splice's AI and returns catalog samples
-    with similar character. Complements `splice_describe_sound` (text)
-    and `search_samples` (keyword).
 
-    **Status: scaffolding complete, wiring pending real-traffic capture
-    (multipart upload shape is the most uncertain part of the bridge).**
-    Until `SPLICE_SEARCH_WITH_SOUND_ENDPOINT` is set, returns a structured
-    NOT_YET_IMPLEMENTED error.
+@mcp.tool()
+async def splice_http_diagnose(ctx: Context) -> dict:
+    """Diagnose the Splice HTTPS bridge configuration and readiness.
 
-    audio_path: absolute path to a local audio file (.wav, .mp3, .flac)
-    limit:      max results (default 20)
+    Reports which endpoints are configured, whether a session token is
+    reachable from the gRPC client, and what the next step is to unblock
+    `splice_describe_sound` and `splice_generate_variation`.
+
+    Use this BEFORE calling either tool if you want a clear readout of
+    "what's missing, and how do I fix it" instead of per-tool
+    ENDPOINT_NOT_CONFIGURED errors.
     """
-    bridge, err = _build_http_bridge(ctx)
-    if err:
-        return err
-    from ..splice_client.http_bridge import SpliceHTTPError
-    if not audio_path or not os.path.isfile(audio_path):
-        return {"ok": False, "error": f"audio_path not found: {audio_path}"}
+    from ..splice_client.http_bridge import SpliceHTTPConfig
+
+    cfg = SpliceHTTPConfig.from_env()
+    endpoints = {
+        "describe": cfg.describe_endpoint,
+        "variation": cfg.variation_endpoint,
+    }
+    verified = {
+        "describe": cfg.describe_verified,
+        "variation": cfg.variation_verified,
+    }
+    unverified = [name for name, ok in verified.items() if not ok]
+    configured_count = sum(1 for v in endpoints.values() if v not in (None, ""))
+
+    # Try to read the session token via the gRPC client the SAME way
+    # the real tools do — reach into ctx.lifespan_context["splice_client"]
+    # and actually attempt a GetSession fetch. Walking a different
+    # engine-nested path (earlier mistake) reported "token unavailable"
+    # while the bridge's real request path succeeded — a misleading
+    # diagnostic is worse than no diagnostic.
+    session_token_available = False
+    session_token_error = None
+    grpc_client = None
     try:
-        result = await bridge.search_with_sound(
-            audio_path=audio_path, limit=int(limit),
+        grpc_client = ctx.lifespan_context.get("splice_client")
+    except AttributeError:
+        pass
+    if grpc_client is None or not getattr(grpc_client, "connected", False):
+        session_token_error = "Splice gRPC not connected"
+    else:
+        # Connection is up; confirm a token actually comes back.
+        from ..splice_client.http_bridge import fetch_session_token
+        try:
+            token = await fetch_session_token(grpc_client)
+            if token:
+                session_token_available = True
+            else:
+                session_token_error = (
+                    "GetSession RPC returned no token — user may be "
+                    "logged out or gRPC schema drifted"
+                )
+        except Exception as exc:
+            session_token_error = f"GetSession call failed: {exc}"
+
+    next_steps: list = []
+    if "describe" in unverified:
+        next_steps.append(
+            "Describe endpoint unverified — reset config to defaults "
+            "(delete ~/.livepilot/splice.json or unset env vars) so the "
+            "captured surfaces-graphql.splice.com/graphql endpoint is used."
         )
-    except SpliceHTTPError as exc:
-        return exc.to_dict()
-    except Exception as exc:
-        return {"ok": False, "error": f"search_with_sound failed: {exc}"}
-    return {"ok": True, "audio_path": audio_path, **(result if isinstance(result, dict) else {"raw": result})}
+    if "variation" in unverified:
+        next_steps.append(
+            "Variation GraphQL operation not yet captured. Right-click "
+            "a Splice sample and click Variations with mitmproxy running. "
+            "See docs/2026-04-22-splice-https-capture-recipe.md."
+        )
+    if not session_token_available:
+        next_steps.append(
+            "Splice desktop app is not reachable — the bridge reads the "
+            "session token via gRPC GetSession RPC. Ensure the app is "
+            "running and logged in."
+        )
+    if not next_steps:
+        next_steps.append("Bridge fully ready — test with splice_describe_sound.")
+
+    return {
+        "ok": True,
+        "base_url": cfg.base_url,
+        "endpoints": endpoints,
+        "verified": verified,
+        "configured_count": configured_count,
+        "unverified_endpoints": unverified,
+        "is_user_configured": cfg.is_user_configured,
+        "session_token_available": session_token_available,
+        "session_token_error": session_token_error,
+        "next_steps": next_steps,
+        "docs": "docs/2026-04-22-splice-https-capture-recipe.md",
+    }