@series-a/cli 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -4,8 +4,19 @@ All notable changes to this package are documented here. This project follows
 [Semantic Versioning](https://semver.org/) and uses
 [Changesets](https://github.com/changesets/changesets) to manage releases.
 
+## 0.2.0 — Write coverage expansion
+
+- `inbox` — added `send`, `reply` (dry-run by default, `--confirm` to dispatch, 7,900 char guard), `mark-read` (bulk), `snooze` (`--for`, `--until`, `--clear`).
+- `sequences` — added `create`, `update`, `add-step` (per-action char limits: invite 200 / DM 8000 / comment 1250), `clone` (with branch remap), `validate`.
+- `content` — full CRUD: `create`, `update`, `delete` alongside existing `list`/`show`/`publish`.
+- `calendar` — new resource group: `list`, `create`, `update`, `delete` against `calendar_posts`.
+- `signals` — new resource group backed by `intelligence_signals`: `list`, `create`, `update`, `delete`.
+- `pipelines` — alias of `opportunities` with `list`, `create`, `update`, `delete`.
+- `agents` — added `create`, `update`, `set-status`, `delete`, `recent-runs`.
+
 ## 0.1.0 — Initial release
 
+
 - `advisoros login` / `logout` / `whoami` / `profiles` with multi-workspace profile support.
 - `leads` — `list`, `get`, `set-status`, `import` (CSV/JSON/JSONL, auto-chunked), `verify`.
 - `campaigns` — `list`, `show`, `create`, `add-leads`, `launch`, `pause`, `resume`.

package/package.json

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

package/src/commands/resources.mjs

@@ -222,7 +222,7 @@ export function registerCampaigns(program) {
 }
 
 export function registerSequences(program) {
-  const s = program.command("sequences").description("View LinkedIn sequences");
+  const s = program.command("sequences").description("Manage LinkedIn sequences");
 
   withCommonOpts(s.command("list"))
     .description("List sequences")
@@ -234,7 +234,7 @@ export function registerSequences(program) {
         emit(this, r, (d) => {
           process.stdout.write(table(
             ["id", "name", "status"],
-            (d.sequences || []).map((s) => [truncate(s.id, 8), truncate(s.name, 40), s.status]),
+            (d.sequences || []).map((s) => [s.id, truncate(s.name, 40), s.status]),
           ) + `\n${d.sequences?.length ?? 0} rows\n`);
         });
       } catch (e) { fail(e); }
@@ -257,10 +257,129 @@ export function registerSequences(program) {
         });
       } 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|addComment|sendInvitation|sendMessage|wait")
+    .option("--text <message>", "message_content (required for addComment/sendInvitation/sendMessage)")
+    .option("--delay <days>", "delay_days before this step", "0")
+    .option("--variant <v>", "variant label", "A")
+    .option("--step-type <t>", "action|branch|wait", "action")
+    .option("--channel <c>", "channel", "linkedin")
+    .option("--branch <label>", "branch_label (for branching steps)")
+    .option("--parent-step <id>", "parent_step_id (for branches)")
+    .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,
+          variant: opts.variant,
+          step_type: opts.stepType,
+          channel: opts.channel,
+          branch_label: opts.branch,
+          parent_step_id: opts.parentStep,
+          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=${st.delay_days}d variant=${st.variant}\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); }
+    });
+}
+
+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 unified inbox");
+  const inbox = program.command("inbox").description("Inspect and act on the unified inbox");
 
   withCommonOpts(inbox.command("threads"))
     .description("List recent inbox messages")
@@ -290,46 +409,254 @@ export function registerInbox(program) {
       } 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)")
-    .action(async function (leadId, opts) {
+    .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 {
-        const r = await call("inbox", "send_dm", {
-          lead_id: leadId,
-          text: opts.text,
-          sender_account_id: opts.sender,
+        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) => {
-          const s = d.sent || {};
-          const b = s.budget || {};
+          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)")
+    .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,
+        };
+        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` : "") +
+            (d.ai?.success === false ? `  ⚠ AI classify: ${d.ai.error}\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")
+    .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,
+        };
+        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("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(
-            `✓ ${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` : ""),
+            `✓ 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 and publish content");
+  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")
-    .option("--type <t>", "filter by type")
+    .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, search: o.search, limit: Number(o.limit),
+          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(
@@ -349,6 +676,72 @@ export function registerContent(program) {
       } 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")
+    .action(async function (id, ts) {
+      try {
+        const r = await call("content", "schedule", { id, scheduled_date: ts }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Scheduled ${d.content?.id} → ${d.content?.scheduled_date}\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("publish <id>"))
     .description("Dispatch publication via agent-content-posting")
     .action(async function (id) {
@@ -357,25 +750,456 @@ export function registerContent(program) {
         emit(this, r, (d) => process.stdout.write(JSON.stringify(d.publish, null, 2) + "\n"));
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(c.command("delete <id>"))
+    .description("Delete a content item")
+    .action(async function (id) {
+      try {
+        const r = await call("content", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\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")
+    .action(async function (opts) {
+      try {
+        let content = opts.content;
+        if (opts.contentFile) content = await readFile(opts.contentFile, "utf8");
+        const r = await call("calendar", "create", {
+          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")
+    .action(async function (id) {
+      try {
+        const r = await call("calendar", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\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")
+    .action(async function (id) {
+      try {
+        const r = await call("signals", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ 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")
+    .action(async function (id) {
+      try {
+        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 and invoke agents");
+  const a = program.command("agents").description("List, create, configure and invoke agents");
 
   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 r = await call("agents", "list", {}, ctxFrom(this));
+        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", "model"],
-            (d.agents || []).map((a) => [truncate(a.name, 32), a.status ?? "", truncate(a.model, 30)]),
+            ["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", "{}")
@@ -397,4 +1221,216 @@ export function registerAgents(program) {
         emit(this, r, (d) => process.stdout.write(JSON.stringify(d.job, null, 2) + "\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")
+    .action(async function (id) {
+      try {
+        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); }
+    });
 }

package/src/index.mjs

@@ -2,7 +2,9 @@ import { Command } from "commander";
 import { registerAuth } from "./commands/auth.mjs";
 import {
   registerLeads, registerCampaigns, registerSequences,
-  registerInbox, registerContent, registerAgents,
+  registerInbox, registerContent, registerAgents, registerKnowledge,
+  registerCalendar, registerSignals, registerPipelines, registerAuthority,
+  registerBriefs,
 } from "./commands/resources.mjs";
 import { registerFlow } from "./commands/flow.mjs";
 
@@ -20,6 +22,12 @@ registerCampaigns(program);
 registerSequences(program);
 registerInbox(program);
 registerContent(program);
+registerCalendar(program);
+registerKnowledge(program);
+registerSignals(program);
+registerPipelines(program);
+registerAuthority(program);
+registerBriefs(program);
 registerAgents(program);
 registerFlow(program);