@senso-ai/cli 0.9.0 → 0.11.1

package/README.md

@@ -124,9 +124,11 @@ Options: `--max-results <n>`
 ```
 senso content list                   List all knowledge base items
 senso content get <id>               Get full content detail by ID
+senso content versions <id>          List version history for a content item
 senso content delete <id>            Delete content (knowledge base + external)
 senso content unpublish <id>         Unpublish and revert to draft
 senso content verification           List items in verification workflow
+senso content verification-counts    Counts by status + published-domain summaries
 senso content reject <versionId>     Reject a content version
 senso content restore <versionId>    Restore rejected version to draft
 senso content owners <id>            List owners of a content item
@@ -134,7 +136,16 @@ senso content set-owners <id>        Replace owners (--user-ids)
 senso content remove-owner <id> <userId>  Remove a single owner
 ```
 
-Options: `content list` supports `--limit`, `--offset`, `--search`, `--sort`. `content verification` supports `--limit`, `--offset`, `--search`, `--status`. `content reject` supports `--reason`.
+Options: `content list` supports `--limit`, `--offset`, `--search`, `--sort`. `content verification` supports `--limit`, `--offset`, `--search`, `--status`, `--substatus`. `content reject` supports `--reason`.
+
+### Generated Content (GEO)
+
+```
+senso generated-content list         List published or draft generated content (--status published|drafts)
+senso generated-content get <id>     Get a generated content item with its rendered body
+```
+
+Options: `generated-content list` supports `--status`, `--limit`, `--offset`, `--search`.
 
 ### Content Generation
 
