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

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

@@ -1,6 +1,6 @@
 {
   "name": "tl-cli",
-  "version": "0.9.4",
+  "version": "0.9.8",
   "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.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: thoughtleaders-cli
-Version: 0.9.4
+Version: 0.9.8
 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.8}/hooks/scripts/post-usage.sh

@@ -11,7 +11,7 @@ fi
 
 # Check for 402 (insufficient credits)
 if [[ "$OUTPUT" =~ "402" ]] || [[ "$OUTPUT" =~ "Insufficient credits" ]]; then
-  echo "WARN: Credits exhausted. Deposit more at https://app.thoughtleaders.io/settings/billing" >&2
+  echo "WARN: Credits exhausted. Deposit more at https://app.thoughtleaders.io/billing" >&2
   exit 0
 fi
 

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

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

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

@@ -61,7 +61,7 @@ Retry after 5 seconds if the server returns a "connection denied" or a "server e
 
 Where possible reference sponsorships, brands, channel by numeric IDs.
 
-In raw SQL, match text case-insensitively with `UPPER(x)` on both sides — never `LOWER(x)`, which misses the indexes and times out. See `references/postgres-schema.md`.
+In raw SQL, match text case-insensitively with `UPPER(x)` on both sides — never `LOWER(x)`, which misses the indexes and times out. This includes channel names (`channel_name`, `common_name`), not just handles and URLs. See `references/postgres-schema.md`.
 
 ## Data Model & Terminology
 
@@ -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.8}/skills/tl/references/postgres-schema.md

@@ -8,7 +8,7 @@ Accepted SQL:
 - **SELECT only**, single statement. No DDL/DML/transactions/SET/COPY/MERGE.
 - Functions accepted from an explicit list (aggregates, window, string, JSON, math, date-time, array). Catalog-resolving casts (`::regclass`, `::regprocedure`, …) are not accepted.
 - `LIMIT` and `OFFSET` are optional. Omit them and the server fills in `LIMIT 50 OFFSET 0`. Explicit `LIMIT` must be an integer literal ≤ 10,000. Explicit `OFFSET` ≥ 10,000 is rejected with HTTP 403 (`OFFSET_TOO_DEEP`); paginate with the response's `next_offset`/breadcrumbs instead of jumping deep.
-- **Case-insensitive equality: `UPPER(col) = UPPER('…')` / `UPPER(col) IN (UPPER('…'), …)` — never `LOWER(col)`.** The functional indexes on this database are built on `UPPER(…)` (e.g. channel `url`, `common_name`); a `LOWER(col)` predicate can't use them, seq-scans the 1.3M-row channel table, and dies on statement timeout (504). For substring search use `ILIKE '%…%'` on the bare column instead — that's served by trigram indexes where present (`channel_name`, `slug`).
+- **Case-insensitive equality: `UPPER(col) = UPPER('…')` / `UPPER(col) IN (UPPER('…'), …)` — never `LOWER(col)`.** The case-insensitive functional indexes on this database are built on `UPPER(…)` — on channel `channel_name`, `common_name` and `url`, among others. A `LOWER(col)` predicate can't use them: it seq-scans the 1.3M-row channel table (~20s+) and often dies on statement timeout (504). This holds for channel **names** exactly as it does for handles and URLs — see *Finding a single channel or brand ID* below for the bulk-lookup form. For substring search use `ILIKE '%…%'` on the **bare** column instead — that's served by trigram indexes where present (channel `channel_name`, `slug`; brand `name`, `website`). `LOWER(col) ILIKE '%…%'` is both redundant (`ILIKE` is already case-insensitive) and slow (the trigram index is on the bare column).
 
 ## Core Tables
 
@@ -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.
@@ -260,16 +262,19 @@ thoughtleaders_adlink
 
 As a special case, the `tl channels find` and `tl brands find` commands accept a name of the channel / brand (be sure to properly quote them for the shell) and will return the respective ID. Use this instead of constructing SQL for this particular case. The commands will return a list of possible choices
 
