@series-a/cli 1.2.0 → 1.3.1

package/src/commands/resources.mjs

@@ -0,0 +1,2196 @@
+import { readFile } from "node:fs/promises";
+import { call } from "../api.mjs";
+import { emit, fail, ctxFrom, withCommonOpts, table, truncate, confirmDestructive } from "../ui.mjs";
+
+function parseCsv(text) {
+  // Tiny CSV parser: header row + comma-separated values, quoted fields supported.
+  const lines = text.split(/\r?\n/).filter((l) => l.trim().length);
+  if (!lines.length) return [];
+  const split = (line) => {
+    const out = []; let cur = ""; let q = false;
+    for (let i = 0; i < line.length; i++) {
+      const c = line[i];
+      if (q) {
+        if (c === '"' && line[i+1] === '"') { cur += '"'; i++; }
+        else if (c === '"') { q = false; }
+        else cur += c;
+      } else {
+        if (c === ",") { out.push(cur); cur = ""; }
+        else if (c === '"') { q = true; }
+        else cur += c;
+      }
+    }
+    out.push(cur);
+    return out.map((s) => s.trim());
+  };
+  const headers = split(lines[0]).map((h) => h.toLowerCase());
+  return lines.slice(1).map((line) => {
+    const cells = split(line);
+    const row = {};
+    headers.forEach((h, i) => { row[h] = cells[i] ?? ""; });
+    return row;
+  });
+}
+
+export function registerLeads(program) {
+  const leads = program.command("leads").description("Manage leads");
+
+  withCommonOpts(leads.command("list"))
+    .description("List leads")
+    .option("--status <s>", "filter by status")
+    .option("--persona <p>", "filter by persona_tag")
+    .option("--search <q>", "search name or company")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("leads", "list", {
+          status: o.status, persona_tag: o.persona, search: o.search, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "name", "title", "company", "status"],
+            (d.leads || []).map((l) => [
+              truncate(l.id, 8), truncate(l.name, 28), truncate(l.title, 24),
+              truncate(l.company, 22), l.status ?? "",
+            ]),
+          ) + `\n${d.leads?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("get <id>"))
+    .description("Show a single lead")
+    .action(async function (id) {
+      try {
+        const r = await call("leads", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.lead, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("set-status <id> <status>"))
+    .description("Update a lead's status")
+    .action(async function (id, status) {
+      try {
+        const r = await call("leads", "update_status", { id, status }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.lead?.name ?? id} → ${d.lead?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("import"))
+    .description("Bulk upsert leads from a CSV or JSON/JSONL file")
+    .requiredOption("--file <path>", "leads.csv | leads.json | leads.jsonl")
+    .option("--persona <tag>", "default persona_tag for all rows")
+    .option("--source <s>", "default source", "cli")
+    .action(async function (opts) {
+      try {
+        const text = await readFile(opts.file, "utf8");
+        let rows;
+        if (opts.file.endsWith(".jsonl")) {
+          rows = text.split(/\r?\n/).filter(Boolean).map((l) => JSON.parse(l));
+        } else if (opts.file.endsWith(".json")) {
+          const parsed = JSON.parse(text);
+          rows = Array.isArray(parsed) ? parsed : (parsed.leads ?? []);
+        } else {
+          rows = parseCsv(text);
+        }
+        if (opts.persona) rows.forEach((r) => { r.persona_tag = r.persona_tag || opts.persona; });
+        rows.forEach((r) => { r.source = r.source || opts.source; });
+
+        // Send in chunks of 200 to respect API limit (500).
+        const chunks = [];
+        for (let i = 0; i < rows.length; i += 200) chunks.push(rows.slice(i, i + 200));
+        let total = 0;
+        for (const chunk of chunks) {
+          const r = await call("leads", "bulk_upsert", { leads: chunk }, ctxFrom(this));
+          total += r.count ?? 0;
+        }
+        emit(this, { upserted: total, total_rows: rows.length }, (d) =>
+          process.stdout.write(`✓ Upserted ${d.upserted}/${d.total_rows} leads\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("import-from <source>"))
+    .description("Import leads from any source: linkedin_search | company_search | post_reactors | paste_profiles | csv | heyreach | sales_nav_url | sales_nav_keywords")
+    .option("--query <q>", "search keywords (linkedin_search / company_search / sales_nav_keywords)")
+    .option("--url <url>", "full Sales Navigator search URL (sales_nav_url)")
+    .option("--post <url>", "LinkedIn post URL (post_reactors)")
+    .option("--file <path>", "CSV or pasted-profile text file (csv / paste_profiles / heyreach)")
+    .option("--audience <name>", "audience (segment) name or id to attach to")
+    .option("--campaign <id>", "campaign id (required for heyreach)")
+    .option("--priority <p>", "queue priority for Sales Navigator imports: normal | high | rush")
+    .option("--limit <n>", "max prospects for LinkedIn sources", "50")
+    .option("--no-enrich", "skip the LinkedIn verify + enrich chain")
+    .action(async function (source) {
+      try {
+        const o = this.optsWithGlobals();
+        const params = {
+          source,
+          query: o.query,
+          search_url: o.url,
+          post_url: o.post,
+          audience: o.audience,
+          campaign_id: o.campaign,
+          priority: o.priority,
+          limit: Number(o.limit),
+          enrich: o.enrich !== false,
+        };
+        if (o.file) {
+          const text = await readFile(o.file, "utf8");
+          if (source === "paste_profiles") params.text = text;
+          else params.csv = text;
+        }
+        const r = await call("leads", "import", params, ctxFrom(this));
+        emit(this, r, (d) => {
+          if (d.schedule) {
+            process.stdout.write(
+              `${d.reused ? "↻ Reusing existing" : "✓ Queued"} background import — ${d.schedule.target_count} leads\n` +
+              `  schedule: ${d.schedule.id} (${d.schedule.status})\n` +
+              `  It drip-feeds inside your LinkedIn read limits. Track with \`advisoros leads import-schedules\`.\n`,
+            );
+            return;
+          }
+          process.stdout.write(
+            `✓ Imported ${d.imported ?? 0} leads (${d.duplicates ?? 0} duplicates, ${d.skipped ?? 0} skipped, ${d.failed ?? 0} failed)\n` +
+            (d.job_id ? `  job: ${d.job_id}\n` : ""));
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("import-schedules"))
+    .description("List queued/running Sales Navigator background imports")
+    .option("--status <s>", "filter by status (queued|running|awaiting_capacity|paused|completed|failed|cancelled)")
+    .option("--all", "include finished imports")
+    .option("--limit <n>", "max rows", "25")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("leads", "import_schedules", {
+          status: o.status,
+          active: o.all ? false : true,
+          limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => table(d.schedules ?? [], [
+          ["id", (s) => s.id.slice(0, 8)],
+          ["status", (s) => s.status],
+          ["progress", (s) => `${s.imported_count}/${s.target_count}`],
+          ["priority", (s) => s.priority],
+          ["source", (s) => s.source],
+          ["target", (s) => truncate(s.search_url || s.search_query || "", 48)],
+          ["reason", (s) => truncate(s.last_reason || "", 40)],
+        ]));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("import-schedule <action> <id>"))
+    .description("Pause, resume or cancel a scheduled import (action: pause|resume|cancel)")
+    .action(async function (action, id) {
+      try {
+        const r = await call("leads", "import_schedule_update", { id, action }, ctxFrom(this));
+        emit(this, r, (d) =>
+          process.stdout.write(`✓ Import ${d.schedule.id} is now ${d.schedule.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+
+  withCommonOpts(leads.command("import-status <jobId>"))
+    .description("Poll a running lead import")
+    .action(async function (jobId) {
+      try {
+        const r = await call("leads", "import_status", { job_id: jobId }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.job, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("update <id>"))
+    .description("Update a single lead")
+    .option("--name <v>").option("--title <v>").option("--company <v>")
+    .option("--email <v>").option("--linkedin <v>").option("--persona <v>")
+    .option("--score <n>").option("--status <v>").option("--notes <v>")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const params = { id };
+        for (const [k, v] of Object.entries({
+          name: o.name, title: o.title, company: o.company, email: o.email,
+          linkedin_url: o.linkedin, persona_tag: o.persona,
+          score: o.score !== undefined ? Number(o.score) : undefined,
+          status: o.status, notes: o.notes,
+        })) if (v !== undefined) params[k] = v;
+        const r = await call("leads", "update", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.lead?.name ?? id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("delete <id>"))
+    .description("Delete a lead")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete lead ${id}. This cannot be undone.`);
+        const r = await call("leads", "delete", { id }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write(`✓ Deleted ${id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("verify <id>"))
+    .description("Run LinkedIn verification on a lead")
+    .action(async function (id) {
+      try {
+        const r = await call("leads", "verify", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.verify, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerCampaigns(program) {
+  const c = program.command("campaigns").description("Manage LinkedIn campaigns");
+
+  withCommonOpts(c.command("list"))
+    .description("List campaigns")
+    .option("--status <s>", "filter by status")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("campaigns", "list", { status: o.status, limit: Number(o.limit) }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "name", "status", "sequence", "daily", "senders"],
+            (d.campaigns || []).map((cp) => [
+              truncate(cp.id, 8), truncate(cp.name, 30), cp.status,
+              truncate(cp.sequence_id, 8), cp.daily_send_limit ?? "",
+              (cp.sender_accounts || []).length,
+            ]),
+          ) + `\n${d.campaigns?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("show <id>"))
+    .description("Show campaign details + stats")
+    .action(async function (id) {
+      try {
+        const r = await call("campaigns", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.campaign, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("create"))
+    .description("Create a new draft campaign")
+    .requiredOption("--name <name>", "campaign name")
+    .option("--description <text>", "description")
+    .option("--goal <text>", "campaign goal")
+    .option("--sequence <id>", "attach a sequence")
+    .option("--senders <csv>", "comma-separated sender_account_ids")
+    .option("--daily-limit <n>", "daily send cap", "25")
+    .action(async function (opts) {
+      try {
+        const r = await call("campaigns", "create", {
+          name: opts.name,
+          description: opts.description,
+          goal: opts.goal,
+          sequence_id: opts.sequence,
+          sender_accounts: opts.senders ? opts.senders.split(",").map((s) => s.trim()).filter(Boolean) : [],
+          daily_send_limit: Number(opts.dailyLimit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Created campaign ${d.campaign?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("update <campaignId>"))
+    .description("Edit an existing campaign")
+    .option("--name <name>", "rename campaign")
+    .option("--description <text>", "description")
+    .option("--goal <text>", "campaign goal")
+    .option("--sequence <id>", "attach a sequence")
+    .option("--senders <csv>", "comma-separated sender_account_ids")
+    .option("--daily-limit <n>", "daily send cap")
+    .option("--status <status>", "draft|active|paused|completed|archived")
+    .action(async function (campaignId, opts) {
+      try {
+        const payload = { id: campaignId };
+        if (opts.name !== undefined) payload.name = opts.name;
+        if (opts.description !== undefined) payload.description = opts.description;
+        if (opts.goal !== undefined) payload.goal = opts.goal;
+        if (opts.sequence !== undefined) payload.sequence_id = opts.sequence;
+        if (opts.senders !== undefined) {
+          payload.sender_accounts = opts.senders.split(",").map((s) => s.trim()).filter(Boolean);
+        }
+        if (opts.dailyLimit !== undefined) payload.daily_send_limit = Number(opts.dailyLimit);
+        if (opts.status !== undefined) payload.status = opts.status;
+        const r = await call("campaigns", "update", payload, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated campaign ${d.campaign?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("rename <campaignId> <name>"))
+    .description("Rename a campaign (shortcut for update --name)")
+    .action(async function (campaignId, name) {
+      try {
+        const r = await call("campaigns", "update", { id: campaignId, name }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Renamed campaign ${d.campaign?.id ?? campaignId} → ${d.campaign?.name ?? name}\n`));
+      } catch (e) { fail(e); }
+    });
+
+
+
+  withCommonOpts(c.command("add-leads <campaignId>"))
+    .description("Attach leads to a campaign")
+    .option("--lead-ids <csv>", "comma-separated lead UUIDs")
+    .option("--file <path>", "file with one lead id per line")
+    .action(async function (campaignId, opts) {
+      try {
+        let ids = [];
+        if (opts.leadIds) ids = opts.leadIds.split(",").map((s) => s.trim()).filter(Boolean);
+        if (opts.file) {
+          const text = await readFile(opts.file, "utf8");
+          ids.push(...text.split(/\r?\n/).map((s) => s.trim()).filter(Boolean));
+        }
+        if (!ids.length) return fail(new Error("--lead-ids or --file required"));
+        const r = await call("campaigns", "add_leads", { campaign_id: campaignId, lead_ids: ids }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Added ${d.added}/${d.requested} leads (${d.valid} valid in workspace)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("remove-leads <campaignId>"))
+    .description("Un-enrol leads from a campaign")
+    .option("--lead-ids <ids>", "comma-separated lead ids")
+    .option("--all", "remove every enrolled lead")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .option("--dry-run", "show what would be removed")
+    .action(async function (campaignId, opts) {
+      try {
+        const ids = opts.leadIds ? opts.leadIds.split(",").map((s) => s.trim()).filter(Boolean) : [];
+        if (!ids.length && !opts.all) return fail(new Error("--lead-ids or --all required"));
+        const params = { campaign_id: campaignId, lead_ids: ids, all: !!opts.all };
+        if (opts.dryRun) {
+          const d = await call("campaigns", "remove_leads", { ...params, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) => process.stdout.write(`Would remove ${x.would_remove} lead(s) from ${campaignId}\n`));
+        }
+        await confirmDestructive(this, `Remove ${opts.all ? "ALL enrolled leads" : `${ids.length} lead(s)`} from campaign ${campaignId}.`);
+        const r = await call("campaigns", "remove_leads", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Removed ${d.removed} lead(s)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("preflight <id>"))
+    .description("Check whether a campaign is safe to launch (read-only)")
+    .action(async function (id) {
+      try {
+        const r = await call("campaigns", "preflight", { campaign_id: id }, ctxFrom(this));
+        emit(this, r, renderPreflight);
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("launch <id>"))
+    .description("Activate a campaign — runs preflight first, then requires --confirm")
+    .option("--confirm", "actually launch (without it, this is a dry run)")
+    .option("--force", "launch even if preflight found blockers")
+    .action(async function (id, opts) {
+      try {
+        if (!opts.confirm) {
+          const d = await call("campaigns", "launch", { campaign_id: id, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) => {
+            renderPreflight(x.preflight ?? x);
+            process.stdout.write(
+              x.preflight?.ok
+                ? `\nDry run only. Re-run with --confirm to launch.\n`
+                : `\nDry run only. Fix the blockers above, then re-run with --confirm.\n`,
+            );
+          });
+        }
+        const r = await call(
+          "campaigns", "launch", { campaign_id: id, force: !!opts.force }, ctxFrom(this),
+        );
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → ${d.campaign?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("pause <id>"))
+    .description("Pause a campaign")
+    .action(async function (id) {
+      try {
+        const r = await call("campaigns", "pause", { campaign_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → ${d.campaign?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("resume <id>"))
+    .description("Resume a paused campaign")
+    .option("--confirm", "required — resuming restarts sending")
+    .option("--force", "resume even if preflight found blockers")
+    .action(async function (id, opts) {
+      try {
+        if (!opts.confirm) {
+          const d = await call("campaigns", "resume", { campaign_id: id, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) => {
+            renderPreflight(x.preflight ?? x);
+            process.stdout.write(`\nDry run only. Re-run with --confirm to resume.\n`);
+          });
+        }
+        const r = await call("campaigns", "resume", { campaign_id: id, force: !!opts.force }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → ${d.campaign?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("archive <id>"))
+    .description("Archive a campaign (reversible, keeps history)")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Archive campaign ${id}. It will stop sending.`);
+        const r = await call("campaigns", "archive", { campaign_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → archived\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("clone <id>"))
+    .description("Duplicate a campaign as a fresh draft (no leads, no history)")
+    .option("--name <name>", "name for the copy")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("campaigns", "clone", { campaign_id: id, name: opts.name }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Cloned to ${d.campaign?.id} — ${d.campaign?.name}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("delete <id>"))
+    .description("Permanently delete a campaign and its enrolments")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .option("--dry-run", "show what would be deleted")
+    .option("--force", "delete even when the campaign has dispatch history")
+    .action(async function (id, opts) {
+      try {
+        if (opts.dryRun) {
+          const d = await call("campaigns", "delete", { campaign_id: id, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) =>
+            process.stdout.write(
+              `Would delete campaign ${x.campaign?.name ?? id} (${x.dispatches} dispatched actions)\n`,
+            ));
+        }
+        await confirmDestructive(
+          this,
+          `Permanently delete campaign ${id} and every lead enrolment on it. This cannot be undone.`,
+          { expect: id.slice(0, 8) },
+        );
+        const r = await call(
+          "campaigns", "delete", { campaign_id: id, force: !!opts.force }, ctxFrom(this),
+        );
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.name ?? id}\n`));
+      } catch (e) { fail(e); }
+    });
+}
+
+function renderPreflight(p) {
+  if (!p) return;
+  process.stdout.write(
+    `${p.ok ? "✓ Ready to launch" : "✖ Not ready"} — ${p.name ?? p.campaign_id} (${p.status})\n`,
+  );
+  const c = p.checks ?? {};
+  process.stdout.write(
+    `  leads: ${c.leads_enrolled}   steps: ${c.sequence_steps}   senders: ${c.sender_accounts}   daily limit: ${c.daily_send_limit ?? "—"}\n`,
+  );
+  for (const b of p.blockers ?? []) process.stdout.write(`  ✖ ${b}\n`);
+  for (const w of p.warnings ?? []) process.stdout.write(`  ! ${w}\n`);
+}
+
+
+
+function delayLabel(s) {
+  const unit = s?.config?.delay_unit || "days";
+  const n = s?.delay_days ?? 0;
+  return unit === "hours" ? `${n}h` : unit === "minutes" ? `${n}m` : `${n}d`;
+}
+
+export function registerSequences(program) {
+  const s = program.command("sequences").description("Manage LinkedIn sequences");
+
+  withCommonOpts(s.command("list"))
+    .description("List sequences")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("sequences", "list", { limit: Number(o.limit) }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "name", "status"],
+            (d.sequences || []).map((s) => [s.id, truncate(s.name, 40), s.status]),
+          ) + `\n${d.sequences?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("show <id>"))
+    .description("Show sequence + steps")
+    .action(async function (id) {
+      try {
+        const r = await call("sequences", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(`Sequence: ${d.sequence?.name} (${d.sequence?.status})\n\n`);
+          process.stdout.write(table(
+            ["#", "action", "channel", "delay", "variant", "preview"],
+            (d.steps || []).map((s) => [
+              s.step_order, s.action, s.channel, delayLabel(s), s.variant,
+              truncate(s.message_content, 60),
+            ]),
+          ) + "\n");
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("create"))
+    .description("Create a new (empty, draft) sequence")
+    .requiredOption("--name <name>", "sequence name")
+    .option("--description <text>", "description")
+    .option("--trigger <type>", "trigger_type", "manual")
+    .option("--stage <stage>", "launch_stage (liberate|architect|uncover|navigate|catalyse|harness|review|graduation)")
+    .action(async function (opts) {
+      try {
+        const r = await call("sequences", "create", {
+          name: opts.name,
+          description: opts.description,
+          trigger_type: opts.trigger,
+          launch_stage: opts.stage,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(`✓ Created sequence ${d.sequence?.id}\n  name: ${d.sequence?.name}\n  status: ${d.sequence?.status}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("update <id>"))
+    .description("Update sequence metadata (name/description/status/stage)")
+    .option("--name <name>", "rename")
+    .option("--description <text>", "set description (pass empty string to clear)")
+    .option("--status <s>", "draft|active|paused|archived")
+    .option("--stage <stage>", "launch_stage (pass '' to clear)")
+    .action(async function (id, opts) {
+      try {
+        const params = { id };
+        if (opts.name != null) params.name = opts.name;
+        if (opts.description != null) params.description = opts.description || null;
+        if (opts.status != null) params.status = opts.status;
+        if (opts.stage != null) params.launch_stage = opts.stage || null;
+        const r = await call("sequences", "update", params, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(`✓ Updated ${d.sequence?.id}\n  name: ${d.sequence?.name}\n  status: ${d.sequence?.status}\n  stage: ${d.sequence?.launch_stage || "—"}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("add-step <id>"))
+    .description("Append a step to a sequence")
+    .requiredOption(
+      "--action <action>",
+      "viewProfile|addReaction|sendInvitation|sendMessage|loopBack|createOpportunity|enrichLead|ifAccepted|ifReplied|ifConnection|ifNetworkDistance|stopOnReply|wait|wait_3h|wait_1d|wait_2d|wait_3d|wait_5d",
+    )
+    .option("--text <message>", "message_content (required for sendInvitation/sendMessage)")
+    .option("--delay <days>", "delay_days before this step", "0")
+    .option("--delay-hours <hours>", "wait this many hours instead of days")
+    .option("--delay-minutes <minutes>", "wait this many minutes instead of days")
+    .option("--variant <v>", "variant label", "A")
+    .option("--step-type <t>", "action|condition|delay (defaults from --action)")
+    .option("--channel <c>", "channel (defaults from --action)")
+    .option("--branch <label>", "branch_label: yes|no|first|second_or_third|follower|out_of_network (children of a condition)")
+    .option("--parent-step <id>", "parent_step_id (defaults to the tail of the sequence)")
+    .option("--root", "start a new root step instead of appending to the tail (rarely correct)")
+
+    .option("--order <n>", "explicit step_order (defaults to max+1)")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("sequences", "add_step", {
+          sequence_id: id,
+          action: opts.action,
+          message_content: opts.text,
+          delay_days: Number(opts.delay) || 0,
+          delay_hours: opts.delayHours !== undefined ? Number(opts.delayHours) : undefined,
+          delay_minutes: opts.delayMinutes !== undefined ? Number(opts.delayMinutes) : undefined,
+          variant: opts.variant,
+          step_type: opts.stepType,
+          channel: opts.channel,
+          branch_label: opts.branch,
+          parent_step_id: opts.parentStep,
+          root: opts.root === true,
+          step_order: opts.order ? Number(opts.order) : undefined,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const st = d.step || {};
+          process.stdout.write(`✓ Added step ${st.id}\n  #${st.step_order} ${st.action} (${st.channel}) delay=${delayLabel(st)} variant=${st.variant}\n  parent=${st.parent_step_id || "root"}${st.branch_label ? ` branch=${st.branch_label}` : ""}\n`);
+          for (const w of d.graph?.warnings || []) process.stdout.write(`  ⚠ ${w.message}\n`);
+        });
+      } catch (e) { fail(e); }
+
+    });
+
+  withCommonOpts(s.command("replace-steps <id>"))
+    .description("Replace every step of a sequence with a validated tree from a JSON file (atomic)")
+    .requiredOption("--file <path>", "JSON file: [{ temp_id, parent, branch_label, action, message_content, delay_days | delay_hours | delay_minutes }] (a flat ordered list is treated as a chain)")
+    .option("--dry-run", "validate the graph without writing")
+    .action(async function (id, opts) {
+      try {
+        const raw = await readFile(opts.file, "utf8");
+        const parsed = JSON.parse(raw);
+        const steps = Array.isArray(parsed) ? parsed : parsed.steps;
+        if (!Array.isArray(steps)) throw new Error("file must contain an array of steps or { steps: [...] }");
+        const r = await call("sequences", "replace_steps", {
+          sequence_id: id,
+          steps,
+          dry_run: opts.dryRun === true,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          if (d.dry_run) {
+            process.stdout.write(`✓ Graph valid — ${d.planned_steps} step(s), nothing written\n`);
+            return;
+          }
+          process.stdout.write(`✓ Replaced steps on ${d.sequence_id} — ${d.replaced_steps} step(s)\n`);
+          for (const st of d.steps || []) {
+            process.stdout.write(`  #${st.step_order} ${st.action}${st.branch_label ? ` [${st.branch_label}]` : ""} parent=${st.parent_step_id || "root"}\n`);
+          }
+          for (const w of d.graph?.warnings || []) process.stdout.write(`  ⚠ ${w.message}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+
+
+  withCommonOpts(s.command("clone <id>"))
+    .description("Duplicate a sequence (and all its steps) as a new draft")
+    .option("--name <name>", "name for the clone (default: '<src> (copy)')")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("sequences", "clone", { id, name: opts.name }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(`✓ Cloned to ${d.sequence?.id}\n  name: ${d.sequence?.name}\n  copied steps: ${d.cloned_steps}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("validate <id>"))
+    .description("Run safety + char-limit validation on a sequence (same checks as 'campaigns launch')")
+    .action(async function (id) {
+      try {
+        const r = await call("sequences", "validate", { id }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const status = d.ok ? "✓ PASS" : "✖ FAIL";
+          process.stdout.write(`${status} — ${d.step_count} step(s), ${d.errors.length} error(s), ${d.warnings.length} warning(s)\n`);
+          for (const e of d.errors) {
+            process.stdout.write(`  ERROR  #${e.step_order ?? "?"} ${e.action ?? ""} ${e.kind}` +
+              (e.field ? ` [${e.field}]` : "") +
+              (e.length != null ? ` ${e.length}/${e.limit} chars (+${e.excess})` : "") + "\n");
+          }
+          for (const w of d.warnings) {
+            process.stdout.write(`  WARN   #${w.step_order} ${w.action} ${w.kind}` +
+              (w.field ? ` [${w.field}]` : "") +
+              ` ${w.length}/${w.limit} chars (+${w.excess})\n`);
+          }
+          if (!d.ok) process.exitCode = 1;
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("update-step <stepId>"))
+    .description("Patch one step in place (message, delay, variant, channel, action)")
+    .option("--action <action>", "step action")
+    .option("--message <text>", "message_content")
+    .option("--delay <days>", "delay_days")
+    .option("--delay-hours <hours>", "wait this many hours instead of days")
+    .option("--delay-minutes <minutes>", "wait this many minutes instead of days")
+    .option("--variant <v>", "variant")
+    .option("--channel <c>", "channel")
+    .action(async function (stepId, opts) {
+      try {
+        const params = { step_id: stepId };
+        if (opts.action !== undefined) params.action = opts.action;
+        if (opts.message !== undefined) params.message_content = opts.message;
+        if (opts.delay !== undefined) params.delay_days = Number(opts.delay);
+        if (opts.delayHours !== undefined) params.delay_hours = Number(opts.delayHours);
+        if (opts.delayMinutes !== undefined) params.delay_minutes = Number(opts.delayMinutes);
+        if (opts.variant !== undefined) params.variant = opts.variant;
+        if (opts.channel !== undefined) params.channel = opts.channel;
+        const r = await call("sequences", "update_step", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated step ${d.step?.id ?? stepId} (${d.step?.action})\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("delete-step <stepId>"))
+    .description("Delete one step; its children are re-parented")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .option("--dry-run", "show what would change")
+    .action(async function (stepId, opts) {
+      try {
+        if (opts.dryRun) {
+          const d = await call("sequences", "delete_step", { step_id: stepId, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) =>
+            process.stdout.write(`Would delete step ${stepId}; ${x.reparented_children} child step(s) re-parented\n`));
+        }
+        await confirmDestructive(this, `Delete sequence step ${stepId}. Child steps will be re-parented.`);
+        const r = await call("sequences", "delete_step", { step_id: stepId }, ctxFrom(this));
+        emit(this, r, (d) =>
+          process.stdout.write(`✓ Deleted step ${stepId} (${d.reparented_children} child step(s) re-parented)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("delete <id>"))
+    .description("Delete a sequence and all its steps")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .option("--dry-run", "show what would be deleted")
+    .option("--force", "delete even if campaigns still use it (they are detached)")
+    .action(async function (id, opts) {
+      try {
+        if (opts.dryRun) {
+          const d = await call("sequences", "delete", { id, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) =>
+            process.stdout.write(
+              `Would delete sequence ${x.sequence?.name ?? id}; used by ${x.used_by_campaigns?.length ?? 0} campaign(s)\n`,
+            ));
+        }
+        await confirmDestructive(this, `Delete sequence ${id} and every step on it. This cannot be undone.`);
+        const r = await call("sequences", "delete", { id, force: !!opts.force }, ctxFrom(this));
+        emit(this, r, (d) =>
+          process.stdout.write(`✓ Deleted sequence ${d.sequence_id} (${d.detached_campaigns} campaign(s) detached)\n`));
+      } catch (e) { fail(e); }
+    });
+}
+
+
+function parseSnoozeDuration(s) {
+  // Accepts e.g. "30m", "2h", "1d", "45" (minutes). Returns minutes (int).
+  if (!s) return null;
+  const m = String(s).trim().match(/^(\d+)\s*([mhd]?)$/i);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = (m[2] || "m").toLowerCase();
+  const mult = unit === "h" ? 60 : unit === "d" ? 60 * 24 : 1;
+  return n * mult;
+}
+
+export function registerInbox(program) {
+  const inbox = program.command("inbox").description("Inspect and act on the unified inbox");
+
+  withCommonOpts(inbox.command("threads"))
+    .description("List recent inbox messages")
+    .option("--campaign <id>", "filter by campaign_id")
+    .option("--lead <id>", "filter by lead_id")
+    .option("--needs-attention", "only messages flagged as needing attention")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("inbox", "list_threads", {
+          campaign_id: o.campaign, lead_id: o.lead,
+          needs_attention: o.needsAttention || undefined,
+          limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["created", "dir", "campaign", "body"],
+            (d.messages || []).map((m) => [
+              (m.created_at || "").slice(0, 16).replace("T", " "),
+              m.direction === "outbound" ? "→" : "←",
+              truncate(m.campaign_name || m.campaign_id, 20),
+              truncate((m.body || "").replace(/\s+/g, " "), 80),
+            ]),
+          ) + `\n${d.messages?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  const sendAction = async function (leadId, opts) {
+    try {
+      const text = String(opts.text || "").trim();
+      if (!text) { fail(new Error("--text cannot be empty")); return; }
+      if (text.length > 7900) {
+        fail(new Error(`--text is ${text.length} chars; hard cap is 7900`));
+        return;
+      }
+      if (!opts.confirm && !opts.yes) {
+        process.stderr.write(
+          `Refusing to send — re-run with --confirm to actually dispatch.\n` +
+          `  lead:   ${leadId}\n` +
+          `  sender: ${opts.sender || "(auto)"}\n` +
+          `  chars:  ${text.length}\n` +
+          `  text:   ${truncate(text.replace(/\s+/g, " "), 120)}\n`,
+        );
+        process.exit(2);
+      }
+      const r = await call("inbox", "send_dm", {
+        lead_id: leadId,
+        text,
+        sender_account_id: opts.sender,
+      }, ctxFrom(this));
+      emit(this, r, (d) => {
+        const s = d.sent || {};
+        const b = s.budget || {};
+        process.stdout.write(
+          `✓ ${s.channel_kind === "linkedin_invite" ? "Invite note" : "DM"} sent to ${s.lead_name || leadId}\n` +
+          `  sender:   ${s.sender_account_id}\n` +
+          `  chars:    ${s.chars}\n` +
+          `  budget:   invites ${b.invites_sent}/${b.invites_cap}, messages ${b.messages_sent}/${b.messages_cap}\n` +
+          (s.external_id ? `  msg id:   ${s.external_id}\n` : ""),
+        );
+      });
+    } catch (e) { fail(e); }
+  };
+
+  withCommonOpts(inbox.command("send <leadId>"))
+    .description("Send a one-off LinkedIn DM (or first-touch invite note) to a lead")
+    .requiredOption("--text <message>", "message body (auto-truncated to channel limit)")
+    .option("--sender <accountId>", "sender_account_id (defaults to most-recently-updated linkedin_tool sender)")
+    .option("--confirm", "actually dispatch (otherwise prints a dry-run preview and exits)")
+    .action(sendAction);
+
+  // `reply` is a semantic alias for `send` — the server auto-resolves the most
+  // recent LinkedIn thread for (lead, sender) and routes via sendMessage.
+  withCommonOpts(inbox.command("reply <leadId>"))
+    .description("Reply on the most recent LinkedIn thread for a lead (alias of `send`; falls back to invite note if no thread)")
+    .requiredOption("--text <message>", "reply body (auto-truncated to channel limit)")
+    .option("--sender <accountId>", "sender_account_id (defaults to most-recently-updated linkedin_tool sender)")
+    .option("--confirm", "actually dispatch (otherwise prints a dry-run preview and exits)")
+    .action(sendAction);
+
+  withCommonOpts(inbox.command("mark-read <messageIds...>"))
+    .description("Mark one or more inbox messages as read")
+    .action(async function (messageIds) {
+      try {
+        if (!messageIds?.length) { fail(new Error("At least one messageId required")); return; }
+        const r = await call("inbox", "mark_read", { message_ids: messageIds }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(`✓ Marked ${d.marked_read}/${d.requested} message(s) read\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(inbox.command("snooze <messageId>"))
+    .description("Snooze a message until a future time")
+    .option("--for <duration>", "duration like 30m, 2h, 1d (default unit: minutes)")
+    .option("--until <iso>", "explicit ISO datetime (e.g. 2026-05-27T09:00:00Z)")
+    .option("--clear", "clear an existing snooze on this message")
+    .action(async function (messageId, opts) {
+      try {
+        const params = { message_id: messageId };
+        if (opts.clear) {
+          params.clear = true;
+        } else if (opts.until) {
+          params.until = opts.until;
+        } else if (opts.for) {
+          const mins = parseSnoozeDuration(opts.for);
+          if (mins == null) { fail(new Error("Invalid --for value; use e.g. 30m, 2h, 1d")); return; }
+          params.minutes = mins;
+        } else {
+          fail(new Error("Provide --for <duration>, --until <iso>, or --clear"));
+          return;
+        }
+        const r = await call("inbox", "snooze", params, ctxFrom(this));
+        emit(this, r, (d) => {
+          if (opts.clear) process.stdout.write(`✓ Snooze cleared on ${d.snoozed?.id}\n`);
+          else process.stdout.write(`✓ Snoozed ${d.snoozed?.id} until ${d.snoozed?.snoozed_until}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerKnowledge(program) {
+  const k = program.command("knowledge").description("Manage the workspace knowledge base");
+
+  withCommonOpts(k.command("list"))
+    .description("List active knowledge items")
+    .option("--category <c>", "filter by category (positioning, frameworks, case-studies, …)")
+    .option("--search <q>", "search name or summary")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("knowledge", "list", {
+          category: o.category, search: o.search, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "type", "category", "name", "tags"],
+            (d.items || []).map((i) => [
+              truncate(i.id, 8), i.type, i.category,
+              truncate(i.name, 40),
+              truncate((i.tags || []).join(","), 30),
+            ]),
+          ) + `\n${d.items?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(k.command("get <id>"))
+    .description("Show a knowledge item (full JSON, including extracted_text)")
+    .action(async function (id) {
+      try {
+        const r = await call("knowledge", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.item, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  // `add` mirrors the web UI flow: insert → (URL: firecrawl-scrape) → AI auto-tag.
+  // Choose exactly one source: --url, --text, or --file.
+  withCommonOpts(k.command("add"))
+    .description("Add a knowledge item (URL is auto-scraped + AI-classified, same as the web UI)")
+    .option("--url <url>", "scrape this URL via Firecrawl")
+    .option("--text <body>", "inline text body")
+    .option("--file <path>", "read body from a local text/markdown file")
+    .option("--name <title>", "display title (defaults to URL hostname or filename)")
+    .option("--category <c>", "seed category (AI may re-classify)")
+    .option("--tags <csv>", "seed tags, comma-separated (AI merges with classifier tags)")
+    .option("--visibility <v>", "workspace | private (default: workspace)")
+    .option("--no-summarize", "skip AI auto-tag/classify (raw insert only)")
+    .option("--no-scrape", "skip Firecrawl scrape for --url (URL stored as bookmark)")
+    .option("--style-reference", "flag as a Tone-of-Voice style reference (for known author documents)")
+    .option("--auto-style", "score as a style reference on arrival and auto-flag if it meets the threshold (default 70)")
+    .action(async function (opts) {
+      try {
+        const sources = [opts.url, opts.text, opts.file].filter(Boolean);
+        if (sources.length !== 1) {
+          return fail(new Error("Provide exactly one of --url, --text, or --file"));
+        }
+        let extracted_text;
+        let derivedName = opts.name;
+        if (opts.file) {
+          extracted_text = await readFile(opts.file, "utf8");
+          if (!derivedName) derivedName = opts.file.split(/[\\/]/).pop();
+        } else if (opts.text) {
+          extracted_text = opts.text;
+        }
+        const params = {
+          content_url: opts.url || undefined,
+          extracted_text,
+          name: derivedName,
+          category: opts.category,
+          tags: opts.tags ? opts.tags.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
+          visibility: opts.visibility,
+          skip_summarize: opts.summarize === false ? true : undefined,
+          skip_scrape: opts.scrape === false ? true : undefined,
+          is_style_reference: opts.styleReference === true ? true : undefined,
+          auto_style_reference: opts.autoStyle === true ? true : undefined,
+        };
+        const r = await call("knowledge", "add", params, ctxFrom(this));
+        emit(this, r, (d) => {
+          const it = d.item || {};
+          process.stdout.write(
+            `✓ Added knowledge item ${it.id}\n` +
+            `  name:     ${it.name}\n` +
+            `  type:     ${it.type}\n` +
+            `  category: ${it.category}\n` +
+            `  tags:     ${(it.tags || []).join(", ") || "(none)"}\n` +
+            (it.summary ? `  summary:  ${truncate(it.summary, 240)}\n` : "") +
+            (it.is_style_reference ? `  ★ style reference\n` : "") +
+            (d.ai?.success === false ? `  ⚠ AI classify: ${d.ai.error}\n` : "") +
+            (d.style_reference_triage?.data?.results?.[0] && !it.is_style_reference
+              ? `  style triage: ${d.style_reference_triage.data.results[0].score}/100 — ${d.style_reference_triage.data.results[0].reason}\n`
+              : ""),
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(k.command("update <id>"))
+    .description("Patch a knowledge item")
+    .option("--name <s>", "rename")
+    .option("--summary <s>", "set summary")
+    .option("--category <c>", "set category")
+    .option("--tags <csv>", "replace tags (comma-separated)")
+    .option("--visibility <v>", "workspace | private")
+    .option("--style-reference <on|off>", "flag/unflag as a Tone-of-Voice style reference")
+    .action(async function (id, opts) {
+      try {
+        const patch = {
+          id,
+          name: opts.name,
+          summary: opts.summary,
+          category: opts.category,
+          tags: opts.tags ? opts.tags.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
+          visibility: opts.visibility,
+          is_style_reference: opts.styleReference === "on" ? true : opts.styleReference === "off" ? false : undefined,
+        };
+        const r = await call("knowledge", "update", patch, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.item?.id}\n`));
+      } 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) {
+      try {
+        const r = await call("knowledge", "reclassify", { id }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const it = d.item || {};
+          process.stdout.write(
+            `✓ Reclassified ${it.id}\n` +
+            `  category: ${it.category}\n` +
+            `  tags:     ${(it.tags || []).join(", ") || "(none)"}\n` +
+            (it.summary ? `  summary:  ${truncate(it.summary, 240)}\n` : ""),
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(k.command("deactivate <id>"))
+    .description("Soft-delete (sets is_active = false)")
+    .action(async function (id) {
+      try {
+        const r = await call("knowledge", "deactivate", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deactivated ${d.item?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerContent(program) {
+  const c = program.command("content").description("Browse, create, schedule and publish content");
+
+  withCommonOpts(c.command("list"))
+    .description("List content items")
+    .option("--status <s>", "filter by status (draft|scheduled|published|…)")
+    .option("--type <t>", "filter by type (article|linkedin_post|…)")
+    .option("--approval <s>", "filter by approval_status")
+    .option("--search <q>", "search title or body")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("content", "list", {
+          status: o.status, type: o.type, approval_status: o.approval,
+          search: o.search, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "type", "status", "title"],
+            (d.content || []).map((c) => [truncate(c.id, 8), c.type, c.status, truncate(c.title, 60)]),
+          ) + `\n${d.content?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("show <id>"))
+    .description("Show a content item")
+    .action(async function (id) {
+      try {
+        const r = await call("content", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.content, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("create"))
+    .description("Create a new content item")
+    .requiredOption("--title <t>", "title")
+    .option("--type <t>", "article | linkedin_post | newsletter | …", "linkedin_post")
+    .option("--body <text>", "inline body")
+    .option("--body-file <path>", "read body from a local file")
+    .option("--platforms <csv>", "target platforms (linkedin,blog,…)")
+    .option("--tags <csv>", "tags")
+    .option("--scheduled <ts>", "ISO timestamp (sets status=scheduled)")
+    .option("--campaign <id>", "campaign_id")
+    .action(async function (opts) {
+      try {
+        let body = opts.body;
+        if (opts.bodyFile) body = await readFile(opts.bodyFile, "utf8");
+        const r = await call("content", "create", {
+          title: opts.title, type: opts.type, body: body ?? "",
+          target_platforms: opts.platforms ? opts.platforms.split(",").map((s) => s.trim()) : undefined,
+          tags: opts.tags ? opts.tags.split(",").map((s) => s.trim()) : undefined,
+          scheduled_date: opts.scheduled, status: opts.scheduled ? "scheduled" : undefined,
+          campaign_id: opts.campaign,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Created content ${d.content?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("update <id>"))
+    .description("Patch a content item")
+    .option("--title <t>")
+    .option("--body <text>")
+    .option("--body-file <path>")
+    .option("--status <s>")
+    .option("--platforms <csv>")
+    .option("--tags <csv>")
+    .option("--scheduled <ts>")
+    .action(async function (id, opts) {
+      try {
+        let body = opts.body;
+        if (opts.bodyFile) body = await readFile(opts.bodyFile, "utf8");
+        const r = await call("content", "update", {
+          id, title: opts.title, body, status: opts.status,
+          target_platforms: opts.platforms ? opts.platforms.split(",").map((s) => s.trim()) : undefined,
+          tags: opts.tags ? opts.tags.split(",").map((s) => s.trim()) : undefined,
+          scheduled_date: opts.scheduled,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.content?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("schedule <id> <isoTimestamp>"))
+    .description("Schedule a content item (Taplio when connected, otherwise built-in cron)")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .option("--publish-as <p>", "personal | company")
+    .option("--company-page <id>", "company page id when publishing as company")
+    .option("--timezone <tz>", "IANA timezone label to store")
+    .action(async function (id, ts, opts) {
+      try {
+        const r = await call("content", "schedule", {
+          id, scheduled_for: ts, channel: opts.channel,
+          publish_as: opts.publishAs, company_page_id: opts.companyPage, timezone: opts.timezone,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Scheduled via ${d.engine} for ${d.scheduled_for}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("unschedule <id>"))
+    .description("Cancel a scheduled content item on whichever engine holds it")
+    .action(async function (id) {
+      try {
+        const r = await call("content", "unschedule", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Unscheduled ${d.unscheduled ?? id}${d.engine ? ` (${d.engine})` : ""}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("approve <id>"))
+    .description("Approve a content item (approval_status=approved)")
+    .action(async function (id) {
+      try {
+        const r = await call("content", "approve", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Approved ${d.content?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("bulk-approve [ids...]"))
+    .description("Approve many content items (all pending when no ids given)")
+    .option("--campaign <id>", "only pending items in this campaign")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (ids, opts) {
+      try {
+        if (!ids?.length) await confirmDestructive(this, "Approve every pending content item in this workspace.");
+        const r = await call("content", "bulk_approve", {
+          ids: ids?.length ? ids : undefined, campaign_id: opts.campaign,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Approved ${d.approved} items\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("bulk-schedule <ids...>"))
+    .description("Schedule several content items on a cadence via the live engine")
+    .option("--start <iso>", "first slot (default: in 1 hour)")
+    .option("--interval-hours <n>", "hours between posts", "24")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .option("--publish-as <p>", "personal | company")
+    .action(async function (ids, opts) {
+      try {
+        const r = await call("content", "bulk_schedule", {
+          ids, start: opts.start, interval_hours: Number(opts.intervalHours),
+          channel: opts.channel, publish_as: opts.publishAs,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "ok", "engine", "when / error"],
+            (d.results || []).map((x) => [truncate(x.id, 8), x.ok ? "yes" : "no", x.engine ?? "—", x.scheduled_for ?? truncate(x.error ?? "", 50)]),
+          ) + `\n${d.scheduled} scheduled, ${d.failed} failed\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("publish <id>"))
+    .description("Publish a content item immediately")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .option("--publish-as <p>", "personal | company")
+    .option("--company-page <id>", "company page id when publishing as company")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id, opts) {
+      try {
+        await confirmDestructive(this, `Publish content item ${id} right now.`);
+        const r = await call("content", "publish_now", {
+          id, channel: opts.channel, publish_as: opts.publishAs, company_page_id: opts.companyPage,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Published via ${d.worker}\n`));
+      } catch (e) { fail(e); }
+    });
+
+
+  withCommonOpts(c.command("delete <id>"))
+    .description("Delete a content item")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete content item ${id}. This cannot be undone.`);
+        const r = await call("content", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("generate"))
+    .description("Generate a draft via agent-content-creator (KB + reference library grounded, URL-sanitised, citations recorded)")
+    .requiredOption("--angle <text>", "topic / angle for the draft")
+    .option("--format <f>", "blog | linkedin_post | video | explainer_video", "blog")
+    .option("--signal <id...>", "intelligence_signals ids to ground on (repeatable)")
+    .option("--reference <id...>", "knowledge_items ids to ground on (repeatable)")
+    .option("--grounding-text <text>", "extra freeform grounding to append")
+    .option("--wait", "poll until the job finishes (up to 10 min)")
+    .option("--timeout <seconds>", "how long --wait polls before giving up", "600")
+    .action(async function (opts) {
+      try {
+        // Always dispatch asynchronously and poll the returned job id. Holding
+        // one long HTTP request open was what produced spurious timeouts, and
+        // polling by the id the server handed back is what keeps --wait from
+        // ever reporting job_not_found for a job that exists.
+        const ctx = ctxFrom(this);
+        const r = await call("content", "generate", {
+          angle: opts.angle,
+          format: opts.format,
+          signal_ids: opts.signal,
+          reference_item_ids: opts.reference,
+          grounding_text: opts.groundingText,
+          async: true,
+        }, ctx);
+        const jobId = r?.job_id || r?.job?.id || null;
+        if (!opts.wait || !jobId) {
+          emit(this, r, (d) => {
+            if (d.content) process.stdout.write(`✓ Draft ${d.content.id} (${d.content.type}, ${d.citations?.length ?? 0} citations)\n`);
+            else process.stdout.write(`⏳ Queued job ${d.job_id} — poll with: advisoros agents job-status ${d.job_id}\n`);
+          });
+          return;
+        }
+        const deadline = Date.now() + Number(opts.timeout || 600) * 1000;
+        let last = null;
+        while (Date.now() < deadline) {
+          await new Promise((res) => setTimeout(res, 5000));
+          let st;
+          try {
+            st = await call("agents", "job_status", { job_id: jobId }, ctx);
+          } catch (e) {
+            // A transient lookup failure must never end the wait — the job id
+            // came from the server, so keep polling until the deadline.
+            continue;
+          }
+          last = st?.job || st;
+          const status = last?.status;
+          if (status === "completed" || status === "succeeded" || status === "failed") break;
+        }
+        emit(this, { job_id: jobId, job: last }, (d) => {
+          const st = d.job?.status || "unknown";
+          const ids = d.job?.result?.content_ids || [];
+          process.stdout.write(st === "completed" || st === "succeeded"
+            ? `✓ Job ${d.job_id} ${st}${ids.length ? ` — draft ${ids[0]}` : ""}\n`
+            : `⏳ Job ${d.job_id} is ${st} — check with: advisoros agents job-status ${d.job_id}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("citations <id>"))
+    .description("List every source (signal, reference, transcript, published) recorded for a content item")
+    .action(async function (id) {
+      try {
+        const r = await call("content", "citations", { id }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["kind", "id", "title", "url"],
+            (d.citations || []).map((c) => [c.source_kind, truncate(c.source_id ?? "", 8), truncate(c.title ?? "", 40), truncate(c.source_url ?? "", 60)]),
+          ) + `\n${d.citations?.length ?? 0} citations\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+}
+
+
+export function registerCalendar(program) {
+  const cal = program.command("calendar").description("Manage the content calendar");
+
+  withCommonOpts(cal.command("list"))
+    .description("List scheduled calendar posts")
+    .option("--from <date>", "YYYY-MM-DD (inclusive)")
+    .option("--to <date>", "YYYY-MM-DD (inclusive)")
+    .option("--platform <p>", "filter by platform")
+    .option("--status <s>", "filter by status")
+    .option("--campaign <id>", "filter by campaign_id")
+    .option("--limit <n>", "max rows", "100")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("calendar", "list", {
+          from: o.from, to: o.to, platform: o.platform, status: o.status,
+          campaign_id: o.campaign, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "date", "time", "platform", "status", "title"],
+            (d.posts || []).map((p) => [
+              truncate(p.id, 8), p.scheduled_date, p.scheduled_time ?? "—",
+              p.platform, p.status, truncate(p.title, 50),
+            ]),
+          ) + `\n${d.posts?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("show <id>"))
+    .description("Show a calendar post")
+    .action(async function (id) {
+      try {
+        const r = await call("calendar", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.post, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("create"))
+    .description("Create a calendar post")
+    .requiredOption("--title <t>", "title")
+    .requiredOption("--date <YYYY-MM-DD>", "scheduled date")
+    .option("--time <HH:MM>", "scheduled time")
+    .option("--platform <p>", "linkedin | blog | twitter | …", "linkedin")
+    .option("--content <text>", "post body")
+    .option("--content-file <path>", "read body from a local file")
+    .option("--hashtags <csv>", "hashtags (no #)")
+    .option("--cta <text>", "call to action")
+    .option("--campaign <id>", "campaign_id")
+    .option("--status <s>", "draft | scheduled | published", "draft")
+    .option("--at <iso>", "ISO timestamp — schedules the post immediately via the live engine")
+    .action(async function (opts) {
+      try {
+        let content = opts.content;
+        if (opts.contentFile) content = await readFile(opts.contentFile, "utf8");
+        const r = await call("calendar", "create", {
+          scheduled_for: opts.at,
+          title: opts.title, scheduled_date: opts.date, scheduled_time: opts.time,
+          platform: opts.platform, content: content ?? "",
+          hashtags: opts.hashtags ? opts.hashtags.split(",").map((s) => s.trim()) : undefined,
+          cta: opts.cta, campaign_id: opts.campaign, status: opts.status,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Created calendar post ${d.post?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("update <id>"))
+    .description("Patch a calendar post")
+    .option("--title <t>")
+    .option("--date <YYYY-MM-DD>")
+    .option("--time <HH:MM>")
+    .option("--content <text>")
+    .option("--content-file <path>")
+    .option("--status <s>")
+    .option("--platform <p>")
+    .option("--hashtags <csv>")
+    .option("--cta <text>")
+    .action(async function (id, opts) {
+      try {
+        let content = opts.content;
+        if (opts.contentFile) content = await readFile(opts.contentFile, "utf8");
+        const r = await call("calendar", "update", {
+          id, title: opts.title, scheduled_date: opts.date, scheduled_time: opts.time,
+          content, status: opts.status, platform: opts.platform,
+          hashtags: opts.hashtags ? opts.hashtags.split(",").map((s) => s.trim()) : undefined,
+          cta: opts.cta,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.post?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("delete <id>"))
+    .description("Delete a calendar post (cancels it on Taplio first when applicable)")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete calendar post ${id}. This cannot be undone.`);
+        const r = await call("calendar", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted ?? d.unscheduled ?? id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("engine"))
+    .description("Show which scheduler is live for this workspace (Taplio or built-in cron)")
+    .option("--channel <c>", "linkedin | blog | newsletter", "linkedin")
+    .action(async function (opts) {
+      try {
+        const r = await call("calendar", "engine", { channel: opts.channel }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(
+            `Engine:            ${d.engine}\n` +
+            `Channel:           ${d.channel}\n` +
+            `Taplio connected:  ${d.taplio_connected ? "yes" : "no"}\n` +
+            `Dispatch worker:   ${d.dispatch_worker}\n` +
+            `Reason:            ${d.reason}\n` +
+            `Pending scheduled: ${d.scheduled_pending}\n` +
+            (d.recent_failures?.length
+              ? `\nRecent failures:\n` + table(
+                ["id", "when", "attempts", "error"],
+                d.recent_failures.map((f) => [truncate(f.id, 8), f.scheduled_for ?? "—", f.dispatch_attempts ?? 0, truncate(f.dispatch_error ?? "", 60)]),
+              ) + "\n"
+              : ""),
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("schedule <id>"))
+    .description("Schedule (or reschedule) a calendar post via the live engine")
+    .requiredOption("--at <iso>", "ISO timestamp, e.g. 2026-09-10T09:00:00Z")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .option("--publish-as <p>", "personal | company")
+    .option("--company-page <id>", "company page id when publishing as company")
+    .option("--timezone <tz>", "IANA timezone label to store")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("calendar", "schedule", {
+          id, scheduled_for: opts.at, channel: opts.channel,
+          publish_as: opts.publishAs, company_page_id: opts.companyPage, timezone: opts.timezone,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Scheduled via ${d.engine} for ${d.scheduled_for}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("unschedule <id>"))
+    .description("Cancel a scheduled calendar post (cancels on Taplio when it owns it)")
+    .action(async function (id) {
+      try {
+        const r = await call("calendar", "unschedule", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Unscheduled ${d.unscheduled} (${d.engine})\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("publish-now <id>"))
+    .description("Publish a calendar post immediately")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Publish calendar post ${id} right now.`);
+        const r = await call("calendar", "publish_now", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Published via ${d.worker}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("bulk-schedule <ids...>"))
+    .description("Schedule several calendar posts on a cadence")
+    .option("--start <iso>", "first slot (default: in 1 hour)")
+    .option("--interval-hours <n>", "hours between posts", "24")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .action(async function (ids, opts) {
+      try {
+        const r = await call("calendar", "bulk_schedule", {
+          ids, start: opts.start, interval_hours: Number(opts.intervalHours), channel: opts.channel,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "ok", "engine", "when / error"],
+            (d.results || []).map((x) => [truncate(x.id, 8), x.ok ? "yes" : "no", x.engine ?? "—", x.scheduled_for ?? truncate(x.error ?? "", 50)]),
+          ) + `\n${d.scheduled} scheduled, ${d.failed} failed\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+}
+
+
+export function registerSignals(program) {
+  const s = program.command("signals").description("Read and manage market intelligence signals");
+
+  withCommonOpts(s.command("list"))
+    .description("List intelligence signals")
+    .option("--type <t>", "signal_type (news|funding|hiring|…)")
+    .option("--category <c>", "filter by category")
+    .option("--agent <name>", "filter by agent_name")
+    .option("--unread", "only unread")
+    .option("--min-score <n>", "min relevance_score")
+    .option("--search <q>", "search title/summary")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("signals", "list", {
+          signal_type: o.type, category: o.category, agent_name: o.agent,
+          is_read: o.unread ? false : undefined, min_score: o.minScore,
+          search: o.search, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "score", "type", "agent", "title"],
+            (d.signals || []).map((g) => [
+              truncate(g.id, 8), g.relevance_score ?? "", g.signal_type,
+              truncate(g.agent_name, 22), truncate(g.title, 60),
+            ]),
+          ) + `\n${d.signals?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("show <id>"))
+    .description("Show a signal")
+    .action(async function (id) {
+      try {
+        const r = await call("signals", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.signal, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("create"))
+    .description("Create a manual signal")
+    .requiredOption("--title <t>", "title")
+    .requiredOption("--agent <name>", "agent_name (source)")
+    .option("--type <t>", "signal_type", "news")
+    .option("--category <c>", "category", "general")
+    .option("--url <url>", "source url")
+    .option("--summary <text>", "short summary")
+    .option("--why <text>", "why_it_matters")
+    .option("--action <text>", "recommended_action")
+    .option("--score <n>", "relevance_score 0-100", "50")
+    .option("--flags <csv>", "trigger_flags (funding,hiring,…)")
+    .action(async function (opts) {
+      try {
+        const r = await call("signals", "create", {
+          title: opts.title, agent_name: opts.agent, signal_type: opts.type,
+          category: opts.category, url: opts.url, summary: opts.summary,
+          why_it_matters: opts.why, recommended_action: opts.action,
+          relevance_score: Number(opts.score),
+          trigger_flags: opts.flags ? opts.flags.split(",").map((s) => s.trim()) : undefined,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Created signal ${d.signal?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("update <id>"))
+    .description("Patch a signal")
+    .option("--title <t>")
+    .option("--summary <text>")
+    .option("--why <text>")
+    .option("--action <text>")
+    .option("--score <n>")
+    .option("--category <c>")
+    .option("--sentiment <s>")
+    .option("--flags <csv>")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("signals", "update", {
+          id, title: opts.title, summary: opts.summary,
+          why_it_matters: opts.why, recommended_action: opts.action,
+          relevance_score: opts.score ? Number(opts.score) : undefined,
+          category: opts.category, sentiment: opts.sentiment,
+          trigger_flags: opts.flags ? opts.flags.split(",").map((s) => s.trim()) : undefined,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.signal?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("read <id>"))
+    .description("Mark a signal as read (use --unread to flip back)")
+    .option("--unread", "mark as unread instead")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("signals", "mark_read", { id, is_read: !opts.unread }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.signal?.id} → is_read=${d.signal?.is_read}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("delete <id>"))
+    .description("Delete a signal")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete signal ${id}. This cannot be undone.`);
+        const r = await call("signals", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("cleanup"))
+    .description("Clean up the signal stream (duplicates, irrelevant, quarantined, stale, low score). Dry-run unless --confirm")
+    .option("--modes <csv>", "duplicates,irrelevant,quarantined,stale,low_score", "duplicates")
+    .option("--older-than <days>", "for the stale mode")
+    .option("--max-score <n>", "for the low_score mode")
+    .option("--include-read", "also clean signals already read and marked relevant")
+    .option("--scan-limit <n>", "how many recent signals to scan", "5000")
+    .option("--confirm", "actually delete (default is a dry run)")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (opts) {
+      try {
+        if (opts.confirm) {
+          await confirmDestructive(this, "Permanently delete the matching signals. This cannot be undone.");
+        }
+        const r = await call("signals", "cleanup", {
+          modes: String(opts.modes).split(",").map((m) => m.trim()).filter(Boolean),
+          older_than_days: opts.olderThan ? Number(opts.olderThan) : undefined,
+          max_score: opts.maxScore ? Number(opts.maxScore) : undefined,
+          keep_read: opts.includeRead ? false : undefined,
+          scan_limit: Number(opts.scanLimit),
+          confirm: !!opts.confirm,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const c = d.counts || {};
+          process.stdout.write(table(
+            ["bucket", "count"],
+            Object.entries(c).map(([k, v]) => [k, String(v)]),
+          ) + "\n");
+          process.stdout.write(d.dry_run
+            ? `Dry run — scanned ${d.scanned}, would delete ${d.would_delete}. Re-run with --confirm to apply.\n`
+            : `✓ Scanned ${d.scanned}, deleted ${d.deleted}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerPipelines(program) {
+  const p = program.command("pipelines").description("Manage the opportunities / deal pipeline");
+
+  withCommonOpts(p.command("list"))
+    .description("List opportunities (pipeline)")
+    .option("--status <s>", "filter by status")
+    .option("--stage <s>", "filter by pipeline_stage")
+    .option("--outcome <s>", "qualification_outcome (pending|qualified_in|qualified_out)")
+    .option("--urgency <s>", "low | medium | high")
+    .option("--search <q>", "search title/account")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("pipelines", "list", {
+          status: o.status, pipeline_stage: o.stage,
+          qualification_outcome: o.outcome, urgency: o.urgency,
+          search: o.search, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "stage", "score", "value", "account", "title"],
+            (d.opportunities || []).map((op) => [
+              truncate(op.id, 8), op.pipeline_stage, op.score ?? "",
+              `${op.deal_currency ?? ""}${op.deal_value ?? 0}`,
+              truncate(op.account, 22), truncate(op.title, 40),
+            ]),
+          ) + `\n${d.opportunities?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("show <id>"))
+    .description("Show an opportunity")
+    .action(async function (id) {
+      try {
+        const r = await call("pipelines", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.opportunity, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("create"))
+    .description("Create an opportunity")
+    .requiredOption("--title <t>", "title")
+    .option("--account <a>", "account / company")
+    .option("--type <t>", "revenue | risk | …", "revenue")
+    .option("--urgency <u>", "low | medium | high", "medium")
+    .option("--stage <s>", "pipeline_stage", "engaged")
+    .option("--value <n>", "deal_value", "0")
+    .option("--currency <c>", "deal_currency", "USD")
+    .option("--why <text>", "why_it_matters")
+    .option("--action <text>", "recommended_action")
+    .option("--contact <name>", "contact_name")
+    .option("--email <e>", "contact_email")
+    .option("--close <YYYY-MM-DD>", "close_date")
+    .option("--notes <text>", "notes")
+    .action(async function (opts) {
+      try {
+        const r = await call("pipelines", "create", {
+          title: opts.title, account: opts.account, type: opts.type,
+          urgency: opts.urgency, pipeline_stage: opts.stage,
+          deal_value: Number(opts.value), deal_currency: opts.currency,
+          why_it_matters: opts.why, recommended_action: opts.action,
+          contact_name: opts.contact, contact_email: opts.email,
+          close_date: opts.close, notes: opts.notes,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Created opportunity ${d.opportunity?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("update <id>"))
+    .description("Patch an opportunity")
+    .option("--title <t>")
+    .option("--account <a>")
+    .option("--stage <s>", "pipeline_stage")
+    .option("--status <s>")
+    .option("--value <n>", "deal_value")
+    .option("--currency <c>")
+    .option("--urgency <u>")
+    .option("--score <n>")
+    .option("--why <text>")
+    .option("--action <text>")
+    .option("--contact <name>")
+    .option("--email <e>")
+    .option("--close <YYYY-MM-DD>")
+    .option("--notes <text>")
+    .option("--lost-reason <text>")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("pipelines", "update", {
+          id, title: opts.title, account: opts.account,
+          pipeline_stage: opts.stage, status: opts.status,
+          deal_value: opts.value ? Number(opts.value) : undefined,
+          deal_currency: opts.currency, urgency: opts.urgency,
+          score: opts.score ? Number(opts.score) : undefined,
+          why_it_matters: opts.why, recommended_action: opts.action,
+          contact_name: opts.contact, contact_email: opts.email,
+          close_date: opts.close, notes: opts.notes, lost_reason: opts.lostReason,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.opportunity?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("stage <id> <pipelineStage>"))
+    .description("Move an opportunity to a new pipeline_stage")
+    .action(async function (id, stage) {
+      try {
+        const r = await call("pipelines", "update_stage", { id, pipeline_stage: stage }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.opportunity?.id} → ${d.opportunity?.pipeline_stage}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("qualify <id> <outcome>"))
+    .description("Set qualification_outcome (pending|qualified_in|qualified_out)")
+    .action(async function (id, outcome) {
+      try {
+        const r = await call("pipelines", "qualify", { id, qualification_outcome: outcome }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.opportunity?.id} → ${d.opportunity?.qualification_outcome}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(p.command("delete <id>"))
+    .description("Delete an opportunity")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete pipeline record ${id}. This cannot be undone.`);
+        const r = await call("pipelines", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerAgents(program) {
+  const a = program.command("agents").description("List, create, configure and invoke agents");
+
+  withCommonOpts(a.command("trigger <name>"))
+    .description("Trigger an agent by name with optional JSON input")
+    .option("--input <json>", "JSON input payload", "{}")
+    .action(async function (name) {
+      try {
+        const o = this.optsWithGlobals();
+        let input = {};
+        try { input = JSON.parse(o.input); } catch { throw new Error("--input must be valid JSON"); }
+        const r = await call("agents", "trigger", { agent_name: name, input }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.run, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("history"))
+    .description("Recent agent runs and jobs")
+    .option("--agent <name>", "filter by agent name")
+    .option("--days <n>", "look-back window", "30")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("agents", "history", {
+          agent_name: o.agent, days: Number(o.days), limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["when", "agent", "status", "results"],
+            (d.runs || []).map((x) => [
+              String(x.created_at ?? "").slice(0, 16), truncate(x.agent_name, 30),
+              x.status ?? "", String(x.results_count ?? ""),
+            ]),
+          ) + `\n${d.runs?.length ?? 0} runs, ${d.jobs?.length ?? 0} jobs\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("list"))
+    .description("List available agents")
+    .option("--scope <s>", "workspace | global | both (default: both)")
+    .option("--status <s>", "filter by status")
+    .option("--layer <l>", "filter by layer")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("agents", "list", {
+          scope: o.scope, status: o.status, layer: o.layer,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["name", "status", "layer", "schedule"],
+            (d.agents || []).map((a) => [
+              truncate(a.name, 32), a.status ?? "", a.layer ?? "", truncate(a.schedule, 20),
+            ]),
+          ) + `\n${d.agents?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("show <nameOrId>"))
+    .description("Show an agent (by id or name)")
+    .action(async function (key) {
+      try {
+        const isUuid = /^[0-9a-f-]{36}$/i.test(key);
+        const r = await call("agents", "get", isUuid ? { id: key } : { name: key }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.agent, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("create"))
+    .description("Create a custom agent")
+    .requiredOption("--name <name>", "agent name (unique per workspace)")
+    .requiredOption("--layer <l>", "layer (intelligence | content | sales | …)")
+    .option("--description <text>")
+    .option("--status <s>", "planned | active | paused", "active")
+    .option("--schedule <cron>", "cron schedule")
+    .option("--type <t>", "agent_type")
+    .option("--icon <icon>", "icon name", "bot")
+    .option("--tools <text>", "tool descriptor")
+    .option("--outputs <csv>", "expected outputs")
+    .option("--scope <s>", "workspace | global (default: workspace)")
+    .option("--pipeline <json>", "pipeline JSON")
+    .action(async function (opts) {
+      try {
+        let pipeline; if (opts.pipeline) try { pipeline = JSON.parse(opts.pipeline); }
+          catch { return fail(new Error("--pipeline must be valid JSON")); }
+        const r = await call("agents", "create", {
+          name: opts.name, layer: opts.layer, description: opts.description,
+          status: opts.status, schedule: opts.schedule, agent_type: opts.type,
+          icon: opts.icon, tools: opts.tools, scope: opts.scope,
+          outputs: opts.outputs ? opts.outputs.split(",").map((s) => s.trim()) : undefined,
+          pipeline,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Created agent ${d.agent?.name} (${d.agent?.id})\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("update <id>"))
+    .description("Patch an agent")
+    .option("--name <name>")
+    .option("--description <text>")
+    .option("--status <s>")
+    .option("--schedule <cron>")
+    .option("--layer <l>")
+    .option("--type <t>")
+    .option("--icon <icon>")
+    .option("--tools <text>")
+    .option("--outputs <csv>")
+    .option("--pipeline <json>")
+    .action(async function (id, opts) {
+      try {
+        let pipeline; if (opts.pipeline) try { pipeline = JSON.parse(opts.pipeline); }
+          catch { return fail(new Error("--pipeline must be valid JSON")); }
+        const r = await call("agents", "update", {
+          id, name: opts.name, description: opts.description, status: opts.status,
+          schedule: opts.schedule, layer: opts.layer, agent_type: opts.type,
+          icon: opts.icon, tools: opts.tools,
+          outputs: opts.outputs ? opts.outputs.split(",").map((s) => s.trim()) : undefined,
+          pipeline,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated agent ${d.agent?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("set-status <id> <status>"))
+    .description("Change an agent's status (active|paused|planned|…)")
+    .action(async function (id, status) {
+      try {
+        const r = await call("agents", "set_status", { id, status }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.agent?.name ?? id} → ${d.agent?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("run <name>"))
+    .description("Invoke an agent")
+    .option("--input <json>", "JSON input payload", "{}")
+    .action(async function (name, opts) {
+      try {
+        let input = {};
+        try { input = JSON.parse(opts.input); }
+        catch { return fail(new Error("--input must be valid JSON")); }
+        const r = await call("agents", "run", { agent_name: name, input }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.run, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("job <id>"))
+    .alias("job-status")
+    .description("Check agent_jobs status (accepts a full or short job id)")
+    .action(async function (id) {
+      try {
+        const r = await call("agents", "job_status", { job_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.job, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("pipeline [name]"))
+    .alias("inspect")
+    .description("Inspect an agent's configuration and content pipeline (default: Content Creator Agent)")
+    .action(async function (name) {
+      try {
+        const r = await call("agents", "pipeline", { agent_name: name || "Content Creator Agent" }, ctxFrom(this));
+        emit(this, r, (d) => {
+          if (!d.agent) { process.stdout.write(`${d.error || "Agent not found"}\n`); return; }
+          process.stdout.write(`${d.agent.name} — ${d.agent.status} (${d.agent.agent_type || "agent"})\n\n`);
+          process.stdout.write(table(
+            ["stage", "what it does"],
+            (d.pipeline?.stages || []).map((s) => [s.id, truncate(s.detail, 80)]),
+          ) + "\n");
+          process.stdout.write(`Blocking gates: ${(d.pipeline?.blocking_gates || []).join(", ")}\n`);
+          process.stdout.write(`Advisory gates: ${(d.pipeline?.advisory_gates || []).join(", ")}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("runs"))
+    .description("List recent agent runs in this workspace")
+    .option("--agent <name>", "filter by agent_name")
+    .option("--limit <n>", "max rows", "25")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("agents", "recent_runs", {
+          agent_name: o.agent, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["created", "agent", "status", "results", "enriched"],
+            (d.runs || []).map((rr) => [
+              (rr.created_at || "").slice(0, 16).replace("T", " "),
+              truncate(rr.agent_name, 28), rr.status, rr.results_count ?? 0, rr.enriched_count ?? 0,
+            ]),
+          ) + `\n${d.runs?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("delete <id>"))
+    .description("Delete an agent")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete agent ${id}. This cannot be undone.`);
+        const r = await call("agents", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerAuthority(program) {
+  const a = program.command("authority").description("Authority Loop — queue, approve, dispatch, settings");
+
+  withCommonOpts(a.command("list"))
+    .description("List authority touches (queued/approved/sent/failed/cancelled)")
+    .option("--status <s>", "filter by status (queued|approved|sent|failed|cancelled|skipped)")
+    .option("--channel <c>", "filter by channel (linkedin_dm|linkedin_invite)")
+    .option("--lead <id>", "filter by lead_id")
+    .option("--min-score <n>", "minimum score")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("authority", "list", {
+          status: o.status, channel: o.channel, lead_id: o.lead,
+          min_score: o.minScore ? Number(o.minScore) : undefined,
+          limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "status", "channel", "score", "asset", "scheduled"],
+            (d.touches || []).map((t) => [
+              t.id.slice(0, 8), t.status, t.channel, t.score ?? 0,
+              truncate(t.asset_title || t.asset_url || "", 36),
+              (t.scheduled_for || "").slice(0, 16).replace("T", " "),
+            ]),
+          ) + `\n${d.touches?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("show <id>"))
+    .description("Full JSON for one authority touch")
+    .action(async function (id) {
+      try {
+        const r = await call("authority", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.touch, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("approve <id>"))
+    .description("Approve a queued touch (sets status=approved)")
+    .action(async function (id) {
+      try {
+        const r = await call("authority", "approve", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Approved ${d.touch?.id} → ${d.touch?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("cancel <id>"))
+    .description("Cancel a queued/approved touch")
+    .option("--reason <text>", "skipped_reason note")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("authority", "cancel", { id, reason: opts.reason }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Cancelled ${d.touch?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("dispatch <id>"))
+    .description("Dispatch a queued/approved touch via LinkedIn (calls authority-touch-dispatch)")
+    .action(async function (id) {
+      try {
+        const r = await call("authority", "dispatch", { id }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const ok = d.dispatch?.success;
+          process.stdout.write(`${ok ? "✓" : "✖"} dispatch status=${d.status} ${JSON.stringify(d.dispatch)}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  const settings = a.command("settings").description("Authority Loop workspace settings");
+
+  withCommonOpts(settings.command("get"))
+    .description("Read authority_loop_settings for this workspace")
+    .action(async function () {
+      try {
+        const r = await call("authority", "settings_get", {}, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.settings, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(settings.command("set"))
+    .description("Patch authority_loop_settings for this workspace (upsert)")
+    .option("--enabled <bool>", "is_enabled (true|false)")
+    .option("--auto-approve <bool>", "auto_approve (true|false)")
+    .option("--daily-cap <n>", "max dispatches per day")
+    .option("--min-relevance <n>", "min signal relevance_score (0-100)")
+    .option("--min-match <n>", "min KB match score (0-100)")
+    .option("--channels <csv>", "allowed_channels e.g. linkedin_dm,linkedin_invite")
+    .option("--kb-categories <csv>", "allowed_kb_categories CSV")
+    .option("--trigger-flags <csv>", "allowed_trigger_flags CSV")
+    .option("--quiet-start <hhmm>", "quiet_hours_start (e.g. 22:00)")
+    .option("--quiet-end <hhmm>", "quiet_hours_end (e.g. 07:00)")
+    .action(async function (opts) {
+      try {
+        const asBool = (v) => v === undefined ? undefined : /^(1|true|yes|on)$/i.test(String(v));
+        const asCsv = (v) => v === undefined ? undefined : String(v).split(",").map((s) => s.trim()).filter(Boolean);
+        const params = {
+          is_enabled: asBool(opts.enabled),
+          auto_approve: asBool(opts.autoApprove),
+          daily_cap: opts.dailyCap !== undefined ? Number(opts.dailyCap) : undefined,
+          min_relevance_score: opts.minRelevance !== undefined ? Number(opts.minRelevance) : undefined,
+          min_match_score: opts.minMatch !== undefined ? Number(opts.minMatch) : undefined,
+          allowed_channels: asCsv(opts.channels),
+          allowed_kb_categories: asCsv(opts.kbCategories),
+          allowed_trigger_flags: asCsv(opts.triggerFlags),
+          quiet_hours_start: opts.quietStart,
+          quiet_hours_end: opts.quietEnd,
+        };
+        const r = await call("authority", "settings_set", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Settings updated\n${JSON.stringify(d.settings, null, 2)}\n`));
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerBriefs(program) {
+  const b = program.command("briefs").description("Chief of Staff morning briefs — list, show, generate");
+
+  withCommonOpts(b.command("list"))
+    .description("Recent intelligence_briefs for this workspace")
+    .option("--user <id>", "filter by user_id")
+    .option("--limit <n>", "max rows", "25")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("briefs", "list", {
+          user_id: o.user,
+          limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "created", "signals", "actions", "sentiment", "headline"],
+            (d.briefs || []).map((x) => [
+              x.id.slice(0, 8),
+              (x.created_at || "").slice(0, 16).replace("T", " "),
+              x.signal_count ?? 0,
+              x.top_actions_count ?? 0,
+              x.sentiment ?? "—",
+              truncate(x.headline || "", 48),
+            ]),
+          ) + `\n${d.briefs?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(b.command("show <id>"))
+    .description("Full JSON for one brief (brief_data, talking points, top actions, risks)")
+    .action(async function (id) {
+      try {
+        const r = await call("briefs", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.brief, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(b.command("generate"))
+    .description("Generate a fresh brief now — invokes agent-chief-of-staff for this workspace")
+    .option("--user <id>", "attribute brief to a specific user_id (defaults to workspace owner)")
+    .option("--job <id>", "existing agent_jobs.id to report progress against")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("briefs", "generate", {
+          user_id: o.user,
+          job_id: o.job,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const g = d.generate || {};
+          const ok = g.success !== false && d.status < 400;
+          process.stdout.write(
+            `${ok ? "✓" : "✖"} chief-of-staff status=${d.status}` +
+            (g.brief_id ? ` brief_id=${g.brief_id}` : "") +
+            (g.headline ? `\n  ${g.headline}` : "") +
+            (g.signal_count !== undefined ? `\n  signals=${g.signal_count} actions=${g.actions_generated ?? "?"}` : "") +
+            "\n",
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+}