@senso-ai/cli 0.11.1 → 0.12.0

package/README.md

@@ -214,6 +214,63 @@ senso prompts delete <promptId>      Delete a prompt
 
 Options: `prompts list` supports `--limit`, `--offset`, `--search`, `--sort`.
 
+### Analytics (GEO)
+
+Read-only metrics for your own organization: how often the AI models name your brand, your share of every brand mention the models made, and which domains and pages get cited. Works with the organization API key from `senso login`.
+
+```
+senso analytics summary              Headline metrics + previous window + deltas
+senso analytics mentions             Visibility time series (day or week buckets)
+senso analytics citations            Citation rates and shares, with the series
+senso analytics domains              Cited domains, ranked (coverage + share)
+senso analytics pages                Cited pages, with the prompts driving them
+senso analytics prompts              Per-prompt performance table
+senso analytics prompt <promptId>    One prompt: history + latest full answers
+senso analytics answers              Latest answer per prompt × model × location
+senso analytics glossary             Canonical definition of every metric
+senso analytics filters              Filter values that have data for this org
+```
+
+Options:
+
+| Command | Options |
+|---------|---------|
+| all except `prompt <promptId>`, `glossary`, `filters` | `--from`, `--to`, `--models`, `--location`, `--prompt-type`, `--tag` |
+| `mentions`, `citations` | `--group-by <day\|week>` |
+| `domains` | `--tier`, `--domain-contains`, `--sort <citations\|coverage>`, `--limit`, `--offset` |
+| `pages` | `--tier`, `--domain`, `--domain-contains`, `--url-contains`, `--sort <citations\|coverage>`, `--limit`, `--offset` |
+| `prompts` | `--search`, `--sort <mention_rate\|share_of_voice\|citations\|answered\|text>`, `--order <asc\|desc>`, `--limit`, `--offset` |
+| `prompt <promptId>` | `--from`, `--to`, `--models`, `--location`, `--no-include-answers` |
+| `answers` | `--from`, `--to`, `--models`, `--location`, `--prompt-type`, `--tag`, `--mentioned <bool>`, `--cited <bool>`, `--citation-tier <primary\|tracked\|secondary>`, `--limit`, `--offset` |
+
+`--from`/`--to` are `YYYY-MM-DD` and default to the 30 days ending at the most recent day that has data for your model/location filter (max window: 365 days). `--models` and `--location` are comma-separated; locations are case-sensitive exact codes (`US`, `US/California`) — the API also accepts `locations` as an alias for the `location` query param. Run `senso analytics filters` to see the values that actually have data.
+
+`analytics answers` is a snapshot, not a window. It always returns the newest stored answer per prompt × model × location, and `--from`/`--to` filter on `run_at` — when that answer was collected. Narrowing the window therefore **hides** prompt × model × location combinations whose latest answer falls outside it; it does not return older answers in their place. Use `analytics mentions` or `analytics citations` for history.
+
+Reading the numbers:
+
+- **Share of Voice** is your mention instances ÷ `brand_mention_total` — mentions of *every* brand the models named, not just your tracked competitors. It matches the Share of Voice in the Senso app. `tracked_mention_total` is still returned as a raw count in `totals`, but it is not the denominator.
+- **Citation Rate** and **Citation Coverage** divide by `D` — answers with at least one citation. **Citation Share** divides by `S` — total citation instances. They are different metrics on different denominators; every table shows the numerator and denominator next to the percentage so you can check.
+- The three tier **rates** are independent and can sum past 100% (one answer can cite an owned page and an external page). The three tier **shares** partition and sum to exactly 100%.
+- A metric renders as `—` when its denominator was zero. That is "not measured", not 0%.
+- Every response carries `notes[]` — caveats about window truncation, null denominators and tracking-set dependence. They are printed under a **Notes** heading in `plain` and `table` output, and are part of the payload in `--output json`.
+- `senso analytics glossary` is the canonical definition, denominator and gotcha for every metric.
+
+### Industry Intelligence (partner key required)
+
+```
+senso industries list                List industries visible to the partner
+senso industries summary <industry>  Industry overview over a time window
+senso industries brand <industry> <brandName>    One brand within an industry
+senso industries domain <industry> <domainOrUrl> Domain/URL citation lookup
+senso industries prompt-metrics <industry>       Per-prompt industry metrics
+senso industries glossary            Competitive-intelligence metric glossary
+```
+
+These commands read partner-scoped endpoints and **require a partner API key**. The organization key stored by `senso login` is rejected with a 401/403 — pass a partner key with `--api-key <key>` or `SENSO_API_KEY`. For metrics about your own organization, use `senso analytics` instead.
+
+Options: all except `list` and `glossary` support `--from`, `--to`, `--location`, `--models`; `prompt-metrics` also supports `--limit`, `--offset`; `list` supports `--search`. The `<industry>` argument accepts a UUID or a name (e.g. `"Automotive"`).
+
 ### Organization
 
 ```
@@ -248,15 +305,6 @@ senso run-config schedule            Get run schedule (days of week)
 senso run-config set-schedule        Set run schedule (--data)
 ```
 
-### Notifications
-
-```
-senso notifications list             List notifications
-senso notifications read <id>        Mark notification as read
-```
-
-Options: `notifications list` supports `--limit`, `--offset`, `--unread-only`.
-
 ### CLI Management
 
 ```
@@ -327,7 +375,7 @@ cnt_def456   Variable Rate Products   draft
 
 ## Auto-Update
 
-The CLI checks for new versions once every 24 hours (via GitHub releases) and shows a notice on stderr if an update is available:
+The CLI checks for new versions once every 24 hours (via the npm registry) and shows a notice on stderr if an update is available:
 
 ```
 ╭──────────────────────────────────────────────╮
@@ -386,12 +434,13 @@ src/
 │   ├── brand-kit.ts       # get, set
 │   ├── content-types.ts   # CRUD
 │   ├── prompts.ts         # CRUD
+│   ├── analytics.ts       # org GEO analytics (summary, citations, prompts, …)
+│   ├── industries.ts      # partner-scoped competitive intelligence
 │   ├── org.ts             # get, update
 │   ├── users.ts           # CRUD + set-current
 │   ├── api-keys.ts        # CRUD + revoke
 │   ├── members.ts         # list
 │   ├── run-config.ts      # models, schedule
-│   ├── notifications.ts   # list, read
 │   └── update.ts          # self-update
 ├── lib/
 │   ├── api-client.ts      # HTTP wrapper (native fetch, X-API-Key auth)
@@ -401,7 +450,7 @@ src/
 └── utils/
     ├── logger.ts          # Colored log helpers (picocolors)
     ├── branding.ts        # ASCII logo, gradient banner, boxed panels
-    └── updater.ts         # GitHub releases version check
+    └── updater.ts         # npm registry version check
 ```
 
 ### Tech Stack
@@ -420,7 +469,7 @@ src/
 
 ### Releasing a New Version
 
-This project uses [semantic versioning](https://semver.org/). The CLI's auto-update checker compares the installed version against the latest GitHub release using semver, so pre-release tags and version ordering are handled correctly.
+This project uses [semantic versioning](https://semver.org/). Publishing to npm is automated: pushing a `v*` tag runs `.github/workflows/publish.yml`, which builds the CLI and publishes it via [npm Trusted Publishing](https://docs.npmjs.com/trusted-publishers) (GitHub Actions OIDC, no token secrets). Every pull request and push to `main` runs `.github/workflows/ci.yml` (typecheck, build, tests, smoke test).
 
 ```bash
 # 1. Bump the version in package.json, commit, and create a git tag
@@ -428,14 +477,11 @@ npm version patch   # 0.1.0 → 0.1.1 (bug fixes)
 npm version minor   # 0.1.0 → 0.2.0 (new features, backwards-compatible)
 npm version major   # 0.1.0 → 1.0.0 (breaking changes)
 