-For bulk handle/name lookups in SQL (e.g. resolving a list of YouTube handles against `common_name`), compare case-insensitively with `UPPER(…)` on both sides — that's the form the functional indexes serve:
+For bulk handle/name lookups in SQL (e.g. resolving a list of YouTube handles against `common_name`, or a list of channel names against `channel_name`), compare case-insensitively with `UPPER(…)` on both sides — that's the form the functional indexes serve:
 
 ```sql
 SELECT id, channel_name, common_name
 FROM thoughtleaders_channel
 WHERE UPPER(common_name) IN (UPPER('@TheInfographicsShow'), UPPER('@DrewDirksen'))
+   OR UPPER(channel_name) IN (UPPER('The Infographics Show'), UPPER('Drew Dirksen'))
 LIMIT 100 OFFSET 0
 ```
 
-`LOWER(common_name)` (or `LOWER()` on any indexed column) cannot use those indexes — it seq-scans and times out.
+Wrap **both** sides in `UPPER(…)`. `UPPER(col) IN ('lowercase literal', …)` matches nothing, since the indexed side is upper-cased.
+
+`LOWER(channel_name)`, `LOWER(common_name)` — or `LOWER()` on any indexed column — cannot use those indexes. Every such predicate is a full sequential scan of 1.3M channel rows: ~20s when it survives, a 504 statement timeout when it doesn't. One `OR LOWER(col) IN (…)` branch is enough to force the scan even when every other branch in the `WHERE` is indexed, so do not mix the two forms.
 
 ### Common Join Paths
 

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.8}/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.8"

thoughtleaders_cli-0.9.8/src/tl_cli/client/errors.py

