thoughtleaders-cli 0.9.4__tar.gz → 0.9.7__tar.gz

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tl-cli",
-  "version": "0.9.4",
+  "version": "0.9.7",
   "description": "ThoughtLeaders CLI — query sponsorship deals, channels, brands, uploads, and intelligence from the terminal",
   "author": {
     "name": "ThoughtLeaders",

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoughtleaders-cli
-Version: 0.9.4
+Version: 0.9.7
 Summary: ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence
 Project-URL: Homepage, https://thoughtleaders.io
 Project-URL: Repository, https://github.com/ThoughtLeaders-io/thoughtleaders-cli

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thoughtleaders-cli"
-version = "0.9.4"
+version = "0.9.7"
 description = "ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence"
 readme = "README.md"
 license = "MIT"

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/skills/tl/SKILL.md

@@ -217,6 +217,8 @@ tl snapshots channel <id>              # Channel metrics over time (Firebolt-bac
 tl snapshots video <id> --channel <id> # Video view curve (--channel required!)
 tl reports                             # List saved reports
 tl reports run <id>                    # Run a saved report
+tl reports link <id> --source <id> --entity <e> [--type include|exclude] [--source-side included|excluded]  # Link another report in as a live entity source
+tl reports unlink <id> --source <id> [--entity <e>] [--type include|exclude]  # Remove report links (all from that source unless narrowed)
 tl <entity> comment-list <id>          # List comments on a sponsorship/channel/brand/upload
 tl <entity> comment-add <id> "msg"     # Add a comment
 tl <entity> comment-edit <comment-id> "msg"  # Edit own comment (author or superuser)
@@ -261,6 +263,66 @@ clear. This is currently the only editable profile field; anything else returns
 the editable surface. Use it for account-handling notes meant for the internal team — it is
 never shown to the customer.
 
+**Report linking.** `tl reports link` attaches another report to a report as a **live**
+include/exclude entity source — the target report's results are filtered by the source
+report's entities (channels, brands, articles, or sponsorships) and stay in sync as the
+source changes. This is the "include/exclude entities from another report" feature the
+web UI offers, and it differs from `tl bulk-import`, which copies a **frozen snapshot**
+of IDs. `--type` defaults to `include`; `--source-side` defaults to `included` (pass
+`excluded` to pull the source report's excluded entities instead of its results).
+Requires owning the target report (or full access), and the source report must be
+visible to you. Linking a report to itself, an exact duplicate link, or an unknown key
+comes back as a 400.
+
+`tl reports unlink` removes links: with only `--source`, every link pulling from that
+source report is removed; add `--entity` and/or `--type` to remove just the matching
+one. No matching link comes back as a 404, never a silent no-op.
+
+```bash
+tl reports link 1234 --source 5678 --entity channels                 # include source's channels
+tl reports link 1234 --source 5678 --entity brands --type exclude    # exclude source's brands
+tl reports unlink 1234 --source 5678                                 # remove all links from 5678
+tl reports unlink 1234 --source 5678 --entity brands --type exclude  # remove one specific link
+```
+
+### Profile memory
+
+Profile memory is the free-text summary of who a user is and what they want from
+sponsorships. The onboarding interview writes it first; `tl memory` keeps it current
+afterwards. **This is the standard way to update user data** — prefer it over any
+direct database write.
+
+```bash
+tl memory show                            # Your memory + the preferences derived from it (free)
+tl memory show --profile-id <id>          # Someone else's memory (full-access only) (free)
+tl memory add "<fact>"                    # Fold one new fact into the existing memory (free)
+tl memory set "<blob>"                    # Replace the memory wholesale (free)
+tl memory set --from-file <path>          # Same, reading the text from a file (free)
+```
+
+Examples:
+```bash
+tl memory show --profile-id 8871
+tl memory add "Stopped doing finance ads. Now targeting 18-24 in the US."
+tl memory set --from-file ./memory.txt
+```
+
+`add` is the verb to reach for almost every time: the new fact is folded into the
+existing memory, keeping what's still true and replacing only what the fact
+contradicts. Never read the memory, edit it yourself and write it back with `set` when
+`add` would do — one `add` per fact is the whole interface. `add` takes noticeably
+longer than the other two; that is expected, so let it finish rather than retrying,
+because a repeated `add` can land twice. A fact is one statement, not a document:
+anything past 4,000 characters is rejected, so split a long update into several `add`
+calls rather than sending it as one.
+
+`set` replaces the memory wholesale and, unlike `add`, accepts a short replacement for
+a long memory — treat it as the repair hatch for when a merge has damaged a memory,
+not as a routine update path. Blank replacement text is refused rather than erasing the
+memory, and text beyond 50,000 characters is not kept. `add` and `set` always write to
+the **caller's own** profile regardless of permissions; only `show --profile-id` can
+reach someone else's, and that's full-access only.
+
 ### Creating and vetting sponsorships
 
 This is the end-to-end workflow for proposing a sponsorship, then moving it through the funnel as the two sides respond. Three create commands plus `tl sponsorships update` cover every state transition the CLI exposes.

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/skills/tl/references/postgres-schema.md

@@ -25,6 +25,7 @@ The profile table is tightly coupled with the brand table for media buyers, so m
 > - ❌ `youtube_id` (on channel) — use `external_channel_id`.
 > - ❌ `msn_join_date` (on channel) — use `media_selling_network_join_date`.
 > - ❌ `mbn_join_date` (on profile) — use `media_buying_network_join_date`.
+> - ❌ `url` — renamed to `urls` (array) by migration 0010 (2026-07-16, "AdLink.url becomes urls"). A sponsorship can carry several URLs now; use `urls` — e.g. `urls[1]` for the first entry, or `array_to_string(urls, ', ')` to flatten.
 
 #### Key Columns for the thoughtleaders_adlink table
 
@@ -58,6 +59,7 @@ The profile table is tightly coupled with the brand table for media buyers, so m
 | `performance_grade` | int | Performance rating (see business-glossary) |
 | `article_id` | varchar | Compound `<channel_id>:<youtube_id>` — links to ES `_id` and ES `id` field |
 | `created_where` | varchar | What mechanism / software / agent created the record |
+| `urls` | varchar(600)[] (array) | Destination/reference URLs for the sponsorship. ⚠️ Renamed from the old singular `url` column by migration 0010 (2026-07-16) — a sponsorship can carry several URLs now. Never NULL (empty array `{}` when none set). Use `urls[1]` for "the" URL when a single value is needed, or `array_to_string(urls, ', ')` to flatten for display. |
 
 #### `publish_status` Constants
 
@@ -204,7 +206,7 @@ A channel can have multiple adspots (different sellers: talent manager, direct,
 
 When composing `SELECT ... FROM thoughtleaders_channel ...`, do not improvise column names from semantic intuition — consult the output of `tl schema pg thoughtleaders_channel` or the column table above. The `tl schema` command is authoritative. Failed guesses return *"column '\<name\>' does not exist"* and cost a round-trip. Recurring problems:
 
-- Subscriber count is in the field named `subscribers`
+- ❌ `reach` — this column does NOT exist on Postgres. Use `subscribers`. (The Elasticsearch channel doc uses `reach` as a legacy alias for the same value — see [elasticsearch-schema.md](elasticsearch-schema.md) — but Postgres never had that name; don't carry the ES field name over when switching to a `tl db pg` query.)
 - Projected views is in the field named `projected_views`
 - ❌ **Suffix/qualifier variants of date columns** (e.g. an `_max` / `latest_` / `_date` form when the canonical column has neither). Date columns  use bare names.
 - ❌ **Platform-name-prefixed ID forms** (e.g. a platform-name prefix when the canonical column uses a neutral `external_` prefix). See the column table for the actual ID column.

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/src/tl_cli/__init__.py

@@ -1,3 +1,3 @@
 """ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence."""
 
-__version__ = "0.9.4"
+__version__ = "0.9.7"

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/src/tl_cli/client/http.py

@@ -26,8 +26,8 @@ class TLClient:
     def get(self, path: str, params: dict | None = None, timeout: float | None = None) -> dict:
         return self._request("GET", path, params=params, timeout=timeout)
 
-    def post(self, path: str, json_body: dict | None = None) -> dict:
-        return self._request("POST", path, json_body=json_body)
+    def post(self, path: str, json_body: dict | None = None, timeout: float | None = None) -> dict:
+        return self._request("POST", path, json_body=json_body, timeout=timeout)
 
     def patch(self, path: str, json_body: dict | None = None) -> dict:
         return self._request("PATCH", path, json_body=json_body)

thoughtleaders_cli-0.9.7/src/tl_cli/commands/memory.py

@@ -0,0 +1,149 @@
+"""tl memory — read and update your profile memory.
+
+Your profile memory is the free-text summary of who you are and what you want from
+sponsorships. The onboarding interview writes it first; these commands are how it
+stays current afterwards.
+"""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.markup import escape as rich_escape
+
+from tl_cli._typer_utils import AlphaSortedTyperGroup
+from tl_cli.client.errors import ApiError, handle_api_error
+from tl_cli.client.http import get_client
+from tl_cli.output.formatter import detect_format, output_single
+
+app = typer.Typer(cls=AlphaSortedTyperGroup, help="Your profile memory (show; add a fact; replace)")
+
+# `add` folds the fact into the existing memory with a model call whose duration
+# scales with how much memory there is to rewrite, so it can run far past the
+# client's 30s default. `set` is a plain replace and needs no extra room.
+_ADD_TIMEOUT_SECONDS = 180.0
+
+
+@app.command("show")
+def show_cmd(
+    profile_id: int | None = typer.Option(None, "--profile-id", help="Another profile's memory (full-access only)"),
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+    toon_output: bool = typer.Option(False, "--toon", help="TOON output (token-efficient for LLMs)"),
+) -> None:
+    """Show your profile memory and the preferences derived from it.
+
+    Examples:
+        tl memory show
+        tl memory show --json
+        tl memory show --profile-id 8871
+    """
+    fmt = detect_format(json_output, False, False, toon_output)
+    params = {"profile_id": profile_id} if profile_id is not None else {}
+
+    client = get_client()
+    try:
+        data = client.get("/memory", params=params)
+        output_single(data, fmt)
+    except ApiError as e:
+        handle_api_error(e)
+    finally:
+        client.close()
+
+
+@app.command("add")
+def add_cmd(
+    fact: str = typer.Argument(..., help="One new fact about you"),
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+    toon_output: bool = typer.Option(False, "--toon", help="TOON output (token-efficient for LLMs)"),
+) -> None:
+    """Fold one new fact into your profile memory.
+
+    The fact is merged into what's already there — everything still true is kept,
+    and only what the new fact contradicts is replaced. Always writes to your own
+    profile.
+
+    Examples:
+        tl memory add "We stopped doing finance sponsorships."
+        tl memory add "Now targeting 18-24 in the US."
+    """
+    fmt = detect_format(json_output, False, False, toon_output)
+    if not fact.strip():
+        Console(stderr=True).print("[red]Error:[/red] fact cannot be empty.")
+        raise typer.Exit(1)
+
+    client = get_client()
+    try:
+        data = client.post("/memory", json_body={"fact": fact.strip()}, timeout=_ADD_TIMEOUT_SECONDS)
+        output_single(data, fmt)
+    except ApiError as e:
+        handle_api_error(e)
+    finally:
+        client.close()
+
+
+@app.command("set")
+def set_cmd(
+    memory: str | None = typer.Argument(None, help="The full replacement text"),
+    from_file: Path | None = typer.Option(None, "--from-file", help="Read the replacement text from a file"),
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+    toon_output: bool = typer.Option(False, "--toon", help="TOON output (token-efficient for LLMs)"),
+) -> None:
+    """Replace your profile memory wholesale.
+
+    The repair hatch for when a merge has gone wrong — unlike `add`, this is not
+    length-guarded, so it will happily replace a long blob with a short one.
+    Prefer `add` for ordinary updates.
+
+    Examples:
+        tl memory set "Runs a finance channel. Avoids crypto."
+        tl memory set --from-file ./memory.txt
+    """
+    fmt = detect_format(json_output, False, False, toon_output)
+    err = Console(stderr=True)
+
+    if memory is not None and from_file is not None:
+        err.print("[red]Error:[/red] pass either the replacement text or --from-file, not both.")
+        raise typer.Exit(1)
+    if memory is None and from_file is None:
+        err.print("[red]Error:[/red] pass the replacement text, or --from-file to read it from a file.")
+        raise typer.Exit(1)
+
+    if from_file is not None:
+        try:
+            # utf-8-sig, not utf-8: an editor that writes a byte-order mark leaves it
+            # as the first character of the text, where it is not whitespace, survives
+            # the strip below, and is stored invisibly at the head of the memory.
+            memory = from_file.read_text(encoding="utf-8-sig")
+        # A non-text file raises UnicodeDecodeError, a ValueError rather than an
+        # OSError. The path and the error text are escaped because a bracket in
+        # either would abort on a markup error and lose the message itself.
+        except (OSError, UnicodeDecodeError) as exc:
+            err.print(f"[red]Error:[/red] could not read {rich_escape(str(from_file))}: {rich_escape(str(exc))}")
+            raise typer.Exit(1)
+
+    # A blank replacement erases the whole memory, and the two ways to arrive at one
+    # — a stray empty argument, or a --from-file that was never written — are both
+    # mistakes rather than an intent to erase.
+    memory = (memory or "").strip()
+    if not memory:
+        source = f"{rich_escape(str(from_file))} is empty" if from_file is not None else "the replacement text is empty"
+        err.print(f"[red]Error:[/red] {source}; that would erase your whole memory.")
+        err.print("Pass the text you want stored, or use [bold]tl memory add[/bold] to change one thing at a time.")
+        raise typer.Exit(1)
+
+    client = get_client()
+    try:
+        data = client.post("/memory", json_body={"memory": memory})
+        output_single(data, fmt)
+        # A replacement past the size limit is kept only up to it. The stored length
+        # is in the output either way, but nothing there says text went missing.
+        stored = data.get("profile_memory")
+        if isinstance(stored, str) and len(stored) < len(memory):
+            err.print(
+                f"[bold yellow]Warning:[/bold yellow] [yellow]stored {len(stored):,} of "
+                f"{len(memory):,} characters — the rest was past the size limit.[/yellow]"
+            )
+    except ApiError as e:
+        handle_api_error(e)
+    finally:
+        client.close()

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/src/tl_cli/commands/reports.py

@@ -672,3 +672,109 @@ def update_report(
         handle_api_error(e)
     finally:
         client.close()
+
+
+LINK_ENTITIES = ("channels", "brands", "articles", "sponsorships")
+LINK_TYPES = ("include", "exclude")
+LINK_SOURCE_SIDES = ("included", "excluded")
+
+
+@app.command("link")
+def link_report(
+    report_id: int = typer.Argument(..., help="Target report ID (the report being filtered)"),
+    source: int = typer.Option(..., "--source", "-s", help="Source report ID whose entities are pulled in"),
+    entity: str = typer.Option(..., "--entity", "-e", help=f"Entity type: one of {', '.join(LINK_ENTITIES)}"),
+    filter_type: str = typer.Option(
+        "include", "--type", "-t", help="How the source acts on the target: include or exclude"
+    ),
+    source_side: str = typer.Option(
+        "included",
+        "--source-side",
+        help="Pull the source report's results ('included', default) or its excluded entities ('excluded')",
+    ),
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+    toon_output: bool = typer.Option(False, "--toon", help="TOON output (token-efficient for LLMs)"),
+) -> None:
+    """Link another report into this report as an include/exclude entity source.
+
+    The target report's results are then filtered by the source report's
+    entities of the given type — the same linking the web UI offers, kept
+    in sync automatically (unlike a bulk-import snapshot).
+
+    Examples:
+        tl reports link 1234 --source 5678 --entity channels --type include
+        tl reports link 1234 --source 5678 --entity brands --type exclude
+    """
+    if entity not in LINK_ENTITIES:
+        err.print(f"[red]--entity must be one of: {', '.join(LINK_ENTITIES)}[/red]")
+        raise typer.Exit(2)
+    if filter_type not in LINK_TYPES:
+        err.print(f"[red]--type must be one of: {', '.join(LINK_TYPES)}[/red]")
+        raise typer.Exit(2)
+    if source_side not in LINK_SOURCE_SIDES:
+        err.print(f"[red]--source-side must be one of: {', '.join(LINK_SOURCE_SIDES)}[/red]")
+        raise typer.Exit(2)
+
+    fmt = detect_format(json_output, False, False, toon_output)
+    client = get_client()
+    try:
+        data = client.post(
+            f"/reports/{report_id}/link",
+            json_body={
+                "source_report_id": source,
+                "entity": entity,
+                "filter_type": filter_type,
+                "campaign_entity_type": source_side,
+            },
+        )
+        output_single(data, fmt)
+    except ApiError as e:
+        handle_api_error(e)
+    finally:
+        client.close()
+
+
+@app.command("unlink")
+def unlink_report(
+    report_id: int = typer.Argument(..., help="Target report ID (the report holding the link)"),
+    source: int = typer.Option(..., "--source", "-s", help="Source report ID to unlink"),
+    entity: str | None = typer.Option(
+        None, "--entity", "-e", help=f"Only remove links of this entity type: one of {', '.join(LINK_ENTITIES)}"
+    ),
+    filter_type: str | None = typer.Option(
+        None, "--type", "-t", help="Only remove links of this type: include or exclude"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+    toon_output: bool = typer.Option(False, "--toon", help="TOON output (token-efficient for LLMs)"),
+) -> None:
+    """Remove a report link created with `tl reports link`.
+
+    Without --entity/--type, removes every link pulling from the source
+    report. Narrow with --entity and/or --type to remove a specific one.
+
+    Examples:
+        tl reports unlink 1234 --source 5678
+        tl reports unlink 1234 --source 5678 --entity channels --type exclude
+    """
+    if entity is not None and entity not in LINK_ENTITIES:
+        err.print(f"[red]--entity must be one of: {', '.join(LINK_ENTITIES)}[/red]")
+        raise typer.Exit(2)
+    if filter_type is not None and filter_type not in LINK_TYPES:
+        err.print(f"[red]--type must be one of: {', '.join(LINK_TYPES)}[/red]")
+        raise typer.Exit(2)
+
+    body: dict = {"source_report_id": source}
+    if entity is not None:
+        body["entity"] = entity
+    if filter_type is not None:
+        body["filter_type"] = filter_type
+
+    fmt = detect_format(json_output, False, False, toon_output)
+    client = get_client()
+    try:
+        data = client.post(f"/reports/{report_id}/unlink", json_body=body)
+        output_single(data, fmt)
+    except ApiError as e:
+        handle_api_error(e)
+    finally:
+        client.close()

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/src/tl_cli/commands/whoami.py

@@ -17,6 +17,18 @@ from tl_cli.output.formatter import detect_format
 app = typer.Typer(cls=AlphaSortedTyperGroup, help="Show current user, profile, org, and brands (free)")
 
 
+def _newsletter_subscribed(data: dict) -> bool | None:
+    """Industry Weekly membership, or None when the response doesn't say.
+
+    The field is absent whenever membership can't be determined, so None means
+    unknown — callers must not render it as a "no".
+    """
+    newsletter = data.get("newsletter")
+    if not isinstance(newsletter, dict) or "subscribed" not in newsletter:
+        return None
+    return bool(newsletter["subscribed"])
+
+
 def _render_whoami(data: dict) -> None:
     """Rich-formatted whoami output."""
     console = Console()
@@ -53,6 +65,16 @@ def _render_whoami(data: dict) -> None:
     lines.append("\n")
     lines.append("Joined:  ", style="dim")
     lines.append(user.get("date_joined", "")[:10])
+    # Unknown membership prints no row at all, rather than a "no" the reader
+    # would take as fact.
+    subscribed = _newsletter_subscribed(data)
+    if subscribed is not None:
+        lines.append("\n")
+        lines.append("Weekly:  ", style="dim")
+        lines.append(
+            "subscribed" if subscribed else "not subscribed",
+            style="green" if subscribed else "yellow",
+        )
 
     console.print(Panel(lines, title=title, border_style="cyan"))
 
@@ -141,6 +163,9 @@ def _render_whoami_md(data: dict) -> None:
         print(f"- **Flags:** {', '.join(flags)}")
     print(f"- **Paid:** {'yes' if profile.get('is_paid') else 'no'}")
     print(f"- **Joined:** {user.get('date_joined', '')[:10]}")
+    subscribed = _newsletter_subscribed(data)
+    if subscribed is not None:
+        print(f"- **Industry Weekly:** {'subscribed' if subscribed else 'not subscribed'}")
 
     print(f"\n## Organization: {org.get('name', '')}\n")
     plan = org.get("plan")

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/src/tl_cli/main.py

@@ -22,6 +22,7 @@ from tl_cli.commands.channels import app as channels_app
 from tl_cli.commands.db import app as db_app
 from tl_cli.commands.deals import app as deals_app
 from tl_cli.commands.matches import app as matches_app
+from tl_cli.commands.memory import app as memory_app
 from tl_cli.commands.profiles import app as profiles_app
 from tl_cli.commands.proposals import app as proposals_app
 from tl_cli.commands.recommender import app as recommender_app
@@ -104,6 +105,7 @@ app.add_typer(deals_app, name="deals")
 app.add_typer(uploads_app, name="uploads")
 app.add_typer(channels_app, name="channels")
 app.add_typer(brands_app, name="brands")
+app.add_typer(memory_app, name="memory")
 app.add_typer(profiles_app, name="profiles")
 app.add_typer(recommender_app, name="recommender")
 app.add_typer(snapshots_app, name="snapshots")

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.7}/src/tl_cli/output/formatter.py

@@ -14,6 +14,7 @@ import sys
 
 from pytoon import encode as toon_encode
 from rich.console import Console
+from rich.markup import escape as rich_escape
 from rich.table import Table
 
 # Stderr console for status messages (never pollutes piped data)
@@ -374,6 +375,12 @@ def _output_detail(record: dict) -> None:
     If a value is a non-empty list of dicts, it's rendered as an indented
     sub-table beneath its label instead of stringified. Empty lists show
     `(none)` to signal "no entries" explicitly rather than printing `[]`.
+
+    Field names and values are both data, never markup: a square-bracketed
+    token ("[/finance]" in a free-text note, a `SELECT ... AS "[x]"` alias) is
+    otherwise read as a Rich tag and either swallows the word or aborts the
+    whole command with a markup error. Everything interpolated below is
+    escaped; only the styling this function itself adds stays live.
     """
     console = Console()
     nested_items = [(k, v) for k, v in record.items() if _is_list_of_dicts(v)]
@@ -388,30 +395,35 @@ def _output_detail(record: dict) -> None:
             display = json.dumps(value, default=str)
         else:
             display = value
-        label = f"[bold]{key:<{max_key_len}}[/bold]"
-        console.print(f"  {label}  {display}")
+        # Escape the padded label, not the bare key: the escape only adds
+        # backslashes Rich consumes, so the rendered width still lines up.
+        label = f"[bold]{rich_escape(f'{key:<{max_key_len}}')}[/bold]"
+        console.print(f"  {label}  {rich_escape(str(display))}")
 
     for key, rows in nested_items:
-        console.print(f"\n  [bold]{key}[/bold] ({len(rows)}):")
+        console.print(f"\n  [bold]{rich_escape(key)}[/bold] ({len(rows)}):")
         sub_cols = list(rows[0].keys())
         sub_table = Table(show_header=True, padding=(0, 1))
         for col in sub_cols:
             kwargs: dict = {"overflow": "ellipsis", "max_width": 40}
             if col in _RIGHT_ALIGN_COLS:
                 kwargs["justify"] = "right"
-            sub_table.add_column(col, **kwargs)
+            sub_table.add_column(rich_escape(col), **kwargs)
         for row in rows:
             sub_table.add_row(*[_format_cell(row.get(col)) for col in sub_cols])
         console.print(sub_table)
 
     for key in empty_list_items:
-        console.print(f"\n  [bold]{key}[/bold]: [dim](none)[/dim]")
+        console.print(f"\n  [bold]{rich_escape(key)}[/bold]: [dim](none)[/dim]")
 
 
 def _format_cell(value: object) -> str:
+    """Render one sub-table cell. Escaped for the same reason the detail rows are:
+    Rich reads markup in table cells too, so a bracketed token in free text would
+    vanish or abort the render."""
     if value is None:
         return ""
-    return _truncate(str(value), 40)
+    return rich_escape(_truncate(str(value), 40))
 
 
 def _output_detail_csv(record: dict) -> None: