@senso-ai/cli 0.11.0 → 0.12.0

package/dist/cli.js

@@ -499,6 +499,29 @@ function registerOrgCommands(program2) {
       process.exit(1);
     }
   });
+  org.command("set-runs").description("Toggle the org-wide runs master switch. Pause every scheduled prompt run and content-generation run, or re-enable them.").requiredOption("--enabled <bool>", "Set to true or false").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const raw = cmdOpts.enabled.toLowerCase();
+    if (raw !== "true" && raw !== "false") {
+      error("--enabled must be `true` or `false`.");
+      process.exit(1);
+    }
+    const enable = raw === "true";
+    try {
+      const data = await apiRequest({
+        method: "PATCH",
+        path: "/org/me/runs-enabled",
+        body: { enable_runs: enable },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Org-wide runs ${enable ? "enabled" : "disabled"}.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
 }
 
 // src/commands/users.ts
@@ -591,6 +614,50 @@ function registerUserCommands(program2) {
       process.exit(1);
     }
   });
+  users.command("invite").description("Invite a brand-new user by email. Creates the user (in Clerk and Senso) and adds them to the organization with the given role. Use `roles list` to find a role_id. If the email already belongs to a Senso user, use `users invite-existing` instead.").requiredOption("--email <email>", "User's email address").requiredOption("--given-name <name>", "First name").requiredOption("--family-name <name>", "Last name").requiredOption("--role-id <uuid>", "Role to assign \u2014 resolve with `senso roles list`").option("--is-current", "Make this org the new user's current org").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/users/invite",
+        body: {
+          email: cmdOpts.email,
+          given_name: cmdOpts.givenName,
+          family_name: cmdOpts.familyName,
+          role_id: cmdOpts.roleId,
+          is_current: cmdOpts.isCurrent ?? false
+        },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Invited ${cmdOpts.email} to the organization.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  users.command("invite-existing").description("Add an existing Senso user to the organization by email. Returns 404 if no user with that email exists \u2014 use `users invite` for brand-new users.").requiredOption("--email <email>", "Email of an existing Senso user").requiredOption("--role-id <uuid>", "Role to assign \u2014 resolve with `senso roles list`").option("--is-current", "Make this org the user's current org").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/users/invite/existing",
+        body: {
+          email: cmdOpts.email,
+          role_id: cmdOpts.roleId,
+          is_current: cmdOpts.isCurrent ?? false
+        },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Added ${cmdOpts.email} to the organization.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
 }
 
 // src/commands/api-keys.ts