@@ -152,6 +163,24 @@ senso engine publish                 Publish content to external destinations (-
 senso engine draft                   Save content as draft for review (--data)
 ```
 
+### Tracked Competitors & Sources
+
+```
+senso competitors list               List tracked competitors
+senso competitors add                Add a competitor (--name, --url)
+senso competitors suggest            Get AI-generated competitor suggestions
+senso competitors batch-add          Add up to 50 competitors (--data)
+senso competitors update <id>        Update a competitor (--name, --url)
+senso competitors delete <id>        Remove a competitor
+
+senso tracked-sources list           List citation-classification rules
+senso tracked-sources add            Add a rule (--pattern, --match-type, --tier)
+senso tracked-sources update <id>    Replace a rule (--pattern, --match-type, --tier)
+senso tracked-sources delete <id>    Remove a rule
+```
+
+Options: `tracked-sources add`/`update` support `--category`, `--label`, `--priority`; `update` also supports `--active`/`--no-active`. `--match-type` is one of `domain | host | path_prefix | exact_url`; `--tier` is one of `primary | tracked | secondary`.
+
 ### Ingestion
 
 ```
@@ -344,12 +373,15 @@ npm test
 ```
 src/
 ├── cli.ts                 # Entry point — arg parsing, command dispatch
-├── commands/              # One file per command group (16 files)
+├── commands/              # One file per command group
 │   ├── auth.ts            # login, logout, whoami
 │   ├── search.ts          # search, search context, search content
-│   ├── content.ts         # CRUD + verification + owners
+│   ├── content.ts         # CRUD + versions + verification + owners
+│   ├── generated-content.ts  # GEO generated content (list, get)
 │   ├── generate.ts        # content generation settings + triggers
 │   ├── engine.ts          # publish, draft
+│   ├── competitors.ts     # tracked competitors CRUD + suggest
+│   ├── tracked-sources.ts # citation-classification rules CRUD
 │   ├── ingest.ts          # upload, reprocess (with S3 upload)
 │   ├── brand-kit.ts       # get, set
 │   ├── content-types.ts   # CRUD

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
@@ -1295,6 +1362,27 @@ function registerIngestCommands(program2) {
 
 // src/commands/content.ts
 import pc9 from "picocolors";
+
+// src/lib/tag-args.ts
+function parseCsv(v) {
+  if (!v) return [];
+  return v.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function buildSetTagsBody(cmdOpts) {
+  const body = {};
+  const names = parseCsv(cmdOpts.names);
+  const ids = parseCsv(cmdOpts.ids);
+  if (names.length > 0) body.tag_names = names;
+  if (ids.length > 0) body.tag_ids = ids;
+  return body;
+}
+function buildAttachTagBody(cmdOpts) {
+  if (cmdOpts.id) return { tag_id: cmdOpts.id };
+  if (cmdOpts.name) return { tag_name: cmdOpts.name };
+  return null;
+}
+
+// src/commands/content.ts
 function registerContentCommands(program2) {
   const content = program2.command("content").description("Manage content items in the knowledge base. List, inspect, delete, unpublish, and manage the verification workflow and ownership of content.");
   content.command("list").description("List top-level files and folders in the knowledge base. Use 'kb my-files' for the same result with richer KB node output.").option("--limit <n>", "Items per page", "10").option("--offset <n>", "Pagination offset", "0").action(async (cmdOpts) => {
@@ -1348,22 +1436,62 @@ function registerContentCommands(program2) {
       process.exit(1);
     }
   });
-  content.command("unpublish <id>").description("Unpublish a content item. Removes it from external destinations and sets its status back to draft.").action(async (id) => {
+  content.command("unpublish <id>").description("Unpublish a content item. Without --publish-record-ids, removes the content from every destination it's live on and sets its status back to draft. With --publish-record-ids, only the specified publish records are retracted \u2014 use this to unpublish from a subset of destinations while leaving the rest live. The content status only flips back to draft once no publish records remain live.").option("--publish-record-ids <ids...>", "Restrict unpublish to specific publish_record UUIDs. Use 'content get <id>' to find publish record IDs for a content item.").action(async (id, cmdOpts) => {
     const opts = program2.opts();
     try {
-      await apiRequest({ method: "POST", path: `/org/content/${id}/unpublish`, apiKey: opts.apiKey, baseUrl: opts.baseUrl });
-      success(`Content ${id} unpublished.`);
+      const body = cmdOpts.publishRecordIds && cmdOpts.publishRecordIds.length > 0 ? { publish_record_ids: cmdOpts.publishRecordIds } : void 0;
+      const data = await apiRequest({
+        method: "POST",
+        path: `/org/content/${id}/unpublish`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(
+        cmdOpts.publishRecordIds && cmdOpts.publishRecordIds.length > 0 ? `Unpublished ${cmdOpts.publishRecordIds.length} record(s) from content ${id}.` : `Content ${id} unpublished.`
+      );
+      if (data) {
+        console.log(JSON.stringify(data, null, 2));
+      }
     } catch (err) {
       error(formatApiError(err));
       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
       });
@@ -1430,6 +1558,85 @@ function registerContentCommands(program2) {
       process.exit(1);
     }
   });
+  const tags = content.command("tags").description("Manage tags attached to a content item (both KB-ingested and generated). Content is auto-tagged on creation (KB uploads get tagged once ingestion finishes, raw content is tagged on create) \u2014 use these commands to override, add, or remove tags afterwards. Tag names are resolved against the org's tag library; unknown names are created automatically.");
+  tags.command("list <id>").description("List tags attached to a content item.").action(async (id) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({ path: `/org/content/${id}/tags`, apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("set <id>").description("Replace the content item's full tag collection. Provide --names (comma-separated) and/or --ids (comma-separated UUIDs). Unknown names are created.").option("--names <list>", "Comma-separated tag names (created if missing)").option("--ids <list>", "Comma-separated existing tag UUIDs").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = buildSetTagsBody(cmdOpts);
+      const data = await apiRequest({
+        method: "PUT",
+        path: `/org/content/${id}/tags`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Content ${id} tags updated.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("add <id>").description("Attach a single tag by --name (created if missing) or --id.").option("--name <name>", "Tag name (created if missing)").option("--id <tagId>", "Existing tag UUID").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    const body = buildAttachTagBody(cmdOpts);
+    if (!body) {
+      error("Provide --name or --id.");
+      process.exit(1);
+    }
+    try {
+      await apiRequest({
+        method: "POST",
+        path: `/org/content/${id}/tags`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tag attached to content ${id}.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("remove <id>").description("Detach a single tag by --name or --id. Idempotent.").option("--name <name>", "Tag name to detach").option("--id <tagId>", "Existing tag UUID to detach").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    if (!cmdOpts.name && !cmdOpts.id) {
+      error("Provide --name or --id.");
+      process.exit(1);
+    }
+    try {
+      if (cmdOpts.id) {
+        await apiRequest({
+          method: "DELETE",
+          path: `/org/content/${id}/tags/${cmdOpts.id}`,
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+      } else {
+        await apiRequest({
+          method: "DELETE",
+          path: `/org/content/${id}/tags`,
+          params: { name: cmdOpts.name },
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+      }
+      success(`Tag detached from content ${id}.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
 }
 
 // src/commands/generate.ts
