@series-a/cli 0.15.2 → 0.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-a/cli",
-  "version": "0.15.2",
+  "version": "0.19.1",
   "description": "AdvisorPro command-line interface — drive leads, campaigns, sequences and agents from your terminal.",
   "type": "module",
   "bin": {

package/src/commands/brand.mjs

@@ -0,0 +1,439 @@
+import { call } from "../api.mjs";
+import { emit, fail, ctxFrom, withCommonOpts, confirmDestructive } from "../ui.mjs";
+
+const list = (v) => (v ? String(v).split(",").map((s) => s.trim()).filter(Boolean) : undefined);
+
+function collectFields(o) {
+  const body = {};
+  const text = {
+    primary: "primary_color", secondary: "secondary_color", accent: "accent_color",
+    ctaColor: "cta_color", ctaTextColor: "cta_text_color",
+    fontHeading: "font_heading", fontBody: "font_body", tone: "tone",
+    tagline: "tagline", notes: "notes",
+    logo: "logo_url", logoFull: "logo_full_url", logoFullDark: "logo_full_dark_url",
+    logoIconLight: "logo_icon_light_url", logoIconDark: "logo_icon_dark_url",
+    videoCtaType: "video_default_cta_type", videoCtaLabel: "video_default_cta_label",
+    videoCtaUrl: "video_default_cta_url", videoIntro: "video_intro_text",
+    videoShareDomain: "video_share_domain",
+  };
+  for (const [opt, field] of Object.entries(text)) if (o[opt] !== undefined) body[field] = o[opt];
+  if (o.extraColors !== undefined) body.extra_colors = list(o.extraColors) ?? [];
+  return body;
+}
+
+function printBrand(b) {
+  if (!b) return process.stdout.write("No brand record for this workspace yet.\n");
+  process.stdout.write(
+    `Colours:   primary ${b.primary_color || "-"}  secondary ${b.secondary_color || "-"}  accent ${b.accent_color || "-"}\n` +
+      `CTA:       ${b.cta_color || "-"} on ${b.cta_text_color || "-"}\n` +
+      `Fonts:     heading ${b.font_heading || "-"}  body ${b.font_body || "-"}\n` +
+      `Tone:      ${b.tone || "-"}\n` +
+      `Tagline:   ${b.tagline || "-"}\n` +
+      `Logos:     ${[b.logo_url, b.logo_full_url, b.logo_full_dark_url, b.logo_icon_light_url, b.logo_icon_dark_url].filter(Boolean).length} set\n` +
+      `Imagery:   style ${b.imagery_style || "-"} | mood ${b.imagery_mood || "-"}\n` +
+      `  motifs:  ${(b.imagery_motifs || []).join(", ") || "-"}\n` +
+      `  avoid:   ${b.imagery_avoid || "-"}\n` +
+      `  refs:    ${(b.imagery_reference_urls || []).join(", ") || "-"}\n` +
+      `Voice:     ${b.tone_of_voice_directive ? `${String(b.tone_of_voice_directive).slice(0, 120)}${String(b.tone_of_voice_directive).length > 120 ? "…" : ""}` : "-"}\n` +
+      `  source:  ${b.tone_of_voice_source || "-"}${b.tone_of_voice_synced_at ? ` (synced ${b.tone_of_voice_synced_at})` : ""}\n` +
+      `Video:     cta ${b.video_default_cta_type || "-"}${b.video_default_cta_label ? ` "${b.video_default_cta_label}"` : ""} | domain ${b.video_share_domain || "-"}\n` +
+      `Social:    ${Object.entries(b.reference_library || {}).filter(([k, v]) => k.startsWith("social_") && v).map(([k]) => k.replace(/^social_|_url$/g, "")).join(", ") || "-"}\n` +
+      (b.notes ? `Notes:     ${b.notes}\n` : ""),
+  );
+}
+
+function printImagery(i) {
+  process.stdout.write(
+    `Style:  ${i.imagery_style || "-"}\nMood:   ${i.imagery_mood || "-"}\n` +
+      `Motifs: ${(i.imagery_motifs || []).join(", ") || "-"}\n` +
+      `Avoid:  ${i.imagery_avoid || "-"}\nRefs:   ${(i.imagery_reference_urls || []).join(", ") || "-"}\n`,
+  );
+}
+
+export function registerBrand(program) {
+  const b = program
+    .command("brand")
+    .description("Read and edit the workspace brand: colours, fonts, logos, tagline and imagery direction");
+
+  withCommonOpts(b.command("show"))
+    .alias("get")
+    .description("Show the workspace brand record")
+    .action(async function () {
+      try {
+        const r = await call("brand", "get", {}, ctxFrom(this));
+        emit(this, r, (d) => printBrand(d.brand));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(b.command("set"))
+    .alias("update")
+    .description("Update any brand field (only the flags you pass are changed)")
+    .option("--primary <hex>", "primary colour")
+    .option("--secondary <hex>", "secondary colour")
+    .option("--accent <hex>", "accent colour")
+    .option("--extra-colors <list>", "comma-separated extra colours")
+    .option("--cta-color <hex>", "CTA background colour")
+    .option("--cta-text-color <hex>", "CTA text colour")
+    .option("--font-heading <name>", "heading font")
+    .option("--font-body <name>", "body font")
+    .option("--tone <tone>", "brand tone keyword")
+    .option("--tagline <text>", "tagline")
+    .option("--notes <text>", "brand notes")
+    .option("--logo <url>", "primary logo URL")
+    .option("--logo-full <url>", "full logo URL")
+    .option("--logo-full-dark <url>", "full logo (dark) URL")
+    .option("--logo-icon-light <url>", "icon logo (light) URL")
+    .option("--logo-icon-dark <url>", "icon logo (dark) URL")
+    .option("--video-cta-type <type>", "default video CTA type")
+    .option("--video-cta-label <text>", "default video CTA label")
+    .option("--video-cta-url <url>", "default video CTA URL")
+    .option("--video-intro <text>", "default video intro text")
+    .option("--video-share-domain <domain>", "video share domain")
+    .action(async function (o) {
+      try {
+        const body = collectFields(o);
+        if (!Object.keys(body).length) fail(new Error("Pass at least one field to update."));
+        const r = await call("brand", "update", body, ctxFrom(this));
+        emit(this, r, (d) => { process.stdout.write(`Updated: ${(d.updated || []).join(", ")}\n\n`); printBrand(d.brand); });
+      } catch (e) { fail(e); }
+    });
+
+  // ── imagery direction ──────────────────────────────────────────────────
+  const img = b.command("imagery").description("Manage the imagery direction used for every generated image");
+
+  withCommonOpts(img.command("show"))
+    .alias("get")
+    .description("Show the imagery direction")
+    .action(async function () {
+      try {
+        const r = await call("brand", "imagery", {}, ctxFrom(this));
+        emit(this, r, (d) => printImagery(d.imagery || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(img.command("set"))
+    .alias("update")
+    .description("Set imagery style, motifs, mood, avoid list or reference URLs")
+    .option("--style <text>", "imagery style")
+    .option("--mood <text>", "imagery mood")
+    .option("--avoid <text>", "what to avoid")
+    .option("--motifs <list>", "comma-separated motifs (replaces the list)")
+    .option("--refs <list>", "comma-separated reference URLs (replaces the list)")
+    .action(async function (o) {
+      try {
+        const body = {};
+        if (o.style !== undefined) body.imagery_style = o.style;
+        if (o.mood !== undefined) body.imagery_mood = o.mood;
+        if (o.avoid !== undefined) body.imagery_avoid = o.avoid;
+        if (o.motifs !== undefined) body.imagery_motifs = list(o.motifs) ?? [];
+        if (o.refs !== undefined) body.imagery_reference_urls = list(o.refs) ?? [];
+        if (!Object.keys(body).length) fail(new Error("Pass at least one imagery field."));
+        const r = await call("brand", "set_imagery", body, ctxFrom(this));
+        emit(this, r, (d) => printImagery(d.imagery || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(img.command("add-motifs <motifs>"))
+    .description("Add motifs (comma-separated) without replacing existing ones")
+    .action(async function (m) {
+      try {
+        const r = await call("brand", "add_motifs", { motifs: list(m) }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Motifs: ${(d.imagery_motifs || []).join(", ") || "-"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(img.command("remove-motifs <motifs>"))
+    .description("Remove motifs (comma-separated)")
+    .action(async function (m) {
+      try {
+        const r = await call("brand", "remove_motifs", { motifs: list(m) }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Motifs: ${(d.imagery_motifs || []).join(", ") || "-"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(img.command("add-refs <urls>"))
+    .description("Add reference URLs (comma-separated)")
+    .action(async function (u) {
+      try {
+        const r = await call("brand", "add_reference_urls", { urls: list(u) }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Refs: ${(d.imagery_reference_urls || []).join(", ") || "-"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(img.command("remove-refs <urls>"))
+    .description("Remove reference URLs (comma-separated)")
+    .action(async function (u) {
+      try {
+        const r = await call("brand", "remove_reference_urls", { urls: list(u) }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Refs: ${(d.imagery_reference_urls || []).join(", ") || "-"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(img.command("clear"))
+    .description("Clear the imagery direction (or only --fields style,motifs...)")
+    .option("--fields <list>", "comma-separated imagery fields to clear")
+    .action(async function (o) {
+      try {
+        await confirmDestructive(this, "Clear the workspace imagery direction.");
+        const fields = list(o.fields)?.map((f) => (f.startsWith("imagery_") ? f : `imagery_${f}`));
+        const r = await call("brand", "clear_imagery", fields ? { fields } : {}, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Cleared: ${(d.cleared || []).join(", ")}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  // ── logos ──────────────────────────────────────────────────────────────
+  const printLogos = (l = {}) =>
+    process.stdout.write(
+      `Primary:    ${l.logo_url || "-"}\nFull:       ${l.logo_full_url || "-"}\n` +
+        `Full dark:  ${l.logo_full_dark_url || "-"}\nIcon light: ${l.logo_icon_light_url || "-"}\n` +
+        `Icon dark:  ${l.logo_icon_dark_url || "-"}\n`,
+    );
+
+  const lg = b.command("logos").alias("logo").description("Manage the workspace logo files and URLs");
+
+  withCommonOpts(lg.command("show"))
+    .alias("get")
+    .description("Show every logo variant")
+    .action(async function () {
+      try {
+        const r = await call("brand", "logos", {}, ctxFrom(this));
+        emit(this, r, (d) => printLogos(d.logos || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(lg.command("set <variant> <url>"))
+    .description("Point a logo variant (full, full_dark, icon_light, icon_dark, primary) at a URL")
+    .action(async function (variant, url) {
+      try {
+        const r = await call("brand", "set_logos", { variant, url }, ctxFrom(this));
+        emit(this, r, (d) => printLogos(d.logos || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(lg.command("upload <file>"))
+    .description("Upload a logo image file and store it against a variant")
+    .option("--variant <variant>", "full, full_dark, icon_light, icon_dark or primary", "full")
+    .action(async function (file, o) {
+      try {
+        const { readFile } = await import("node:fs/promises");
+        const path = await import("node:path");
+        const buf = await readFile(file);
+        if (buf.byteLength > 5 * 1024 * 1024) fail(new Error("Logo must be under 5 MB."));
+        const body = {
+          variant: o.variant,
+          filename: path.basename(file),
+          data: buf.toString("base64"),
+        };
+        const r = await call("brand", "upload_logo", body, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(`Uploaded ${d.uploaded?.variant}: ${d.uploaded?.url}\n\n`);
+          printLogos(d.logos || {});
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(lg.command("clear"))
+    .description("Remove all logos, or only --variants full,icon_dark")
+    .option("--variants <list>", "comma-separated variants to clear")
+    .action(async function (o) {
+      try {
+        await confirmDestructive(this, "Clear the workspace logos.");
+        const variants = list(o.variants);
+        const r = await call("brand", "clear_logos", variants ? { variants } : {}, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Cleared: ${(d.cleared || []).join(", ")}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  // ── social links ───────────────────────────────────────────────────────
+  const NETWORKS = ["linkedin", "twitter", "facebook", "instagram", "youtube", "tiktok", "threads", "github"];
+  const printSocial = (s = {}) =>
+    process.stdout.write(NETWORKS.map((n) => `${(n + ":").padEnd(11)}${s[n] || "-"}`).join("\n") + "\n");
+
+  const so = b.command("social").description("Manage the brand's social profile links");
+
+  withCommonOpts(so.command("show"))
+    .alias("get")
+    .description("Show the social profile links")
+    .action(async function () {
+      try {
+        const r = await call("brand", "social", {}, ctxFrom(this));
+        emit(this, r, (d) => printSocial(d.social || {}));
+      } catch (e) { fail(e); }
+    });
+
+  const soSet = withCommonOpts(so.command("set"))
+    .alias("update")
+    .description("Set one or more social profile links");
+  for (const n of NETWORKS) soSet.option(`--${n} <url>`, `${n} profile URL`);
+  soSet.action(async function (o) {
+    try {
+      const body = {};
+      for (const n of NETWORKS) if (o[n] !== undefined) body[n] = o[n];
+      if (!Object.keys(body).length) fail(new Error(`Pass at least one of: ${NETWORKS.map((n) => `--${n}`).join(", ")}.`));
+      const r = await call("brand", "set_social", body, ctxFrom(this));
+      emit(this, r, (d) => printSocial(d.social || {}));
+    } catch (e) { fail(e); }
+  });
+
+  withCommonOpts(so.command("clear"))
+    .description("Remove all social links, or only --networks linkedin,github")
+    .option("--networks <list>", "comma-separated networks to clear")
+    .action(async function (o) {
+      try {
+        await confirmDestructive(this, "Clear the workspace social links.");
+        const networks = list(o.networks);
+        const r = await call("brand", "clear_social", networks ? { networks } : {}, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Cleared: ${(d.cleared || []).join(", ")}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  // ── video share branding ───────────────────────────────────────────────
+  const printVideo = (v = {}) =>
+    process.stdout.write(
+      `CTA type:   ${v.video_default_cta_type || "-"}\nCTA label:  ${v.video_default_cta_label || "-"}\n` +
+        `CTA URL:    ${v.video_default_cta_url || "-"}\nIntro text: ${v.video_intro_text || "-"}\n` +
+        `Share domain: ${v.video_share_domain || "-"}\n`,
+    );
+
+  const vd = b.command("video").description("Manage the branded video share page defaults");
+
+  withCommonOpts(vd.command("show"))
+    .alias("get")
+    .description("Show the video share branding defaults")
+    .action(async function () {
+      try {
+        const r = await call("brand", "video", {}, ctxFrom(this));
+        emit(this, r, (d) => printVideo(d.video || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(vd.command("set"))
+    .alias("update")
+    .description("Set the default video CTA, intro text or share domain")
+    .option("--cta-type <type>", "default CTA type (e.g. booking, website, none)")
+    .option("--cta-label <text>", "button label")
+    .option("--cta-url <url>", "CTA destination URL")
+    .option("--intro <text>", "intro text shown on the share page")
+    .option("--share-domain <domain>", "custom share domain")
+    .action(async function (o) {
+      try {
+        const body = {};
+        if (o.ctaType !== undefined) body.video_default_cta_type = o.ctaType;
+        if (o.ctaLabel !== undefined) body.video_default_cta_label = o.ctaLabel;
+        if (o.ctaUrl !== undefined) body.video_default_cta_url = o.ctaUrl;
+        if (o.intro !== undefined) body.video_intro_text = o.intro;
+        if (o.shareDomain !== undefined) body.video_share_domain = o.shareDomain;
+        if (!Object.keys(body).length) fail(new Error("Pass at least one video field."));
+        const r = await call("brand", "set_video", body, ctxFrom(this));
+        emit(this, r, (d) => printVideo(d.video || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(vd.command("clear"))
+    .description("Clear the video share defaults (or only --fields cta_url,intro_text)")
+    .option("--fields <list>", "comma-separated video fields to clear")
+    .action(async function (o) {
+      try {
+        await confirmDestructive(this, "Clear the video share branding defaults.");
+        const fields = list(o.fields)?.map((f) => (f.startsWith("video_") ? f : `video_${f}`));
+        const r = await call("brand", "clear_video", fields ? { fields } : {}, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Cleared: ${(d.cleared || []).join(", ")}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  // ── tone of voice ──────────────────────────────────────────────────────
+
+  const tv = b.command("tone").description("Manage the tone of voice directive used when writing copy");
+
+  const printTone = (t = {}) =>
+    process.stdout.write(
+      `Keyword:   ${t.tone || "-"}\nDirective: ${t.directive || "-"}\n` +
+        `Source:    ${t.source || "-"}\nSynced:    ${t.synced_at || "-"}\n` +
+        (t.apply_by_default === undefined ? "" : `Applied by default: ${t.apply_by_default ? "yes" : "no"}\n`),
+    );
+
+  withCommonOpts(tv.command("show"))
+    .alias("get")
+    .description("Show the tone of voice directive")
+    .action(async function () {
+      try {
+        const r = await call("brand", "tone", {}, ctxFrom(this));
+        emit(this, r, (d) => printTone(d.tone || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(tv.command("set"))
+    .alias("update")
+    .description("Set the tone of voice directive (and optional keyword/source)")
+    .option("--directive <text>", "the tone of voice directive")
+    .option("--file <path>", "read the directive from a file")
+    .option("--source <name>", "where it came from (default: manual)")
+    .option("--keyword <tone>", "short brand tone keyword")
+    .action(async function (o) {
+      try {
+        const body = {};
+        if (o.file) body.directive = await (await import("node:fs/promises")).readFile(o.file, "utf8");
+        if (o.directive !== undefined) body.directive = o.directive;
+        if (o.source !== undefined) body.source = o.source;
+        if (o.keyword !== undefined) body.tone = o.keyword;
+        if (!Object.keys(body).length) fail(new Error("Pass --directive, --file or --keyword."));
+        const r = await call("brand", "set_tone", body, ctxFrom(this));
+        emit(this, r, (d) => printTone(d.tone || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(tv.command("clear"))
+    .description("Remove the tone of voice directive")
+    .action(async function () {
+      try {
+        await confirmDestructive(this, "Clear this workspace's tone of voice directive.");
+        const r = await call("brand", "clear_tone", {}, ctxFrom(this));
+        emit(this, r, () => process.stdout.write("Tone of voice cleared.\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(tv.command("apply <on|off>"))
+    .description("Apply the tone of voice by default when generating content")
+    .action(async function (v) {
+      try {
+        const enabled = ["on", "true", "yes", "1"].includes(String(v).toLowerCase());
+        const r = await call("brand", "set_tone_default", { apply_by_default: enabled }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`Applied by default: ${d.apply_by_default ? "yes" : "no"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(tv.command("sync"))
+    .description("Pull the latest tone of voice from Business Build")
+    .option("--email <email>", "client identity email to resolve against")
+    .action(async function (o) {
+      try {
+        const r = await call("brand", "sync_tone", o.email ? { email: o.email } : {}, ctxFrom(this));
+        emit(this, r, (d) => printTone(d.tone || {}));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(b.command("delete"))
+    .alias("reset")
+    .description("Delete the entire brand record for this workspace")
+    .action(async function () {
+      try {
+        await confirmDestructive(this, "Delete this workspace's whole brand record.");
+        const r = await call("brand", "delete", {}, ctxFrom(this));
+        emit(this, r, () => process.stdout.write("Brand record deleted.\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(b.command("fields"))
+    .description("List every editable brand field")
+    .action(async function () {
+      try {
+        const r = await call("brand", "fields", {}, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `Text: ${(d.text_fields || []).join(", ")}\nLists: ${(d.list_fields || []).join(", ")}\n` +
+            `Imagery: ${(d.imagery_fields || []).join(", ")}\nTone: ${(d.tone_fields || []).join(", ")}\n` +
+            `Logos: ${(d.logo_fields || []).join(", ")}\nLogo variants: ${(d.logo_variants || []).join(", ")}\n` +
+            `Video: ${(d.video_fields || []).join(", ")}\nSocial: ${(d.social_networks || []).join(", ")}\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+}

package/src/commands/insights.mjs

@@ -1231,16 +1231,185 @@ export function registerWatchlist(program) {
       } catch (e) { fail(e); }
     });
 
+  withCommonOpts(w.command("show <id>"))
+    .description("Show one watchlist item")
+    .action(async function (id) {
+      try {
+        const r = await call("watchlist", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const x = d.item || {};
+          process.stdout.write(
+            `${x.name}\n  id: ${x.id}\n  type: ${n(x.type)}\n  priority: ${n(x.priority_label || x.priority)}\n` +
+            `  keywords: ${(x.keywords || []).join(", ") || "(none)"}\n  active: ${x.is_active}\n  matches: ${n(x.match_count)}\n`,
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(w.command("update <id>"))
+    .description("Update a watchlist item")
+    .option("--name <name>", "new name")
+    .option("--type <t>", "company|person|topic|competitor|keyword")
+    .option("--priority <p>", "P0|P1|P2|P3")
+    .option("--keywords <list>", "comma-separated keywords (replaces the list)")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const body = { id };
+        if (o.name) body.name = o.name;
+        if (o.type) body.type = o.type;
+        if (o.priority) body.priority = o.priority;
+        if (o.keywords !== undefined) body.keywords = o.keywords.split(",").map((s) => s.trim()).filter(Boolean);
+        const r = await call("watchlist", "update", body, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✔ Updated ${d.item?.name}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(w.command("tag <id> <keywords>"))
+    .description("Add keyword tags (comma-separated) to a watchlist item")
+    .action(async function (id, keywords) {
+      try {
+        const r = await call("watchlist", "add_keywords", {
+          id, keywords: keywords.split(",").map((s) => s.trim()).filter(Boolean),
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✔ ${d.item?.name}: ${(d.item?.keywords || []).join(", ")}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(w.command("untag <id> <keywords>"))
+    .description("Remove keyword tags (comma-separated) from a watchlist item")
+    .action(async function (id, keywords) {
+      try {
+        const r = await call("watchlist", "remove_keywords", {
+          id, keywords: keywords.split(",").map((s) => s.trim()).filter(Boolean),
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✔ ${d.item?.name}: ${(d.item?.keywords || []).join(", ") || "(none)"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(w.command("toggle <id>"))
+    .description("Activate or deactivate a watchlist item")
+    .option("--on", "force active")
+    .option("--off", "force inactive")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const body = { id };
+        if (o.on) body.is_active = true;
+        if (o.off) body.is_active = false;
+        const r = await call("watchlist", "toggle", body, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✔ ${d.item?.name} → ${d.item?.is_active ? "active" : "inactive"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(w.command("suggest"))
+    .description("Generate watchlist suggestions from the knowledge base")
+    .action(async function () {
+      try {
+        const r = await call("watchlist", "suggest", {}, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✔ Added ${d.added ?? 0} suggested items\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(w.command("sync-prompts"))
+    .description("Resync the agent intelligence prompts derived from the watchlist")
+    .action(async function () {
+      try {
+        const r = await call("watchlist", "sync_prompts", {}, ctxFrom(this));
+        emit(this, r, () => process.stdout.write("✔ Prompts resynced\n"));
+      } catch (e) { fail(e); }
+    });
+
   withCommonOpts(w.command("remove <id>"))
-    .description("Remove a watchlist item")
+    .description("Remove a watchlist item (suppressed by default so it is not re-suggested)")
+    .option("--hard", "permanently delete the row")
     .action(async function (id) {
       try {
-        const r = await call("watchlist", "remove", { id }, ctxFrom(this));
+        const o = this.optsWithGlobals();
+        const r = await call("watchlist", "remove", { id, hard: !!o.hard }, ctxFrom(this));
         emit(this, r, () => process.stdout.write(`✔ Removed ${id}\n`));
       } catch (e) { fail(e); }
     });
 }
 
+export function registerIntelligencePrompts(program) {
+  const p = program.command("intel-prompts")
+    .description("Agent intelligence prompts (news, competitive, market, leads, content)");
+
+  withCommonOpts(p.command("list"))
+    .description("List the workspace intelligence prompts")
+    .action(async function () {
+      try {
+        const r = await call("intelligence_prompts", "list", {}, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["type", "source", "active", "prompt"],
+            (d.prompts || []).map((x) => [
+              n(x.prompt_type), x.is_auto === false ? "manual" : "auto",
+              String(!!x.is_active), truncate(n(x.prompt_text).replace(/\s+/g, " "), 70),
+            ]),
+          ) + "\n");
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("show <type>"))
+    .description("Show one prompt in full")
+    .action(async function (type) {
+      try {
+        const r = await call("intelligence_prompts", "get", { prompt_type: type }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`${n(d.prompt?.prompt_text)}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("set <type>"))
+    .description("Override a prompt with custom text (marks it manual)")
+    .option("--text <text>", "prompt text")
+    .option("--file <path>", "read prompt text from a file")
+    .action(async function (type) {
+      try {
+        const o = this.optsWithGlobals();
+        const text = o.file ? await readFile(o.file, "utf8") : o.text;
+        if (!text) throw new Error("--text or --file required");
+        const r = await call("intelligence_prompts", "set", { prompt_type: type, prompt_text: text }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✔ ${d.prompt?.prompt_type} updated (manual override)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("toggle <type>"))
+    .description("Activate or deactivate a prompt")
+    .option("--on", "force active")
+    .option("--off", "force inactive")
+    .action(async function (type) {
+      try {
+        const o = this.optsWithGlobals();
+        const body = { prompt_type: type };
+        if (o.on) body.is_active = true;
+        if (o.off) body.is_active = false;
+        const r = await call("intelligence_prompts", "toggle", body, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✔ ${d.prompt?.prompt_type} → ${d.prompt?.is_active ? "active" : "inactive"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("reset <type>"))
+    .description("Reset a prompt back to auto (regenerated from the watchlist)")
+    .action(async function (type) {
+      try {
+        const r = await call("intelligence_prompts", "reset", { prompt_type: type }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write(`✔ ${type} reset to auto\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("resync"))
+    .description("Regenerate all auto prompts from the current watchlist")
+    .action(async function () {
+      try {
+        const r = await call("intelligence_prompts", "resync", {}, ctxFrom(this));
+        emit(this, r, () => process.stdout.write("✔ Prompts resynced\n"));
+      } catch (e) { fail(e); }
+    });
+}
+
 export function registerMeetings(program) {
   const m = program.command("meetings").description("Meeting transcripts (anonymised)");
 

package/src/commands/resources.mjs

@@ -938,6 +938,50 @@ export function registerKnowledge(program) {
       } catch (e) { fail(e); }
     });
 
+  withCommonOpts(k.command("approve <id...>"))
+    .description("Confirm knowledge item(s) as the client's own material (unlocks voice training + evidence use)")
+    .option("--author-name <name>", "Attribute to a named expert")
+    .option("--authorship <kind>", "human|expert|client|team (default human)")
+    .action(async function (ids, opts) {
+      try {
+        const payload = ids.length > 1
+          ? { ids, author_name: opts.authorName, authorship: opts.authorship }
+          : { id: ids[0], author_name: opts.authorName, authorship: opts.authorship };
+        const r = await call("knowledge", "approve", payload, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Confirmed ${(d.items || [d.item]).filter(Boolean).length} item(s)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(k.command("reject <id...>"))
+    .description("Mark knowledge item(s) as NOT the client's own material")
+    .action(async function (ids) {
+      try {
+        const payload = ids.length > 1 ? { ids } : { id: ids[0] };
+        const r = await call("knowledge", "reject", payload, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Rejected ${(d.items || [d.item]).filter(Boolean).length} item(s)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(k.command("set-authorship <id>"))
+    .description("Set who wrote a knowledge item (human|expert|client|team|ai|unknown)")
+    .requiredOption("--authorship <kind>", "human|expert|client|team|ai|unknown")
+    .option("--author-name <name>", "Named author")
+    .option("--approval-status <status>", "approved|pending|rejected")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("knowledge", "set_authorship", {
+          id,
+          authorship: opts.authorship,
+          author_name: opts.authorName,
+          approval_status: opts.approvalStatus,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const it = d.item || {};
+          process.stdout.write(`✓ ${it.id}: ${it.authorship}${it.author_name ? ` (${it.author_name})` : ""} · ${it.approval_status}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
   withCommonOpts(k.command("reclassify <id>"))
     .description("Re-run AI auto-tag/classify (same as the UI 'sparkles' button)")
     .action(async function (id) {

package/src/index.mjs

@@ -1,5 +1,6 @@
 import { registerStrategies } from "./commands/strategies.mjs";
 import { registerVoice } from "./commands/voice.mjs";
+import { registerBrand } from "./commands/brand.mjs";
 import { Command } from "commander";
 import { readFileSync } from "node:fs";
 import { registerAuth } from "./commands/auth.mjs";
@@ -12,7 +13,7 @@ import {
 import {
   registerCampaignAnalytics, registerAnalytics, registerSafety, registerCtas,
   registerNotifications, registerAudiences, registerNewsletter, registerVideo,
-  registerWatchlist, registerMeetings, registerActivity, registerWorkspacesExtras,
+  registerWatchlist, registerIntelligencePrompts, registerMeetings, registerActivity, registerWorkspacesExtras,
   registerExport, registerIntegrations, registerAudit, registerReports,
 } from "./commands/insights.mjs";
 import { registerFlow } from "./commands/flow.mjs";
@@ -40,6 +41,7 @@ registerSignals(program);
 registerPipelines(program);
 registerStrategies(program);
 registerVoice(program);
+registerBrand(program);
 registerAuthority(program);
 registerBriefs(program);
 registerAgents(program);
@@ -55,6 +57,7 @@ registerAudiences(program);
 registerNewsletter(program);
 registerVideo(program);
 registerWatchlist(program);
+registerIntelligencePrompts(program);
 registerMeetings(program);
 registerActivity(program);
 registerAudit(program);