@@ -1163,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}`);
@@ -1391,12 +1458,40 @@ function registerContentCommands(program2) {
       process.exit(1);
     }
   });
-  content.command("verification").description("List content items in the verification workflow. Filter by editorial status (draft, review, rejected, published) to manage the review pipeline.").option("--limit <n>", "Maximum items to return").option("--offset <n>", "Number of items to skip (for pagination)").option("--search <query>", "Filter by title").option("--status <status>", "Filter by status: all, draft, review, rejected, published").action(async (cmdOpts) => {
+  content.command("verification").description("List content items in the verification workflow. Filter by editorial status (draft, review, rejected, published) to manage the review pipeline.").option("--limit <n>", "Maximum items to return").option("--offset <n>", "Number of items to skip (for pagination)").option("--search <query>", "Filter by title").option("--status <status>", "Filter by status: all, draft, review, rejected, published").option("--substatus <substatus>", "Narrow further (only valid with --status published): pending_draft").action(async (cmdOpts) => {
     const opts = program2.opts();
     try {
       const data = await apiRequest({
         path: "/org/content/verification",
-        params: { limit: cmdOpts.limit, offset: cmdOpts.offset, search: cmdOpts.search, status: cmdOpts.status },
+        params: { limit: cmdOpts.limit, offset: cmdOpts.offset, search: cmdOpts.search, status: cmdOpts.status, substatus: cmdOpts.substatus },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  content.command("verification-counts").description("Get counts of content by editorial status (draft, published, rejected, pending published-draft) plus per-destination published-domain summaries. A lightweight alternative to paging through 'content verification'.").action(async () => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/org/content/verification/counts",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  content.command("versions <id>").description("List the version history for a content item, newest first. The current version is flagged with is_current.").action(async (id) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: `/org/content/${id}/versions`,
         apiKey: opts.apiKey,
         baseUrl: opts.baseUrl
       });
@@ -1669,12 +1764,12 @@ function registerGenerateCommands(program2) {
       process.exit(1);
     }
   });
-  gen.command("runs-items <runId>").description("List individual prompt items within a content generation run and their per-item status.").option("--limit <n>", "Items per page", "100").option("--offset <n>", "Pagination offset", "0").action(async (runId, cmdOpts) => {
+  gen.command("runs-items <runId>").description("List individual prompt items within a content generation run and their per-item status.").option("--limit <n>", "Items per page", "100").option("--offset <n>", "Pagination offset", "0").option("--status <status>", "Filter by item status: pending, running, succeeded, failed, skipped, stopped").action(async (runId, cmdOpts) => {
     const opts = program2.opts();
     try {
       const data = await apiRequest({
         path: `/org/content-generation/runs/${runId}/items`,
-        params: { limit: cmdOpts.limit, offset: cmdOpts.offset },
+        params: { limit: cmdOpts.limit, offset: cmdOpts.offset, status: cmdOpts.status },
         apiKey: opts.apiKey,
         baseUrl: opts.baseUrl
       });
@@ -1727,7 +1822,7 @@ function sleep(ms) {
 // src/commands/engine.ts
 function registerEngineCommands(program2) {
   const engine = program2.command("engine").description("Publish or draft content through the content engine. Used to push AI-generated content to external destinations (citeables by default) or save it as a draft for review.");
-  engine.command("publish").description("Publish content to external destinations via the content engine. Requires geo_question_id, raw_markdown, and seo_title. By default publishes to every destination currently selected for generation (citeables is the default for most orgs \u2014 see 'senso destinations list'). Pass --publisher-ids to restrict publishing to a specific subset, or include 'publisher_ids' inside --data.").requiredOption("--data <json>", 'JSON: { "geo_question_id": "uuid", "raw_markdown": "...", "seo_title": "...", "summary": "...", "publisher_ids": ["<uuid>", ...] }').option("--publisher-ids <ids...>", "Restrict publishing to specific publisher IDs. Overrides any publisher_ids present in --data. Omit to publish to all configured destinations (citeables by default).").action(async (cmdOpts) => {
+  engine.command("publish").description("Publish content to external destinations via the content engine. Requires geo_question_id, raw_markdown, and seo_title. By default publishes to every destination currently selected for generation (citeables is the default for most orgs \u2014 see 'senso destinations list'). Pass --publisher-ids to restrict publishing to a specific subset, or include 'publisher_ids' inside --data. To record content as already published externally rather than pushing it to destinations, set mark_as_published (and optionally manual_published_at) in --data.").requiredOption("--data <json>", 'JSON: { "geo_question_id": "uuid", "raw_markdown": "...", "seo_title": "...", "summary": "...", "publisher_ids": ["<uuid>", ...], "mark_as_published": false, "manual_published_at": "2026-06-11T00:00:00Z" }').option("--publisher-ids <ids...>", "Restrict publishing to specific publisher IDs. Overrides any publisher_ids present in --data. Omit to publish to all configured destinations (citeables by default).").action(async (cmdOpts) => {
     const opts = program2.opts();
     try {
       const body = JSON.parse(cmdOpts.data);
@@ -1847,14 +1942,13 @@ function registerPublishRecordsCommands(program2) {
   pr.command("retry <publishRecordId>").description("Retry a failed publish record. Re-runs the publish for that specific content+destination pair and flips the record's state based on the new attempt. Only works on records currently in the 'failed' state.").action(async (publishRecordId) => {
     const opts = program2.opts();
     try {
-      const data = await apiRequest({
+      await apiRequest({
         method: "POST",
         path: `/org/publish-records/${publishRecordId}/retry`,
         apiKey: opts.apiKey,
         baseUrl: opts.baseUrl
       });
-      success(`Publish record ${publishRecordId} retry triggered.`);
-      console.log(JSON.stringify(data, null, 2));
+      success(`Publish record ${publishRecordId} retry completed.`);
     } catch (err) {
       error(formatApiError(err));
       process.exit(1);
@@ -1864,7 +1958,7 @@ function registerPublishRecordsCommands(program2) {
 
 // src/commands/brand-kit.ts
 function registerBrandKitCommands(program2) {
-  const bk = program2.command("brand-kit").description("Manage the organization's brand kit guidelines. The brand kit is a free-form JSON object that informs AI content generation about your brand voice, tone, and style.");
+  const bk = program2.command("brand-kit").description("Manage the organization's brand kit guidelines that inform AI content generation about your brand voice, tone, and style. The guidelines object accepts a defined set of keys: brand_name, brand_domain, brand_description, voice_and_tone, author_persona, and global_writing_rules (array). Unknown keys are rejected.");
   bk.command("get").description("Get the current brand kit guidelines.").action(async () => {
     const opts = program2.opts();
     try {
@@ -1931,7 +2025,7 @@ function registerContentTypeCommands(program2) {
       process.exit(1);
     }
   });
-  ct.command("create").description("Create a new content type. Requires a name and configuration defining the output structure.").requiredOption("--data <json>", 'JSON: { "name": "Blog Post", "config": { ... } }').action(async (cmdOpts) => {
+  ct.command("create").description("Create a new content type. Requires a name and a config defining the output structure. config accepts a defined set of keys: template, template_spec, cta_text, cta_destination, writing_rules (array). Unknown keys are rejected.").requiredOption("--data <json>", 'JSON: { "name": "Blog Post", "config": { "template": "...", "cta_text": "...", "cta_destination": "...", "writing_rules": [] } }').action(async (cmdOpts) => {
     const opts = program2.opts();
     try {
       const body = JSON.parse(cmdOpts.data);
@@ -2415,7 +2509,7 @@ function registerQuestionsCommands(program2) {
       process.exit(1);
     }
   });
-  questions.command("patch <questionId>").description("Partially update a question. Currently supports updating tag associations.").requiredOption("--data <json>", 'JSON: { "tag_ids": ["<uuid>", ...] } \u2014 pass null to clear all tags').action(async (questionId, cmdOpts) => {
+  questions.command("patch <questionId>").description("Partially update a question. Supports updating tag associations and/or the funnel stage (type). At least one of tag_ids or type must be provided.").requiredOption("--data <json>", 'JSON: { "tag_ids": ["<uuid>", ...], "type": "decision|consideration|awareness|evaluation" } \u2014 pass tag_ids: null to clear all tags').action(async (questionId, cmdOpts) => {
     const opts = program2.opts();
     try {
       const body = JSON.parse(cmdOpts.data);
@@ -2482,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}`);
 }