-# 2. Push the commit and tag
-git push origin main --tags
-
-# 3. Create a GitHub release (this is what the auto-updater checks)
-gh release create v0.2.0 --title "v0.2.0" --notes "Release notes here"
+# 2. Push the commit and tag — the tag triggers the publish workflow
+git push --follow-tags
 ```
 
-After step 3, users running the CLI will see the update notice within 24 hours (or immediately via `senso update`).
+The publish workflow refuses to run if the tag does not match the version in `package.json`. Once it finishes, users running the CLI will see the update notice within 24 hours (or immediately via `senso update`).
 
 ---
 

package/dist/cli.js

@@ -1230,7 +1230,7 @@ async function uploadToS3(url, buffer, contentType) {
   const res = await fetch(url, {
     method: "PUT",
     headers: { "Content-Type": contentType },
-    body: buffer
+    body: new Uint8Array(buffer)
   });
   if (!res.ok) {
     throw new Error(`S3 upload failed: ${res.status} ${res.statusText}`);
@@ -2576,7 +2576,7 @@ async function uploadToS32(url, buffer, contentType) {
   const res = await fetch(url, {
     method: "PUT",
     headers: { "Content-Type": contentType },
-    body: buffer
+    body: new Uint8Array(buffer)
   });
   if (!res.ok) throw new Error(`S3 upload failed: ${res.status} ${res.statusText}`);
 }
@@ -3356,14 +3356,952 @@ function registerGeneratedContentCommands(program2) {
   });
 }
 
+// src/commands/analytics.ts
+import pc10 from "picocolors";
+var NO_VALUE = "\u2014";
+function rate(r) {
+  return r && typeof r.display === "string" ? r.display : NO_VALUE;
+}
+function count(v) {
+  return v === void 0 || v === null ? NO_VALUE : v.toLocaleString("en-US");
+}
+function position(v) {
+  return v === void 0 || v === null ? NO_VALUE : `#${v.toFixed(1)}`;
+}
+function trend(t) {
+  return t ? `${t.display} (${t.direction})` : NO_VALUE;
+}
+function ratio(numerator, denominator, unit) {
+  return `${count(numerator)} / ${count(denominator)} ${unit}`;
+}
+function truncate(value, max) {
+  const flat = (value ?? "").replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function windowLine(w) {
+  if (!w) return "";
+  const fresh = w.latest_data_day ? `, latest data ${w.latest_data_day}` : ", no data days in window";
+  return `  ${pc10.dim(`Window ${w.from} \u2192 ${w.to} (${w.days} days${fresh})`)}`;
+}
+function qualityLine(dq) {
+  if (!dq) return "";
+  return `  ${pc10.dim(`Data quality: ${dq.level} \u2014 ${count(dq.answered_count)} answered runs`)}`;
+}
+function emitContext(format, lines) {
+  if (format !== "table") return;
+  const visible = lines.filter(Boolean);
+  if (visible.length === 0) return;
+  outputPlain([...visible, ""]);
+}
+function emitNotes(format, notes) {
+  if (format === "json" || !notes || notes.length === 0) return;
+  outputPlain([
+    "",
+    `  ${pc10.bold("Notes")}`,
+    ...notes.map((note) => `  ${pc10.dim("\u2022")} ${note}`)
+  ]);
+}
+function windowParams(o) {
+  return {
+    from: o.from,
+    to: o.to,
+    models: o.models,
+    location: o.location,
+    prompt_type: o.promptType,
+    tag: o.tag
+  };
+}
+function addWindowOptions(cmd, opts = {}) {
+  const withTag = opts.tag !== false;
+  const base = cmd.option("--from <date>", "Window start, YYYY-MM-DD (default: 30 days ending at the most recent day with data)").option("--to <date>", "Window end, YYYY-MM-DD (max window: 365 days)").option("--models <list>", "Comma-separated model filter \u2014 see 'senso analytics filters'").option("--location <list>", "Comma-separated location filter, case-sensitive (e.g. US, US/California)").option("--prompt-type <type>", "Funnel stage: awareness | consideration | evaluation | decision");
+  return withTag ? base.option("--tag <tag>", "Restrict to prompts carrying this tag") : base;
+}
+function addPagingOptions(cmd, defaultLimit) {
+  return cmd.option("--limit <n>", `Maximum rows to return (default: ${defaultLimit}, max: 100)`).option("--offset <n>", "Rows to skip (for pagination)");
+}
+var BOOL_VALUES = /* @__PURE__ */ new Set(["true", "false", "1", "0", "yes", "no"]);
+function normalizeBool(flag, raw) {
+  if (raw === void 0) return void 0;
+  const value = raw.trim().toLowerCase();
+  if (!BOOL_VALUES.has(value)) {
+    error(`Invalid --${flag}: expected true or false.`);
+    process.exit(1);
+  }
+  return value;
+}
+function metricRows(totals, metrics, deltas) {
+  return [
+    {
+      metric: "Mention Rate",
+      value: rate(metrics.mention_rate),
+      counts: ratio(totals.mentioned_count, totals.answered_count, "answers"),
+      "vs prev": trend(deltas?.mention_rate)
+    },
+    {
+      metric: "Share of Voice",
+      value: rate(metrics.share_of_voice),
+      counts: ratio(totals.mention_total, totals.brand_mention_total, "mentions (all brands)"),
+      "vs prev": trend(deltas?.share_of_voice)
+    },
+    {
+      metric: "Avg Rank",
+      value: rate(metrics.avg_rank),
+      counts: `over ${count(totals.mentioned_count)} mentioned answers`,
+      "vs prev": NO_VALUE
+    },
+    {
+      metric: "Citation Rate (Owned)",
+      value: rate(metrics.primary_citation_rate),
+      counts: ratio(totals.primary_cited_run_count, totals.cited_run_count, "cited answers"),
+      "vs prev": trend(deltas?.primary_citation_rate)
+    },
+    {
+      metric: "Citation Rate (Tracked)",
+      value: rate(metrics.tracked_citation_rate),
+      counts: ratio(totals.tracked_cited_run_count, totals.cited_run_count, "cited answers"),
+      "vs prev": NO_VALUE
+    },
+    {
+      metric: "Citation Rate (External)",
+      value: rate(metrics.external_citation_rate),
+      counts: ratio(totals.external_cited_run_count, totals.cited_run_count, "cited answers"),
+      "vs prev": NO_VALUE
+    },
+    {
+      metric: "Citation Share (Owned)",
+      value: rate(metrics.primary_citation_share),
+      counts: ratio(totals.primary_cited_total, totals.cited_total, "citations"),
+      "vs prev": NO_VALUE
+    },
+    {
+      metric: "Citation Share (Tracked)",
+      value: rate(metrics.tracked_citation_share),
+      counts: ratio(totals.tracked_cited_total, totals.cited_total, "citations"),
+      "vs prev": NO_VALUE
+    },
+    {
+      metric: "Citation Share (External)",
+      value: rate(metrics.external_citation_share),
+      counts: ratio(totals.external_cited_total, totals.cited_total, "citations"),
+      "vs prev": NO_VALUE
+    },
+    {
+      metric: "Citations per Answer",
+      value: rate(metrics.citations_per_answer),
+      counts: ratio(totals.cited_total, totals.cited_run_count, "cited answers"),
+      "vs prev": NO_VALUE
+    },
+    {
+      metric: "Sentiment (pos/neu/neg)",
+      value: `${count(totals.sentiment?.positive)} / ${count(totals.sentiment?.neutral)} / ${count(totals.sentiment?.negative)}`,
+      counts: `sums to ${count(totals.mentioned_count)} mentioned answers`,
+      "vs prev": NO_VALUE
+    }
+  ];
+}
+var METRIC_COLUMNS = ["metric", "value", "counts", "vs prev"];
+function metricPlainLines(rows) {
+  const width = rows.reduce((max, r) => Math.max(max, String(r.metric).length), 0);
+  return rows.map(
+    (r) => `  ${pc10.bold(String(r.metric).padEnd(width))}  ${String(r.value)}  ${pc10.dim(`(${r.counts})`)}` + (r["vs prev"] !== NO_VALUE ? `  ${pc10.dim(`vs prev: ${r["vs prev"]}`)}` : "")
+  );
+}
+function registerAnalyticsCommands(program2) {
+  const analytics = program2.command("analytics").description(
+    "GEO analytics for your organization \u2014 brand visibility, share of voice, and citations across the AI models you monitor. Every payload ships raw counts alongside the rates, and a rate is null (shown as \u201C\u2014\u201D) when its denominator is zero, never a silent 0%. Run 'senso analytics glossary' for the canonical definition and denominator of every metric."
+  );
+  addWindowOptions(
+    analytics.command("summary").description(
+      "One-call dashboard: every headline metric with its raw counts, plus the preceding equal-length window and the deltas between them."
+    )
+  ).action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const format = opts.output || "plain";
+    try {
+      const data = await apiRequest({
+        path: "/org/analytics/summary",
+        params: windowParams(cmdOpts),
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      const rows = metricRows(data.totals, data.metrics, data.deltas);
+      emitContext(format, [
+        "",
+        `  ${pc10.bold("Analytics summary")}`,
+        windowLine(data.window),
+        qualityLine(data.data_quality)
+      ]);
+      output(format, {
+        json: data,
+        table: { rows, columns: METRIC_COLUMNS },
+        plain: [
+          "",
+          `  ${pc10.bold("Analytics summary")}`,
+          windowLine(data.window),
+          qualityLine(data.data_quality),
+          "",
+          ...metricPlainLines(rows),
+          "",
+          `  ${pc10.dim(`Monitoring ${count(data.totals.prompt_count)} prompts \xD7 ${count(data.totals.model_count)} models \xD7 ${count(data.totals.location_count)} locations \u2014 ${count(data.totals.answered_count)} of ${count(data.totals.run_count)} runs answered`)}`
+        ]
+      });
+      emitNotes(format, data.notes);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  addWindowOptions(
+    analytics.command("mentions").description(
+      "Visibility time series: mention counts, share of voice (your mentions \xF7 mentions of every brand), average rank and sentiment, bucketed by day or week."
+    )
+  ).option("--group-by <bucket>", "Time bucket: day | week (default: day)").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const format = opts.output || "plain";
+    try {
+      const data = await apiRequest({
+        path: "/org/analytics/mentions",
+        params: { ...windowParams(cmdOpts), group_by: cmdOpts.groupBy },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      const series = data.series ?? [];
+      const context = [
+        "",
+        `  ${pc10.bold("Mentions")} ${pc10.dim(`by ${data.group_by}`)}`,
+        windowLine(data.window),
+        qualityLine(data.data_quality),
+        `  ${pc10.dim(`Window totals \u2014 mention rate ${rate(data.metrics.mention_rate)}, share of voice ${rate(data.metrics.share_of_voice)}, avg rank ${rate(data.metrics.avg_rank)}`)}`
+      ];
+      emitContext(format, context);
+      output(format, {
+        json: data,
+        table: {
+          rows: series.map((p4) => ({
+            period: p4.period_start,
+            answered: count(p4.answered_count),
+            mentioned: count(p4.mentioned_count),
+            mention_rate: rate(p4.mention_rate),
+            sov: rate(p4.share_of_voice),
+            avg_rank: rate(p4.avg_rank)
+          })),
+          columns: ["period", "answered", "mentioned", "mention_rate", "sov", "avg_rank"]
+        },
+        plain: [
+          ...context,
+          "",
+          ...series.length ? series.map(
+            (p4) => `  ${pc10.bold(p4.period_start)}  answered ${count(p4.answered_count)}  mentioned ${count(p4.mentioned_count)}  rate ${rate(p4.mention_rate)}  SoV ${rate(p4.share_of_voice)}  rank ${rate(p4.avg_rank)}`
+          ) : ["  No rollup days in this window."]
+        ]
+      });
+      emitNotes(format, data.notes);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  addWindowOptions(
+    analytics.command("citations").description(
+      "Citation overview: both denominators (D = cited answers, S = citation instances), every tier numerator, the tier rates (\xF7D) and tier shares (\xF7S), and the series underneath."
+    )
+  ).option("--group-by <bucket>", "Time bucket: day | week (default: day)").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const format = opts.output || "plain";
+    try {
+      const data = await apiRequest({
+        path: "/org/analytics/citations",
+        params: { ...windowParams(cmdOpts), group_by: cmdOpts.groupBy },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      const series = data.series ?? [];
+      const context = [
+        "",
+        `  ${pc10.bold("Citations")} ${pc10.dim(`by ${data.group_by}`)}`,
+        windowLine(data.window),
+        qualityLine(data.data_quality),
+        `  ${pc10.dim(`D = ${count(data.totals.cited_run_count)} cited answers, S = ${count(data.totals.cited_total)} citation instances`)}`,
+        `  ${pc10.dim(`Owned rate ${rate(data.metrics.primary_citation_rate)} (\xF7D) \xB7 Owned share ${rate(data.metrics.primary_citation_share)} (\xF7S) \xB7 ${rate(data.metrics.citations_per_answer)}`)}`
+      ];
+      emitContext(format, context);
+      output(format, {
+        json: data,
+        table: {
+          rows: series.map((p4) => ({
+            period: p4.period_start,
+            cited_answers: count(p4.cited_run_count),
+            citations: count(p4.cited_total),
+            owned_rate: rate(p4.primary_citation_rate),
+            tracked_rate: rate(p4.tracked_citation_rate),
+            external_rate: rate(p4.external_citation_rate),
+            owned_share: rate(p4.primary_citation_share)
+          })),
+          columns: [
+            "period",
+            "cited_answers",
+            "citations",
+            "owned_rate",
+            "tracked_rate",
+            "external_rate",
+            "owned_share"
+          ]
+        },
+        plain: [
+          ...context,
+          "",
+          ...series.length ? series.map(
+            (p4) => `  ${pc10.bold(p4.period_start)}  cited answers ${count(p4.cited_run_count)}  citations ${count(p4.cited_total)}  owned ${rate(p4.primary_citation_rate)}  tracked ${rate(p4.tracked_citation_rate)}  external ${rate(p4.external_citation_rate)}`
+          ) : ["  No rollup days in this window."]
+        ]
+      });
+      emitNotes(format, data.notes);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  addPagingOptions(
+    addWindowOptions(
+      analytics.command("domains").description(
+        "Every domain the models cited, ranked. Citation Coverage is this domain's cited answers \xF7 D; Citation Share is its citation instances \xF7 S. Tiers: primary (Owned) | tracked | secondary (External)."
+      ),
+      { tag: false }
+    ).option("--tier <tier>", "Filter by tier: primary | tracked | secondary").option("--domain-contains <text>", "Substring filter on the domain").option("--sort <field>", "Sort by: citations | coverage (default: citations)"),
+    50
+  ).action(
+    async (cmdOpts) => {
+      const opts = program2.opts();
+      const format = opts.output || "plain";
+      try {
+        const data = await apiRequest({
+          path: "/org/analytics/citations/domains",
+          params: {
+            ...windowParams(cmdOpts),
+            tier: cmdOpts.tier,
+            domain_contains: cmdOpts.domainContains,
+            sort: cmdOpts.sort,
+            limit: cmdOpts.limit,
+            offset: cmdOpts.offset
+          },
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+        const domains = data.domains ?? [];
+        const context = [
+          "",
+          `  ${pc10.bold("Cited domains")} ${pc10.dim(`${domains.length} of ${count(data.total)} (offset ${count(data.offset)})`)}`,
+          windowLine(data.window),
+          qualityLine(data.data_quality),
+          `  ${pc10.dim(`D = ${count(data.denominators?.cited_run_count)} cited answers, S = ${count(data.denominators?.cited_total)} citation instances`)}`
+        ];
+        emitContext(format, context);
+        output(format, {
+          json: data,
+          table: {
+            rows: domains.map((d) => ({
+              rank: d.rank_by_citations,
+              domain: d.domain,
+              tier: d.tier_label || d.tier,
+              answers: count(d.cited_run_count),
+              citations: count(d.cited_total),
+              coverage: rate(d.citation_coverage),
+              share: rate(d.citation_share),
+              avg_pos: position(d.avg_citation_rank)
+            })),
+            columns: [
+              "rank",
+              "domain",
+              "tier",
+              "answers",
+              "citations",
+              "coverage",
+              "share",
+              "avg_pos"
+            ]
+          },
+          plain: [
+            ...context,
+            "",
+            ...domains.length ? domains.map(
+              (d) => `  ${pc10.dim(`#${d.rank_by_citations}`)} ${pc10.bold(d.domain)} ${pc10.dim(`[${d.tier_label || d.tier}]`)}
+     coverage ${rate(d.citation_coverage)} \xB7 share ${rate(d.citation_share)} \xB7 ${count(d.cited_run_count)} cited answers \xB7 ${count(d.cited_total)} citations \xB7 avg position ${position(d.avg_citation_rank)}`
+            ) : ["  No cited domains in this window."]
+          ]
+        });
+        emitNotes(format, data.notes);
+      } catch (err) {
+        error(formatApiError(err));
+        process.exit(1);
+      }
+    }
+  );
+  addPagingOptions(
+    addWindowOptions(
+      analytics.command("pages").description(
+        "URL-grain citation table plus the prompts driving each page's citations. Same Coverage (\xF7D) and Share (\xF7S) denominators as 'analytics domains'."
+      ),
+      { tag: false }
+    ).option("--tier <tier>", "Filter by tier: primary | tracked | secondary").option("--domain <domain>", "Restrict to one exact domain").option("--domain-contains <text>", "Substring filter on the domain").option("--url-contains <text>", "Substring filter on the URL").option("--sort <field>", "Sort by: citations | coverage (default: citations)"),
+    50
+  ).action(
+    async (cmdOpts) => {
+      const opts = program2.opts();
+      const format = opts.output || "plain";
+      try {
+        const data = await apiRequest({
+          path: "/org/analytics/citations/pages",
+          params: {
+            ...windowParams(cmdOpts),
+            tier: cmdOpts.tier,
+            domain: cmdOpts.domain,
+            domain_contains: cmdOpts.domainContains,
+            url_contains: cmdOpts.urlContains,
+            sort: cmdOpts.sort,
+            limit: cmdOpts.limit,
+            offset: cmdOpts.offset
+          },
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+        const pages = data.pages ?? [];
+        const context = [
+          "",
+          `  ${pc10.bold("Cited pages")} ${pc10.dim(`${pages.length} of ${count(data.total)} (offset ${count(data.offset)})`)}`,
+          windowLine(data.window),
+          qualityLine(data.data_quality),
+          `  ${pc10.dim(`D = ${count(data.denominators?.cited_run_count)} cited answers, S = ${count(data.denominators?.cited_total)} citation instances`)}`
+        ];
+        emitContext(format, context);
+        output(format, {
+          json: data,
+          table: {
+            rows: pages.map((p4) => ({
+              url: truncate(p4.url, 70),
+              tier: p4.tier_label || p4.tier,
+              answers: count(p4.cited_run_count),
+              citations: count(p4.cited_total),
+              coverage: rate(p4.citation_coverage),
+              share: rate(p4.citation_share),
+              avg_pos: position(p4.avg_citation_rank)
+            })),
+            columns: [
+              "url",
+              "tier",
+              "answers",
+              "citations",
+              "coverage",
+              "share",
+              "avg_pos"
+            ]
+          },
+          plain: [
+            ...context,
+            "",
+            ...pages.length ? pages.map(
+              (p4) => [
+                `  ${pc10.bold(p4.url)} ${pc10.dim(`[${p4.tier_label || p4.tier}]`)}`,
+                `     coverage ${rate(p4.citation_coverage)} \xB7 share ${rate(p4.citation_share)} \xB7 ${count(p4.cited_run_count)} cited answers \xB7 ${count(p4.cited_total)} citations`,
+                ...(p4.top_prompts ?? []).map(
+                  (tp) => `     ${pc10.dim(`\u21B3 ${truncate(tp.prompt_text, 80)} (${count(tp.cited_run_count)} cited answers)`)}`
+                )
+              ].join("\n")
+            ) : ["  No cited pages in this window."]
+          ]
+        });
+        emitNotes(format, data.notes);
+      } catch (err) {
+        error(formatApiError(err));
+        process.exit(1);
+      }
+    }
+  );
+  addPagingOptions(
+    addWindowOptions(
+      analytics.command("prompts").description(
+        "Per-prompt performance over the window \u2014 sort ascending by mention_rate to find the prompts where you are invisible. Drill into one with 'senso analytics prompt <promptId>'."
+      )
+    ).option("--search <query>", "Filter prompts by question text").option(
+      "--sort <field>",
+      "Sort by: mention_rate | share_of_voice | citations | answered | text (default: mention_rate)"
+    ).option("--order <dir>", "Sort direction: asc | desc (default: desc)"),
+    50
+  ).action(
+    async (cmdOpts) => {
+      const opts = program2.opts();
+      const format = opts.output || "plain";
+      try {
+        const data = await apiRequest({
+          path: "/org/analytics/prompts",
+          params: {
+            ...windowParams(cmdOpts),
+            search: cmdOpts.search,
+            sort: cmdOpts.sort,
+            order: cmdOpts.order,
+            limit: cmdOpts.limit,
+            offset: cmdOpts.offset
+          },
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+        const prompts = data.prompts ?? [];
+        const context = [
+          "",
+          `  ${pc10.bold("Prompt performance")} ${pc10.dim(`${prompts.length} of ${count(data.total)} (offset ${count(data.offset)})`)}`,
+          windowLine(data.window),
+          qualityLine(data.data_quality),
+          `  ${pc10.dim(`Org-wide over the same window \u2014 mention rate ${rate(data.metrics.mention_rate)}, share of voice ${rate(data.metrics.share_of_voice)}`)}`
+        ];
+        emitContext(format, context);
+        output(format, {
+          json: data,
+          table: {
+            rows: prompts.map((p4) => ({
+              prompt_id: p4.prompt_id,
+              prompt: truncate(p4.prompt_text, 40),
+              answered: count(p4.answered_count),
+              mention_rate: rate(p4.mention_rate),
+              sov: rate(p4.share_of_voice),
+              latest_sov: rate(p4.latest?.share_of_voice ?? null),
+              avg_rank: rate(p4.avg_rank),
+              owned_cite_rate: rate(p4.primary_citation_rate)
+            })),
+            columns: [
+              "prompt_id",
+              "prompt",
+              "answered",
+              "mention_rate",
+              "sov",
+              "latest_sov",
+              "avg_rank",
+              "owned_cite_rate"
+            ]
+          },
+          plain: [
+            ...context,
+            "",
+            ...prompts.length ? prompts.map(
+              (p4) => [
+                `  ${pc10.bold(truncate(p4.prompt_text, 100))} ${pc10.dim(`[${p4.prompt_type}]`)}`,
+                `     mention rate ${rate(p4.mention_rate)} (${count(p4.mentioned_count)}/${count(p4.answered_count)}) \xB7 SoV ${rate(p4.share_of_voice)} (window) \xB7 ${rate(p4.latest?.share_of_voice ?? null)} (latest) \xB7 avg rank ${rate(p4.avg_rank)} \xB7 owned citation rate ${rate(p4.primary_citation_rate)}`,
+                `     ${pc10.dim(`ID: ${p4.prompt_id}${p4.tags?.length ? ` \xB7 tags: ${p4.tags.join(", ")}` : ""}`)}`
+              ].join("\n")
+            ) : ["  No prompts matched this filter."]
+          ]
+        });
+        emitNotes(format, data.notes);
+      } catch (err) {
+        error(formatApiError(err));
+        process.exit(1);
+      }
+    }
+  );
+  analytics.command("prompt <promptId>").description(
+    "One prompt end to end: its metric history over the window plus the latest full answer from every model \xD7 location."
+  ).option("--from <date>", "Window start, YYYY-MM-DD").option("--to <date>", "Window end, YYYY-MM-DD").option("--models <list>", "Comma-separated model filter").option("--location <list>", "Comma-separated location filter, case-sensitive").option("--no-include-answers", "Omit the latest answer bodies (included by default)").action(
+    async (promptId, cmdOpts) => {
+      const opts = program2.opts();
+      const format = opts.output || "plain";
+      try {
+        const data = await apiRequest({
+          path: `/org/analytics/prompts/${promptId}`,
+          params: {
+            from: cmdOpts.from,
+            to: cmdOpts.to,
+            models: cmdOpts.models,
+            location: cmdOpts.location,
+            include_answers: cmdOpts.includeAnswers === false ? "false" : void 0
+          },
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+        const series = data.series ?? [];
+        const answers = data.latest_answers ?? [];
+        const rows = metricRows(data.totals, data.metrics);
+        const context = [
+          "",
+          `  ${pc10.bold(data.prompt_text)} ${pc10.dim(`[${data.prompt_type}]`)}`,
+          `  ${pc10.dim(`ID: ${data.prompt_id}${data.tags?.length ? ` \xB7 tags: ${data.tags.join(", ")}` : ""}`)}`,
+          windowLine(data.window),
+          qualityLine(data.data_quality)
+        ];
+        emitContext(format, context);
+        output(format, {
+          json: data,
+          table: {
+            rows: series.map((p4) => ({
+              period: p4.period_start,
+              answered: count(p4.answered_count),
+              mentioned: count(p4.mentioned_count),
+              mention_rate: rate(p4.mention_rate),
+              sov: rate(p4.share_of_voice),
+              avg_rank: rate(p4.avg_rank)
+            })),
+            columns: [
+              "period",
+              "answered",
+              "mentioned",
+              "mention_rate",
+              "sov",
+              "avg_rank"
+            ]
+          },
+          plain: [
+            ...context,
+            "",
+            ...metricPlainLines(rows),
+            "",
+            `  ${pc10.bold("Series")}`,
+            ...series.length ? series.map(
+              (p4) => `  ${p4.period_start}  answered ${count(p4.answered_count)}  mentioned ${count(p4.mentioned_count)}  rate ${rate(p4.mention_rate)}  SoV ${rate(p4.share_of_voice)}  rank ${rate(p4.avg_rank)}`
+            ) : ["  No rollup days in this window."],
+            ...answers.length ? [
+              "",
+              `  ${pc10.bold("Latest answers")}`,
+              ...answers.map(
+                (a) => [
+                  `  ${pc10.bold(`${a.model} \xB7 ${a.location}`)} ${pc10.dim(a.run_at)}`,
+                  `     mentioned ${a.mentioned ? "yes" : "no"} \xB7 rank ${a.rank === null || a.rank === void 0 ? NO_VALUE : `#${a.rank}`} \xB7 sentiment ${a.sentiment ?? NO_VALUE} \xB7 ${count(a.citations?.length ?? 0)} citations`,
+                  `     ${pc10.dim(truncate(a.response_text, 200))}`
+                ].join("\n")
+              )
+            ] : []
+          ]
+        });
+        emitNotes(format, data.notes);
+      } catch (err) {
+        error(formatApiError(err));
+        process.exit(1);
+      }
+    }
+  );
+  addPagingOptions(
+    analytics.command("answers").description(
+      "The newest stored answer per prompt \xD7 model \xD7 location, with its citations and competitor mentions. This is a snapshot, not a window: --from/--to filter on when each answer was collected, so narrowing them hides combinations instead of returning older answers. Historical answer text is not retained."
+    ).option("--from <date>", "Answers collected on or after this date, YYYY-MM-DD (hides rows, never reveals older answers)").option("--to <date>", "Answers collected on or before this date, YYYY-MM-DD (hides rows, never reveals older answers)").option("--models <list>", "Comma-separated model filter").option("--location <list>", "Comma-separated location filter, case-sensitive").option("--prompt-type <type>", "Funnel stage: awareness | consideration | evaluation | decision").option("--tag <tag>", "Restrict to prompts carrying this tag").option("--mentioned <bool>", "Only answers that did (true) or did not (false) name your brand").option("--cited <bool>", "Only answers that did (true) or did not (false) cite anything").option("--citation-tier <tier>", "Only answers citing this tier: primary | tracked | secondary"),
+    25
+  ).action(
+    async (cmdOpts) => {
+      const opts = program2.opts();
+      const format = opts.output || "plain";
+      const mentioned = normalizeBool("mentioned", cmdOpts.mentioned);
+      const cited = normalizeBool("cited", cmdOpts.cited);
+      try {
+        const data = await apiRequest({
+          path: "/org/analytics/answers/latest",
+          params: {
+            from: cmdOpts.from,
+            to: cmdOpts.to,
+            models: cmdOpts.models,
+            location: cmdOpts.location,
+            prompt_type: cmdOpts.promptType,
+            tag: cmdOpts.tag,
+            mentioned,
+            cited,
+            citation_tier: cmdOpts.citationTier,
+            limit: cmdOpts.limit,
+            offset: cmdOpts.offset
+          },
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+        const answers = data.answers ?? [];
+        const collectedLine = cmdOpts.from || cmdOpts.to ? `  ${pc10.dim(`Collected ${cmdOpts.from ?? "any"} \u2192 ${cmdOpts.to ?? "any"} \u2014 combinations whose newest answer falls outside this window are hidden, not replaced by older answers.`)}` : "";
+        const context = [
+          "",
+          `  ${pc10.bold("Latest answers")} ${pc10.dim(`${answers.length} of ${count(data.total)} (offset ${count(data.offset)})`)}`,
+          `  ${pc10.dim("Snapshot of the newest answer per prompt \xD7 model \xD7 location \u2014 not a sample of any window.")}`,
+          ...collectedLine ? [collectedLine] : []
+        ];
+        emitContext(format, context);
+        output(format, {
+          json: data,
+          table: {
+            rows: answers.map((a) => ({
+              run_at: (a.run_at || "").slice(0, 10),
+              model: a.model,
+              location: a.location,
+              prompt: truncate(a.prompt_text, 40),
+              mentioned: a.mentioned ? "yes" : "no",
+              rank: a.rank === null || a.rank === void 0 ? NO_VALUE : `#${a.rank}`,
+              sentiment: a.sentiment ?? NO_VALUE,
+              citations: count(a.citations?.length ?? 0)
+            })),
+            columns: [
+              "run_at",
+              "model",
+              "location",
+              "prompt",
+              "mentioned",
+              "rank",
+              "sentiment",
+              "citations"
+            ]
+          },
+          plain: [
+            ...context,
+            "",
+            ...answers.length ? answers.map(
+              (a) => [
+                `  ${pc10.bold(truncate(a.prompt_text, 100))} ${pc10.dim(`[${a.prompt_type}]`)}`,
+                `     ${a.model} \xB7 ${a.location} \xB7 ${pc10.dim(a.run_at)}`,
+                `     mentioned ${a.mentioned ? "yes" : "no"} \xB7 rank ${a.rank === null || a.rank === void 0 ? NO_VALUE : `#${a.rank}`} \xB7 sentiment ${a.sentiment ?? NO_VALUE} \xB7 ${count(a.citations?.length ?? 0)} citations`,
+                `     ${pc10.dim(truncate(a.response_text, 200))}`,
+                `     ${pc10.dim(`ID: ${a.prompt_id}`)}`
+              ].join("\n")
+            ) : ["  No answers matched this filter."]
+          ]
+        });
+        emitNotes(format, data.notes);
+      } catch (err) {
+        error(formatApiError(err));
+        process.exit(1);
+      }
+    }
+  );
+  analytics.command("glossary").description(
+    "Canonical definition, denominator and gotcha for every metric these endpoints emit. Read this before quoting a number \u2014 a Citation Rate divides by cited answers (D), a Citation Share divides by citation instances (S), and they are not interchangeable."
+  ).action(async () => {
+    const opts = program2.opts();
+    const format = opts.output || "plain";
+    try {
+      const data = await apiRequest({
+        path: "/org/analytics/glossary",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      const entries = data.entries ?? [];
+      emitContext(format, [
+        "",
+        `  ${pc10.bold("Metric glossary")} ${pc10.dim(`${entries.length} metrics \u2014 gotchas shown in plain and json output`)}`
+      ]);
+      output(format, {
+        json: data,
+        table: {
+          rows: entries.map((e) => ({
+            metric: e.metric,
+            denominator: e.denominator || NO_VALUE,
+            definition: e.definition
+          })),
+          columns: ["metric", "denominator", "definition"]
+        },
+        plain: [
+          "",
+          `  ${pc10.bold("Metric glossary")}`,
+          "",
+          ...entries.map(
+            (e) => [
+              `  ${pc10.bold(e.metric)}`,
+              `     ${e.definition}`,
+              ...e.denominator ? [`     ${pc10.dim(`Denominator: ${e.denominator}`)}`] : [],
+              ...e.gotcha ? [`     ${pc10.yellow("Gotcha:")} ${e.gotcha}`] : []
+            ].join("\n")
+          )
+        ]
+      });
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  analytics.command("filters").description(
+    "The models, locations, prompt types, tags and tracked competitors that actually have data for this org, plus the span of rollup days available \u2014 so you never guess a model spelling or query an empty window."
+  ).action(async () => {
+    const opts = program2.opts();
+    const format = opts.output || "plain";
+    try {
+      const data = await apiRequest({
+        path: "/org/analytics/filters",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      const models = (data.models ?? []).map((m) => m.display_name || m.id);
+      const competitors = (data.tracked_competitors ?? []).map(
+        (c) => c.display_name || c.id
+      );
+      const range = data.date_range;
+      const rangeText = range?.earliest_day && range?.latest_day ? `${range.earliest_day} \u2192 ${range.latest_day}` : "no rollup days yet";
+      const list = (values) => values.length ? values.join(", ") : NO_VALUE;
+      emitContext(format, ["", `  ${pc10.bold("Available filters")}`]);
+      output(format, {
+        json: data,
+        table: {
+          rows: [
+            { filter: "--models", values: list(models) },
+            { filter: "--location", values: list(data.locations ?? []) },
+            { filter: "--prompt-type", values: list(data.prompt_types ?? []) },
+            { filter: "--tag", values: list(data.tags ?? []) },
+            { filter: "tracked competitors", values: list(competitors) },
+            { filter: "date range", values: rangeText }
+          ],
+          columns: ["filter", "values"]
+        },
+        plain: [
+          "",
+          `  ${pc10.bold("Available filters")}`,
+          "",
+          `  ${pc10.bold("--models")}        ${list(models)}`,
+          `  ${pc10.bold("--location")}      ${list(data.locations ?? [])}`,
+          `  ${pc10.bold("--prompt-type")}   ${list(data.prompt_types ?? [])}`,
+          `  ${pc10.bold("--tag")}           ${list(data.tags ?? [])}`,
+          "",
+          `  ${pc10.bold("Tracked competitors")}  ${list(competitors)}`,
+          `  ${pc10.bold("Date range")}           ${rangeText}`
+        ]
+      });
+      emitNotes(format, data.notes);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/industries.ts
+function handlePartnerError(err) {
+  if (err instanceof ApiError && (err.status === 401 || err.status === 403)) {
+    error(
+      "This request was rejected by the Senso API's partner authentication."
+    );
+    info(
+      "`senso industries` reads partner-scoped endpoints (/partner/*) and needs a PARTNER API key. The organization key stored by `senso login` cannot access them \u2014 logging in again will not help."
+    );
+    info(
+      "If you have a partner key, pass it per-command with `--api-key <partner-key>` or export SENSO_API_KEY."
+    );
+    info(
+      "For metrics about your own organization, use `senso analytics` \u2014 e.g. `senso analytics summary`, `senso analytics domains`, `senso analytics glossary`."
+    );
+    process.exit(1);
+  }
+  error(formatApiError(err));
+  process.exit(1);
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+  return UUID_RE.test(value.trim());
+}
+function ciParams(cmdOpts) {
+  return {
+    from: cmdOpts.from,
+    to: cmdOpts.to,
+    location: cmdOpts.location,
+    models: cmdOpts.models
+  };
+}
+async function resolveIndustryId(industry, opts) {
+  if (isUuid(industry)) return industry.trim();
+  const data = await apiRequest({
+    path: "/partner/industries",
+    params: { search: industry },
+    apiKey: opts.apiKey,
+    baseUrl: opts.baseUrl
+  });
+  const match = data.industries?.[0];
+  if (!match?.industry_id) {
+    throw new Error(`No industry found matching "${industry}".`);
+  }
+  return match.industry_id;
+}
+function registerIndustriesCommands(program2) {
+  const industries = program2.command("industries").description('Explore industry-level competitive intelligence across a partner network \u2014 brand share-of-voice, domain citations, and per-prompt metrics. The <industry> argument accepts either a UUID or a name (e.g. "Automotive"). REQUIRES A PARTNER API KEY: these commands read /partner/* endpoints, which reject the organization key stored by `senso login`. For metrics about your own organization, use `senso analytics`.');
+  industries.command("list").description("List industries visible to the partner. Use --search to filter by name.").option("--search <q>", "Filter industries by name").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/partner/industries",
+        params: { search: cmdOpts.search },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      handlePartnerError(err);
+    }
+  });
+  industries.command("summary <industry>").description("One-call, slide-ready overview of an industry: brand counts, share-of-voice, and citation totals over a time window.").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("--location <code>", "2-letter location code (e.g. US)").option("--models <list>", "Comma-separated model filter").action(async (industry, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const industryId = await resolveIndustryId(industry, opts);
+      const data = await apiRequest({
+        path: `/partner/industries/${industryId}/summary`,
+        params: ciParams(cmdOpts),
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      handlePartnerError(err);
+    }
+  });
+  industries.command("brand <industry> <brandName>").description("Everything about one brand within an industry, merged across surface-form spellings. Returns mentioned=false when the brand is never named.").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("--location <code>", "2-letter location code (e.g. US)").option("--models <list>", "Comma-separated model filter").action(async (industry, brandName, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const industryId = await resolveIndustryId(industry, opts);
+      const data = await apiRequest({
+        path: `/partner/industries/${industryId}/brands/${encodeURIComponent(brandName)}`,
+        params: ciParams(cmdOpts),
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      handlePartnerError(err);
+    }
+  });
+  industries.command("domain <industry> <domainOrUrl>").description("Direct domain/URL citation lookup within an industry. Returns cited=false when the domain is never cited.").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("--location <code>", "2-letter location code (e.g. US)").option("--models <list>", "Comma-separated model filter").action(async (industry, domainOrUrl, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const industryId = await resolveIndustryId(industry, opts);
+      const data = await apiRequest({
+        path: `/partner/industries/${industryId}/domains/${encodeURIComponent(domainOrUrl)}`,
+        params: ciParams(cmdOpts),
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      handlePartnerError(err);
+    }
+  });
+  industries.command("prompt-metrics <industry>").description("Pure-industry per-prompt metrics (no single-org overlay) \u2014 how each tracked prompt performs across the industry.").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("--location <code>", "2-letter location code (e.g. US)").option("--models <list>", "Comma-separated model filter").option("--limit <n>", "Maximum prompts to return").option("--offset <n>", "Number of prompts to skip (for pagination)").action(async (industry, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const industryId = await resolveIndustryId(industry, opts);
+      const data = await apiRequest({
+        path: `/partner/industries/${industryId}/prompt-metrics`,
+        params: { ...ciParams(cmdOpts), limit: cmdOpts.limit, offset: cmdOpts.offset },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      handlePartnerError(err);
+    }
+  });
+  industries.command("glossary").description("Canonical metric glossary \u2014 the citable definition of every competitive-intelligence metric returned by these endpoints.").action(async () => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/partner/glossary",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      handlePartnerError(err);
+    }
+  });
+}
+
 // src/commands/update.ts
 import semver2 from "semver";
-import pc10 from "picocolors";
+import pc11 from "picocolors";
 import { execSync } from "child_process";
 var NPM_PACKAGE2 = "@senso-ai/cli";
 function registerUpdateCommand(program2) {
   program2.command("update").description("Update CLI to the latest version").action(async () => {
-    info(`Current version: ${pc10.bold(version)}`);
+    info(`Current version: ${pc11.bold(version)}`);
     info("Checking npm for updates...");
     const latest = await getLatestVersion();
     if (!latest) {
@@ -3374,7 +4312,7 @@ function registerUpdateCommand(program2) {
       success(`Already on the latest version (${version}).`);
       return;
     }
-    info(`New version available: ${pc10.bold(latest)}`);
+    info(`New version available: ${pc11.bold(latest)}`);
     info("Updating...");
     try {
       execSync(`npm install -g ${NPM_PACKAGE2}@latest`, {
@@ -3384,7 +4322,7 @@ function registerUpdateCommand(program2) {
     } catch {
       error("Update failed. Please reinstall manually:");
       console.log(
-        `  ${pc10.cyan(`npm install -g ${NPM_PACKAGE2}`)}`
+        `  ${pc11.cyan(`npm install -g ${NPM_PACKAGE2}`)}`
       );
       process.exit(1);
     }
@@ -3426,6 +4364,8 @@ registerRolesCommands(program);
 registerCompetitorsCommands(program);
 registerTrackedSourcesCommands(program);
 registerGeneratedContentCommands(program);
+registerAnalyticsCommands(program);
+registerIndustriesCommands(program);
 registerUpdateCommand(program);
 async function main() {
   const quiet = process.argv.includes("--quiet") || process.argv.includes("--output") && process.argv[process.argv.indexOf("--output") + 1] === "json";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@senso-ai/cli",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Senso CLI — Infrastructure for the Agentic Web. Interact with your Senso knowledge base from the terminal.",
   "type": "module",
   "bin": {