@senso-ai/cli 0.8.2 → 0.11.0

package/README.md

@@ -141,7 +141,7 @@ Options: `content list` supports `--limit`, `--offset`, `--search`, `--sort`. `c
 ```
 senso generate settings              Get generation settings
 senso generate update-settings       Update generation settings (--data)
-senso generate sample                Generate sample for a prompt (--prompt-id, --content-type-id)
+senso generate sample                Generate sample for a prompt; waits for async job by default (--prompt-id, --content-type-id, --no-wait)
 senso generate run                   Trigger a content engine run (--prompt-ids)
 ```
 

package/dist/cli.js

@@ -1295,6 +1295,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,11 +1369,23 @@ 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);
@@ -1430,9 +1463,90 @@ 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
+var SAMPLE_JOB_POLL_INTERVAL_MS = 2e3;
+var SAMPLE_JOB_TIMEOUT_MS = 18e4;
 function registerGenerateCommands(program2) {
   const gen = program2.command("generate").description("AI content generation. Configure settings, generate content samples from prompts, or trigger full content engine runs.");
   gen.command("settings").description("Get content generation settings. Shows whether generation and auto-publish are enabled, the content schedule, and configured publishers.").action(async () => {
@@ -1457,7 +1571,7 @@ function registerGenerateCommands(program2) {
       process.exit(1);
     }
   });
-  gen.command("sample").description("Generate an ad hoc content sample for a specific prompt and content type. Returns the generated markdown, SEO title, and publish results. Use 'prompts list' to find a prompt ID, and 'content-types list' to find a content-type ID.").requiredOption("--prompt-id <id>", "Prompt (geo question) ID to generate content for").requiredOption("--content-type-id <id>", "Content type ID that defines the output format (use 'content-types list' to find)").option("--destination <dest>", "Publisher slug to publish to immediately after generation. Omit to save as draft only.").action(async (cmdOpts) => {
+  gen.command("sample").description("Generate an ad hoc content sample for a specific prompt and content type. Submits an async job, waits for completion by default, then returns the generated markdown, SEO title, and publish results. Use 'prompts list' to find a prompt ID, and 'content-types list' to find a content-type ID.").requiredOption("--prompt-id <id>", "Prompt (geo question) ID to generate content for").requiredOption("--content-type-id <id>", "Content type ID that defines the output format (use 'content-types list' to find)").option("--destination <dest>", "Publisher slug to publish to immediately after generation. Omit to save as draft only.").option("--no-wait", "Return the accepted sample job immediately instead of polling for the generated content.").action(async (cmdOpts) => {
     const opts = program2.opts();
     try {
       const body = {
@@ -1474,7 +1588,25 @@ function registerGenerateCommands(program2) {
         apiKey: opts.apiKey,
         baseUrl: opts.baseUrl
       });
-      console.log(JSON.stringify(data, null, 2));
+      if (cmdOpts.wait === false) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      const quiet = opts.quiet || opts.output === "json";
+      if (!quiet) {
+        info(`Sample job accepted: ${data.sample_job_id}`);
+      }
+      const job = await waitForSampleJob(data.sample_job_id, {
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl,
+        quiet
+      });
+      if (job.status === "completed") {
+        console.log(JSON.stringify(job.result ?? job, null, 2));
+        return;
+      }
+      const message = job.error?.message || `Sample job ended with status: ${job.status}`;
+      throw new Error(job.error?.code ? `${message} (${job.error.code})` : message);
     } catch (err) {
       error(formatApiError(err));
       process.exit(1);
@@ -1568,14 +1700,40 @@ function registerGenerateCommands(program2) {
     }
   });
 }
+async function waitForSampleJob(sampleJobId, opts) {
+  const deadline = Date.now() + SAMPLE_JOB_TIMEOUT_MS;
+  let lastStatus = "";
+  while (Date.now() < deadline) {
+    const job = await apiRequest({
+      path: `/org/content-generation/sample-jobs/${sampleJobId}`,
+      apiKey: opts.apiKey,
+      baseUrl: opts.baseUrl
+    });
+    if (!opts.quiet && job.status !== lastStatus) {
+      info(`Sample job status: ${job.status}`);
+      lastStatus = job.status;
+    }
+    if (job.status === "completed" || job.status === "failed" || job.status === "expired") {
+      return job;
+    }
+    await sleep(SAMPLE_JOB_POLL_INTERVAL_MS);
+  }
+  throw new Error(`Timed out waiting for sample job ${sampleJobId}. Poll /org/content-generation/sample-jobs/${sampleJobId} for status.`);
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, 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.").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) => {
     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",
@@ -1590,7 +1748,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);
@@ -1610,6 +1768,100 @@ 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 {
+      const data = 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));
+    } 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.");
@@ -1811,6 +2063,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
@@ -2426,6 +2757,85 @@ function registerKBCommands(program2) {
       process.exit(1);
     }
   });
+  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/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
@@ -2443,6 +2853,174 @@ function registerPermissionsCommands(program2) {
   });
 }
 
+// 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/update.ts
 import semver2 from "semver";
 import pc10 from "picocolors";
@@ -2495,6 +3073,8 @@ registerIngestCommands(program);
 registerContentCommands(program);
 registerGenerateCommands(program);
 registerEngineCommands(program);
+registerDestinationsCommands(program);
+registerPublishRecordsCommands(program);
 registerBrandKitCommands(program);
 registerContentTypeCommands(program);
 registerPromptCommands(program);
@@ -2505,6 +3085,8 @@ registerCreditsCommands(program);
 registerQuestionsCommands(program);
 registerKBCommands(program);
 registerPermissionsCommands(program);
+registerTagsCommands(program);
+registerProductLineCommands(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.8.2",
+  "version": "0.11.0",
   "description": "Senso CLI — Infrastructure for the Agentic Web. Interact with your Senso knowledge base from the terminal.",
   "type": "module",
   "bin": {