@@ -1557,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
       });
@@ -1614,11 +1821,14 @@ 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 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.").requiredOption("--data <json>", 'JSON: { "geo_question_id": "uuid", "raw_markdown": "...", "seo_title": "...", "summary": "..." }').action(async (cmdOpts) => {
+  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. 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);
+      if (cmdOpts.publisherIds && cmdOpts.publisherIds.length > 0) {
+        body.publisher_ids = cmdOpts.publisherIds;
+      }
       const data = await apiRequest({
         method: "POST",
         path: "/org/content-engine/publish",
@@ -1633,7 +1843,7 @@ function registerEngineCommands(program2) {
       process.exit(1);
     }
   });
-  engine.command("draft").description("Save content as a draft for review before publishing. Requires geo_question_id, raw_markdown, and seo_title.").requiredOption("--data <json>", 'JSON: { "geo_question_id": "uuid", "raw_markdown": "...", "seo_title": "...", "summary": "..." }').action(async (cmdOpts) => {
+  engine.command("draft").description("Save content as a draft for review before publishing. Requires geo_question_id, raw_markdown, and seo_title. Drafts do not hit any destination until you run 'senso engine publish' on them.").requiredOption("--data <json>", 'JSON: { "geo_question_id": "uuid", "raw_markdown": "...", "seo_title": "...", "summary": "..." }').action(async (cmdOpts) => {
     const opts = program2.opts();
     try {
       const body = JSON.parse(cmdOpts.data);
@@ -1653,9 +1863,102 @@ function registerEngineCommands(program2) {
   });
 }
 
+// src/commands/destinations.ts
+var SUPPORTED_TYPES = ["citeables", "codeables", "cucopilot"];
+var REMOVE_ACTIONS = ["leave", "unpublish", "delete"];
+function registerDestinationsCommands(program2) {
+  const dest = program2.command("destinations").description("Manage publish destinations. Destinations are where generated content gets published \u2014 shared domains (citeables, codeables, cucopilot) plus any custom citeables domains registered for your org. Most orgs publish to 'citeables' by default; additional destinations are opt-in.");
+  dest.command("list").description("List all destinations available to the organization. Includes shared destinations (citeables, codeables, cucopilot) and any custom domains you've added, with per-destination live article counts and last publish timestamps. 'selected_for_generation: true' means a destination is active in your generation pipeline.").action(async () => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/org/destinations",
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  dest.command("add").description("Register a custom publish destination (a citeables-system domain owned by your org). The domain is registered synchronously with the citeables service and linked to the org. Today only citeables-type destinations (slugs: citeables, codeables, cucopilot) are supported \u2014 pass --type if you need to target one of the non-default systems; new destination types may be added in future releases.").requiredOption("--domain <domain>", 'Custom domain to register (e.g. "content.example.com")').requiredOption("--name <name>", 'Display name for the destination (e.g. "Example Citeables")').option("--type <type>", "Destination type. One of: citeables, codeables, cucopilot. Defaults to citeables.", "citeables").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const type = cmdOpts.type.toLowerCase();
+    if (!SUPPORTED_TYPES.includes(type)) {
+      error(`Invalid --type "${cmdOpts.type}". Must be one of: ${SUPPORTED_TYPES.join(", ")}.`);
+      process.exit(1);
+    }
+    try {
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/destinations",
+        body: {
+          type,
+          name: cmdOpts.name,
+          domain: cmdOpts.domain
+        },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Destination "${cmdOpts.name}" registered for ${cmdOpts.domain}.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  dest.command("remove <publisherId>").description("Remove a destination from the org. --action controls what happens to live content: 'leave' keeps the articles live at the destination (org stops publishing to it but published records remain), 'unpublish' removes live articles from the destination and returns content to draft, 'delete' unpublishes AND hard-deletes the local content records. Shared destinations (citeables/codeables/cucopilot) can be removed from the org without affecting the underlying domain. --keep-domain preserves the custom domain registration on the citeables side (useful for SEO) when removing a custom destination.").requiredOption("--action <action>", "One of: leave, unpublish, delete. See command description.").option("--also-remove-destination", "Also delete the publisher row (not just the org link). Only valid for custom destinations you own.", false).option("--keep-domain", "Keep the custom domain registered on citeables after removing (custom destinations only).", false).action(async (publisherId, cmdOpts) => {
+    const opts = program2.opts();
+    const action = cmdOpts.action.toLowerCase();
+    if (!REMOVE_ACTIONS.includes(action)) {
+      error(`Invalid --action "${cmdOpts.action}". Must be one of: ${REMOVE_ACTIONS.join(", ")}.`);
+      process.exit(1);
+    }
+    try {
+      const data = await apiRequest({
+        method: "POST",
+        path: `/org/destinations/${publisherId}/remove`,
+        body: {
+          action,
+          also_remove_destination: cmdOpts.alsoRemoveDestination ?? false,
+          keep_domain: cmdOpts.keepDomain ?? false
+        },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Destination ${publisherId} removed (action: ${action}).`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/publish-records.ts
+function registerPublishRecordsCommands(program2) {
+  const pr = program2.command("publish-records").description("Inspect and retry publish records. A publish_record is the unit that tracks one content item's publication to one destination \u2014 published/live, pending, failed, unpublished, etc. When a publish fails for a single destination, retry it here without redoing the whole publish.");
+  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 {
+      await apiRequest({
+        method: "POST",
+        path: `/org/publish-records/${publishRecordId}/retry`,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Publish record ${publishRecordId} retry completed.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
 // 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 {
@@ -1722,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);
@@ -1854,6 +2157,85 @@ function registerPromptCommands(program2) {
       process.exit(1);
     }
   });
+  const tags = prompts.command("tags").description("Manage tags attached to a prompt. Prompts are auto-tagged on creation \u2014 use these commands to override, add, or remove tags afterwards. Tag names are resolved against the org's tag library; unknown names are created automatically.");
+  tags.command("list <promptId>").description("List tags attached to a prompt.").action(async (promptId) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({ path: `/org/prompts/${promptId}/tags`, apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("set <promptId>").description("Replace the prompt's full tag collection. Provide --names (comma-separated) and/or --ids (comma-separated UUIDs). Unknown names are created.").option("--names <list>", "Comma-separated tag names (created if missing)").option("--ids <list>", "Comma-separated existing tag UUIDs").action(async (promptId, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = buildSetTagsBody(cmdOpts);
+      const data = await apiRequest({
+        method: "PUT",
+        path: `/org/prompts/${promptId}/tags`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Prompt ${promptId} tags updated.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("add <promptId>").description("Attach a single tag by --name (created if missing) or --id.").option("--name <name>", "Tag name (created if missing)").option("--id <tagId>", "Existing tag UUID").action(async (promptId, cmdOpts) => {
+    const opts = program2.opts();
+    const body = buildAttachTagBody(cmdOpts);
+    if (!body) {
+      error("Provide --name or --id.");
+      process.exit(1);
+    }
+    try {
+      await apiRequest({
+        method: "POST",
+        path: `/org/prompts/${promptId}/tags`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tag attached to prompt ${promptId}.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("remove <promptId>").description("Detach a single tag by --name or --id. Idempotent.").option("--name <name>", "Tag name to detach").option("--id <tagId>", "Existing tag UUID to detach").action(async (promptId, cmdOpts) => {
+    const opts = program2.opts();
+    if (!cmdOpts.name && !cmdOpts.id) {
+      error("Provide --name or --id.");
+      process.exit(1);
+    }
+    try {
+      if (cmdOpts.id) {
+        await apiRequest({
+          method: "DELETE",
+          path: `/org/prompts/${promptId}/tags/${cmdOpts.id}`,
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+      } else {
+        await apiRequest({
+          method: "DELETE",
+          path: `/org/prompts/${promptId}/tags`,
+          params: { name: cmdOpts.name },
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+      }
+      success(`Tag detached from prompt ${promptId}.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
 }
 
 // src/commands/run-config.ts
@@ -2127,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);
@@ -2469,15 +2851,503 @@ function registerKBCommands(program2) {
       process.exit(1);
     }
   });
-}
-
-// src/commands/permissions.ts
-function registerPermissionsCommands(program2) {
-  const perms = program2.command("permissions").description("View available role permissions for the organization.");
-  perms.command("list").description("List all available permission keys with their names, descriptions, and categories. Useful for building role management UIs.").action(async () => {
+  const tags = kb.command("tags").description("Manage tags attached to a KB node. KB content is auto-tagged on creation (raw content on create, uploaded files once ingestion finishes) \u2014 use these commands to override, add, or remove tags afterwards. Tags can only be applied to content nodes, not folders. Names are resolved against the org's tag library; unknown names are created.");
+  tags.command("list <id>").description("List tags attached to a KB node.").action(async (id) => {
     const opts = program2.opts();
     try {
-      const data = await apiRequest({ path: "/org/permissions", apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      const data = await apiRequest({ path: `/org/kb/nodes/${id}/tags`, apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("set <id>").description("Replace the KB node's full tag collection. Provide --names (comma-separated) and/or --ids. Unknown names are created.").option("--names <list>", "Comma-separated tag names (created if missing)").option("--ids <list>", "Comma-separated existing tag UUIDs").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = buildSetTagsBody(cmdOpts);
+      const data = await apiRequest({
+        method: "PUT",
+        path: `/org/kb/nodes/${id}/tags`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`KB node ${id} tags updated.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("add <id>").description("Attach a single tag by --name (created if missing) or --id.").option("--name <name>", "Tag name (created if missing)").option("--id <tagId>", "Existing tag UUID").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    const body = buildAttachTagBody(cmdOpts);
+    if (!body) {
+      error("Provide --name or --id.");
+      process.exit(1);
+    }
+    try {
+      await apiRequest({
+        method: "POST",
+        path: `/org/kb/nodes/${id}/tags`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tag attached to KB node ${id}.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("remove <id>").description("Detach a single tag by --name or --id. Idempotent.").option("--name <name>", "Tag name to detach").option("--id <tagId>", "Existing tag UUID to detach").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    if (!cmdOpts.name && !cmdOpts.id) {
+      error("Provide --name or --id.");
+      process.exit(1);
+    }
+    try {
+      if (cmdOpts.id) {
+        await apiRequest({
+          method: "DELETE",
+          path: `/org/kb/nodes/${id}/tags/${cmdOpts.id}`,
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+      } else {
+        await apiRequest({
+          method: "DELETE",
+          path: `/org/kb/nodes/${id}/tags`,
+          params: { name: cmdOpts.name },
+          apiKey: opts.apiKey,
+          baseUrl: opts.baseUrl
+        });
+      }
+      success(`Tag detached from KB node ${id}.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/permissions.ts
+function registerPermissionsCommands(program2) {
+  const perms = program2.command("permissions").description("View available role permissions for the organization.");
+  perms.command("list").description("List all available permission keys with their names, descriptions, and categories. Useful for building role management UIs.").action(async () => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({ path: "/org/permissions", apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/product-lines.ts
+function registerProductLineCommands(program2) {
+  const pl = program2.command("product-lines").description("Manage product lines \u2014 flexible org-scoped product/service definitions. Each product line has a name and an arbitrary JSON 'details' blob carried by downstream generation and evaluation pipelines.");
+  pl.command("list").description("List all product lines for the organization.").option("--limit <n>", "Maximum items to return (default: 50)").option("--offset <n>", "Number of items to skip (for pagination)").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/org/product-lines",
+        params: { limit: cmdOpts.limit, offset: cmdOpts.offset },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  pl.command("create").description("Create a new product line. 'details' is an open-ended JSON object \u2014 put whatever structured metadata (SKUs, URLs, positioning, pricing tiers) your workflows need.").requiredOption("--data <json>", 'JSON: { "name": "Pro Plan", "details": { ... } }').action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = JSON.parse(cmdOpts.data);
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/product-lines",
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success("Product line created.");
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(err instanceof SyntaxError ? "Invalid JSON in --data" : formatApiError(err));
+      process.exit(1);
+    }
+  });
+  pl.command("get <id>").description("Get a product line by ID.").action(async (id) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({ path: `/org/product-lines/${id}`, apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  pl.command("update <id>").description("Replace a product line's name and details (PUT). Both fields are required \u2014 run 'get <id>' first to preserve existing values. For single-field updates, use 'product-lines patch <id>'.").requiredOption("--data <json>", 'JSON: { "name": "Updated Name", "details": { ... } }').action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = JSON.parse(cmdOpts.data);
+      const data = await apiRequest({
+        method: "PUT",
+        path: `/org/product-lines/${id}`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Product line ${id} updated.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(err instanceof SyntaxError ? "Invalid JSON in --data" : formatApiError(err));
+      process.exit(1);
+    }
+  });
+  pl.command("patch <id>").description("Partially update a product line (PATCH). Only the fields you provide are changed \u2014 existing fields are preserved.").requiredOption("--data <json>", 'JSON: { "details": { "price": 99 } }').action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const body = JSON.parse(cmdOpts.data);
+      const data = await apiRequest({
+        method: "PATCH",
+        path: `/org/product-lines/${id}`,
+        body,
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Product line ${id} updated.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(err instanceof SyntaxError ? "Invalid JSON in --data" : formatApiError(err));
+      process.exit(1);
+    }
+  });
+  pl.command("delete <id>").description("Delete a product line. This cannot be undone.").action(async (id) => {
+    const opts = program2.opts();
+    try {
+      await apiRequest({ method: "DELETE", path: `/org/product-lines/${id}`, apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      success(`Product line ${id} deleted.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/tags.ts
+function registerTagsCommands(program2) {
+  const tags = program2.command("tags").description("Manage the organization's tag library. Tags are labels attached to prompts, KB nodes, and content items to group them for filtering or metric rollups. Senso auto-tags prompts, KB content, and search queries on creation, so the tag library grows automatically \u2014 most workflows skip these commands and rely on attach-by-name on the resource commands, which also creates tags on demand.");
+  tags.command("list").description("List all tags for the organization. Pass --counts to include per-tag usage counts.").option("--counts", "Include prompt/content usage counts").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        path: "/org/tags",
+        params: cmdOpts.counts ? { counts: "true" } : {},
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("create").description("Create a new tag. Tag names are unique per org (case-insensitive).").requiredOption("--name <name>", "Tag name").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        method: "POST",
+        path: "/org/tags",
+        body: { name: cmdOpts.name },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tag "${cmdOpts.name}" created.`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("get <id>").description("Get a tag by ID, including usage counts.").action(async (id) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({ path: `/org/tags/${id}`, apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("update <id>").description("Rename a tag. Existing attachments on prompts, content, and KB nodes are preserved.").requiredOption("--name <name>", "New tag name").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    try {
+      const data = await apiRequest({
+        method: "PATCH",
+        path: `/org/tags/${id}`,
+        body: { name: cmdOpts.name },
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl
+      });
+      success(`Tag ${id} renamed to "${cmdOpts.name}".`);
+      console.log(JSON.stringify(data, null, 2));
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+  tags.command("delete <id>").description("Delete a tag and detach it from every prompt, content item, and KB node it was applied to. This cannot be undone.").action(async (id) => {
+    const opts = program2.opts();
+    try {
+      await apiRequest({ method: "DELETE", path: `/org/tags/${id}`, apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+      success(`Tag ${id} deleted.`);
+    } catch (err) {
+      error(formatApiError(err));
+      process.exit(1);
+    }
+  });
+}
+
+// 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));
@@ -2538,6 +3408,8 @@ registerIngestCommands(program);
 registerContentCommands(program);
 registerGenerateCommands(program);
 registerEngineCommands(program);
+registerDestinationsCommands(program);
+registerPublishRecordsCommands(program);
 registerBrandKitCommands(program);
 registerContentTypeCommands(program);
 registerPromptCommands(program);
@@ -2548,6 +3420,12 @@ registerCreditsCommands(program);
 registerQuestionsCommands(program);
 registerKBCommands(program);
 registerPermissionsCommands(program);
+registerTagsCommands(program);
+registerProductLineCommands(program);
+registerRolesCommands(program);
+registerCompetitorsCommands(program);
+registerTrackedSourcesCommands(program);
+registerGeneratedContentCommands(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.9.0",
+  "version": "0.11.1",
   "description": "Senso CLI — Infrastructure for the Agentic Web. Interact with your Senso knowledge base from the terminal.",
   "type": "module",
   "bin": {