@@ -3021,14 +3115,1193 @@ function registerTagsCommands(program2) {
   });
 }
 
-// src/commands/update.ts
-import semver2 from "semver";
+// src/commands/roles.ts
+function registerRolesCommands(program2) {
+  const roles = program2.command("roles").description("Inspect the roles defined for your organization. Each organization has its own per-org role_ids \u2014 resolve a role name to its UUID here before passing role_id to `users invite`, `users add`, or `users update`.");
+  roles.command("list").description("List every role for the current organization, including the built-in admin/collaborator/viewer roles and any custom roles.").action(async () => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/org/roles",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/competitors.ts
+function registerCompetitorsCommands(program2) {
+  const competitors = program2.command("competitors").description("Manage the curated list of competitor brands your organization tracks. Tracked competitors feed downstream share-of-voice analytics and inform content-generation prompts.");
+  competitors.command("list").description("List every tracked competitor for the current organization.").action(async () => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/org/competitors",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  competitors.command("add").description("Add a single tracked competitor.").requiredOption("--name <name>", "Competitor brand name").option("--url <url>", "Competitor website URL").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = { name: cmdOpts.name };
+      if (cmdOpts.url) body.url = cmdOpts.url;
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/competitors",
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tracked competitor "${cmdOpts.name}" added.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  competitors.command("batch-add").description("Add up to 50 tracked competitors in one call. Designed for accepting AI-generated suggestions returned by `competitors suggest`.").requiredOption("--data <json>", 'JSON: { "items": [{ "name": "...", "url": "...", "source": "manual|suggested_run_text|suggested_web_search", "rationale": "...", "confidence": 0.85 }, ...] }').action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = JSON.parse(cmdOpts.data);
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/competitors/batch",
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success("Tracked competitors added.");
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(err instanceof SyntaxError ? "Invalid JSON in --data" : formatApiError(err));
+      process.exit(1);
+    }
+  });
+  competitors.command("suggest").description("Get AI-generated competitor suggestions seeded from your org's website and recent prompt-run results. Pipe accepted suggestions into `competitors batch-add`.").action(async () => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/competitors/suggest",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  competitors.command("update <competitorId>").description("Update a tracked competitor's name or URL.").requiredOption("--name <name>", "Competitor brand name").option("--url <url>", "Competitor website URL").action(async (competitorId, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = { name: cmdOpts.name };
+      if (cmdOpts.url) body.url = cmdOpts.url;
+      const data = await apiRequest({
+        method: "PUT",
+        path: `/org/competitors/${competitorId}`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tracked competitor ${competitorId} updated.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  competitors.command("delete <competitorId>").description("Remove a tracked competitor.").action(async (competitorId) => {
+    const opts = program2.opts();
+    try {
+      await apiRequest({
+        method: "DELETE",
+        path: `/org/competitors/${competitorId}`,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tracked competitor ${competitorId} removed.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/tracked-sources.ts
+var MATCH_TYPES = "domain | host | path_prefix | exact_url";
+var TIERS = "primary (Owned) | tracked | secondary (External)";
+var CATEGORIES = "affiliated_domain | published_content | social | press";
+function buildSourceBody(cmdOpts) {
+  const body = {};
+  if (cmdOpts.pattern !== void 0) body.pattern = cmdOpts.pattern;
+  if (cmdOpts.matchType !== void 0) body.match_type = cmdOpts.matchType;
+  if (cmdOpts.tier !== void 0) body.tier = cmdOpts.tier;
+  if (cmdOpts.category !== void 0) body.category = cmdOpts.category;
+  if (cmdOpts.label !== void 0) body.label = cmdOpts.label;
+  if (cmdOpts.priority !== void 0) body.priority = Number(cmdOpts.priority);
+  if (cmdOpts.active !== void 0) body.active = cmdOpts.active;
+  return body;
+}
+function registerTrackedSourcesCommands(program2) {
+  const sources = program2.command("tracked-sources").description("Manage citation-classification rules that tier each cited URL as Owned (primary), Tracked, or External (secondary). Tracked sources drive share-of-voice and citation analytics. Rules created from published content are read-only.");
+  sources.command("list").description("List every tracked source rule for the current organization.").action(async () => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/org/tracked-sources",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  sources.command("add").description("Add a tracked source rule. New rules are always created active.").requiredOption("--pattern <pattern>", "Value to match cited URLs against, interpreted per --match-type").requiredOption("--match-type <type>", `Match strategy: ${MATCH_TYPES}`).requiredOption("--tier <tier>", `Classification tier: ${TIERS}`).option("--category <category>", `Optional sub-category (only meaningful for the 'tracked' tier): ${CATEGORIES}`).option("--label <label>", "Optional human-readable label").option("--priority <n>", "Optional ordering priority (integer)").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/tracked-sources",
+        body: buildSourceBody(cmdOpts),
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tracked source "${cmdOpts.pattern}" added.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  sources.command("update <sourceId>").description("Replace a tracked source rule (PUT). Pattern, match type, and tier are required. Published rules are read-only.").requiredOption("--pattern <pattern>", "Value to match cited URLs against, interpreted per --match-type").requiredOption("--match-type <type>", `Match strategy: ${MATCH_TYPES}`).requiredOption("--tier <tier>", `Classification tier: ${TIERS}`).option("--category <category>", `Optional sub-category (only meaningful for the 'tracked' tier): ${CATEGORIES}`).option("--label <label>", "Optional human-readable label").option("--priority <n>", "Optional ordering priority (integer)").option("--active", "Mark the rule active").option("--no-active", "Mark the rule inactive").action(async (sourceId, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        method: "PUT",
+        path: `/org/tracked-sources/${sourceId}`,
+        body: buildSourceBody(cmdOpts),
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tracked source ${sourceId} updated.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  sources.command("delete <sourceId>").description("Remove a tracked source rule.").action(async (sourceId) => {
+    const opts = program2.opts();
+    try {
+      await apiRequest({
+        method: "DELETE",
+        path: `/org/tracked-sources/${sourceId}`,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tracked source ${sourceId} removed.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/generated-content.ts
+function registerGeneratedContentCommands(program2) {
+  const gc = program2.command("generated-content").description("Browse AI-generated content (GEO). List published or draft generated items, or fetch a single item with its rendered body. Requires the GEO product and read:content permission.");
+  gc.command("list").description("List generated content. Use --status to switch between published and draft items.").option("--status <status>", "Which items to list: published | drafts", "published").option("--limit <n>", "Items per page (max 100)", "10").option("--offset <n>", "Pagination offset", "0").option("--search <query>", "Filter by title").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const status = cmdOpts.status === "drafts" || cmdOpts.status === "draft" ? "drafts" : "published";
+    try {
+      const data = await apiRequest({
+        path: `/org/generated-content/${status}`,
+        params: { limit: cmdOpts.limit, offset: cmdOpts.offset, search: cmdOpts.search },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  gc.command("get <id>").description("Get a single generated content item including its question text and rendered body.").action(async (id) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: `/org/generated-content/${id}`,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// 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 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) {
@@ -3039,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`, {
@@ -3049,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);
     }
@@ -3087,6 +4360,12 @@ registerKBCommands(program);
 registerPermissionsCommands(program);
 registerTagsCommands(program);
 registerProductLineCommands(program);
+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";