@@ -0,0 +1,122 @@
+"""User-friendly error handling for API responses."""
+
+import json
+import sys
+import traceback
+
+from rich.console import Console
+
+err = Console(stderr=True)
+
+
+class ApiError(Exception):
+    """Raised when the API returns a non-success status."""
+
+    def __init__(self, status_code: int, detail: str, raw: dict | None = None, url: str | None = None, response_text: str | None = None):
+        self.status_code = status_code
+        self.detail = detail
+        self.raw = raw
+        self.url = url
+        self.response_text = response_text
+        super().__init__(f"HTTP {status_code}: {detail}")
+
+
+def _print_debug(error: ApiError) -> None:
+    """Print detailed debug info for an API error."""
+    from tl_cli.config import debug
+
+    if not debug:
+        return
+    err.print(f"\n[dim]--- debug ---[/dim]")
+    if error.url:
+        err.print(f"[dim]URL: {error.url}[/dim]")
+    err.print(f"[dim]HTTP {error.status_code}: {error.detail}[/dim]")
+    if error.response_text:
+        err.print(f"[dim]Response body:[/dim]")
+        err.print(f"[dim]{error.response_text}[/dim]")
+    err.print(f"[dim]Traceback:[/dim]")
+    err.print(f"[dim]{''.join(traceback.format_exception(error))}[/dim]")
+
+
+def _split_hint(error: ApiError) -> tuple[str, str | None]:
+    """Separate the server's `hint` from `detail`.
+
+    The server sends the remediation both concatenated into `detail` (for
+    older clients) and as a separate `hint` key — render it on its own line
+    so it can't get lost in the error. Used by every branch: a hint on a
+    billing refusal (402/403/429) is just as actionable as one on a 400.
+    """
+    detail = error.detail or ""
+    hint = (error.raw or {}).get("hint") if isinstance(error.raw, dict) else None
+    if isinstance(hint, str) and hint:
+        if detail.endswith(hint):
+            detail = detail[: -len(hint)].rstrip()
+        return detail, hint
+    return detail, None
+
+
+def _print_hint(hint: str | None) -> None:
+    if hint:
+        err.print(f"[bold yellow]Hint:[/bold yellow] [yellow]{hint}[/yellow]")
+
+
+def handle_api_error(error: ApiError) -> None:
+    """Print a user-friendly error message and exit with the right code."""
+    detail, hint = _split_hint(error)
+    if error.status_code == 401:
+        err.print("[red]Authentication required.[/red] Run: tl auth login")
+        _print_debug(error)
+        sys.exit(2)
+    elif error.status_code == 402:
+        # The server composes the whole story into `detail` — a prepaid org is
+        # told to deposit, a subscription org that it can also just wait for
+        # the next top-up — and only the server knows which org this is. The
+        # old fixed copy overwrote that with the same top-up pitch for
+        # everyone. The `tl credits buy` line stays: it is the CLI-native way
+        # to act on the refusal, which the server's sentence can't know about.
+        if detail:
+            err.print(f"[red]{detail}[/red]")
+        else:
+            err.print("[red]Insufficient credits.[/red]")
+            err.print("Or visit: https://app.thoughtleaders.io/billing")
+        _print_hint(hint)
+        err.print("Top up with: [bold]tl credits buy --amount-usd 10[/bold]")
+        _print_debug(error)
+        sys.exit(4)
+    elif error.status_code == 403:
+        # Verbatim, with no upsell line of our own: a billing 403's detail
+        # already names the paid plan (UPGRADE_MESSAGE and friends), and the
+        # rest of the 403s — "Superuser only", permission errors — are not
+        # plan problems, so "your plan may not include this" was misdirection
+        # exactly where the user needed the real reason.
+        err.print(f"[red]Access denied:[/red] {detail}")
+        _print_hint(hint)
+        _print_debug(error)
+        sys.exit(1)
+    elif error.status_code == 404:
+        err.print(f"[yellow]Not found:[/yellow] {detail}")
+        _print_hint(hint)
+        _print_debug(error)
+        sys.exit(1)
+    elif error.status_code == 429:
+        # Both quota gates refuse with 429 and compose the whole explanation
+        # into `detail` — which cap was hit, how much of it is used, and when it
+        # frees up. Collapsing that to a flat "rate limited" line drops the only
+        # thing that tells the user whether to wait, buy credits, or ask for a
+        # seat. An edge/WAF 429 carries no detail and keeps the generic wording.
+        if detail:
+            err.print(f"[yellow]{detail}[/yellow]")
+        else:
+            err.print("[yellow]Rate limited.[/yellow] Please wait and try again.")
+        _print_hint(hint)
+        _print_debug(error)
+        sys.exit(3)
+    elif error.status_code >= 500:
+        err.print(f"[red]Server error ({error.status_code}):[/red] {error.detail}")
+        _print_debug(error)
+        sys.exit(3)
+    else:
+        err.print(f"[red]Error ({error.status_code}):[/red] {detail}")
+        _print_hint(hint)
+        _print_debug(error)
+        sys.exit(1)

{thoughtleaders_cli-0.9.4 → thoughtleaders_cli-0.9.8}/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.4 → thoughtleaders_cli-0.9.8}/src/tl_cli/commands/balance.py

@@ -53,6 +53,17 @@ def balance(
         if allow_overage:
             console.print("[dim]Overage: enabled[/dim]")
 
+        # The server's own read on the caller's allowance — the session-quota
+        # percentage, or the seatless explanation. This is the same sentence
+        # the refusal path uses, so a seatless member learns why from
+        # `tl balance` instead of only from their first refused call (it used
+        # to be visible solely under --json).
+        usage = data.get("credit_usage") or {}
+        usage_message = usage.get("message")
+        if isinstance(usage_message, str) and usage_message:
+            style = "yellow" if usage.get("warn") else "dim"
+            console.print(f"[{style}]{usage_message}[/{style}]")
+
         # Top-up hint when running low. Threshold matches the hook warning
         # that nudges the user before they hit 0.
         try:
@@ -63,7 +74,7 @@ def balance(
             console.print(
                 "[yellow]Running low.[/yellow] Top up with: "
                 "[bold]tl credits buy --amount-usd 10[/bold] "
-                "(or https://app.thoughtleaders.io/billing/cli)"
+                "(or https://app.thoughtleaders.io/billing)"
             )
 
         recent = data.get("recent_usage", [])

thoughtleaders_cli-0.9.8/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.8}/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.8}/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")