@series-a/cli 0.7.1 → 0.13.1

package/CHANGELOG.md

@@ -4,6 +4,45 @@ 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.13.0 — Full lifecycle + scheduling engine
+
+- Campaign lifecycle is complete from the terminal: `campaigns update` (name, goal, sequence, sender accounts, daily send limit — no longer create-time-only), `launch`, `pause`, `resume`, `archive`, `clone`, and `delete` (dry-run preview by default, `--force` to execute, blocked when the campaign has dispatched activity unless forced).
+- Sequence editing: `sequences update-step`, `delete-step`, and `replace-steps` — steps are no longer append-only. Graph validation flags disconnected nodes and cycles before launch.
+- Scheduling engine awareness: calendar/schedule commands report whether a workspace will publish via Taplio (when connected) or the built-in cron scheduler, so automation targets the right engine.
+- Live counts after writes: campaign and sequence mutations re-read the record and return live stats, clearly separated from the stored snapshot which may lag.
+- Clearer errors under load: the API now returns a typed 429 with retry-after guidance instead of empty lists during heavy automation; the CLI surfaces this plainly.
+
+## 0.12.0 — Agent audit trail
+
+- `advisoros audit list/show/stats` — query the durable per-workspace audit log of every CLI/MCP/Agent API action (actor, surface, action, outcome, duration, correlation ID).
+- CLI requests now send actor/client/version headers so audit records attribute actions to the right user and CLI version.
+- `login` persists the profile email for audit attribution.
+
+## 0.11.0 — Video management
+
+- `videos` resource group: `list`, `show`, `create`, `generate`, `update`, `publish`, `unpublish`, `refresh`, `delete` against video projects, with workspace scoping and destructive-action confirmation.
+
+## 0.10.0 — Calendar & Command Centre write access
+
+- Full content calendar read/write/delete/schedule via CLI, with bulk operations and engine-aware scheduling (Taplio when connected, built-in cron otherwise).
+- Command Centre content management: update, approve, schedule, unschedule, and publish-now actions.
+
+## 0.9.0 — Tone of Voice
+
+- Full Tone of Voice support: workspace configuration, writing-sample references, benchmark pinning, voice cards, scoring/redrafting, and report CRUD.
+
+## 0.8.0 — Content Strategy
+
+- Full content strategy read/write: create, list, show, update, delete strategies; manage strategy posts; retry/resume generation.
+
+## 0.7.0 — Hardening & admin keys
+
+- Shared typed errors with machine-readable codes across all commands.
+- Cursor pagination up to 1,000 items per page.
+- Destructive actions require explicit confirmation (`--confirm` / `--force`).
+- `login --admin` for admin API keys, `--as-agent` impersonation flag, and `whoami` scope reporting.
+- Admin keys (`advos_admin_…`) authorize from key scope alone and work across all workspaces.
+
 ## 0.6.1 — Campaign editing
 
 - `campaigns` — added `update`/`edit` (name, description, goal, sequence, sender accounts, daily send limit, launch stage, status). Mirrors the new `update_campaign` MCP tool.

package/package.json

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

package/src/api.mjs

@@ -1,5 +1,15 @@
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
 import { getProfile, DEFAULTS } from "./config.mjs";
 
+const CLI_VERSION = (() => {
+  try {
+    return createRequire(import.meta.url)("../package.json").version;
+  } catch {
+    return "unknown";
+  }
+})();
+
 export class AdvisorOSApiError extends Error {
   constructor(message, { status, body } = {}) {
     super(message);
@@ -32,6 +42,11 @@ export async function call(resource, action, params = {}, opts = {}) {
     stored?.agentName ||
     "advisoros-cli";
 
+  const actorEmail =
+    opts.actorEmail || process.env.ADVISOROS_ACTOR_EMAIL || stored?.email || null;
+  const actorUserId =
+    opts.actorUserId || process.env.ADVISOROS_ACTOR_USER_ID || stored?.userId || null;
+
   if (!apiKey) {
     throw new AdvisorOSApiError(
       "No API key configured. Run `advisoros login` or set ADVISOROS_API_KEY.",
@@ -59,6 +74,12 @@ export async function call(resource, action, params = {}, opts = {}) {
       headers: {
         "Content-Type": "application/json",
         "x-service-account-key": apiKey,
+        "x-surface": "cli",
+        "x-client-name": "advisoros-cli",
+        "x-client-version": CLI_VERSION,
+        "x-correlation-id": opts.correlationId || randomUUID(),
+        ...(actorUserId ? { "x-actor-user-id": actorUserId } : {}),
+        ...(actorEmail ? { "x-actor-email": actorEmail } : {}),
       },
       body: JSON.stringify(body),
     });

package/src/commands/auth.mjs

@@ -14,6 +14,7 @@ export function registerAuth(program) {
     .option("--admin", "admin key login — verify cross-workspace, no workspace required", false)
     .option("--base-url <url>", "agent-api base URL", DEFAULTS.baseUrl)
     .option("--as-agent <name>", "caller identity to send as agent_name", "advisoros-cli")
+    .option("--email <email>", "your email — recorded on the audit trail for every action")
     .action(async (opts) => {
       try {
         let { apiKey, workspace, baseUrl, profile } = opts;
@@ -49,7 +50,7 @@ export function registerAuth(program) {
             apiKey, baseUrl, agentName,
           });
           const count = verify?.pagination?.total ?? verify?.workspaces?.length ?? 0;
-          await setProfile(profile, { apiKey, baseUrl, admin: true, agentName, ...(workspace ? { workspaceId: workspace } : {}) });
+          await setProfile(profile, { apiKey, baseUrl, admin: true, agentName, ...(opts.email ? { email: opts.email } : {}), ...(workspace ? { workspaceId: workspace } : {}) });
           process.stdout.write(chalk.green(
             `\n✓ Logged in as admin profile "${profile}" — ${count} workspaces reachable\n` +
             `  Config: ${CONFIG_PATH}\n` +
@@ -63,7 +64,7 @@ export function registerAuth(program) {
           apiKey, workspaceId: workspace, baseUrl, agentName,
         });
         const count = verify?.agents?.length ?? 0;
-        await setProfile(profile, { apiKey, workspaceId: workspace, baseUrl, agentName });
+        await setProfile(profile, { apiKey, workspaceId: workspace, baseUrl, agentName, ...(opts.email ? { email: opts.email } : {}) });
         process.stdout.write(chalk.green(
           `\n✓ Logged in as profile "${profile}" — workspace ${workspace} (${count} agents visible)\n` +
           `  Config: ${CONFIG_PATH}\n`,

package/src/commands/insights.mjs

@@ -1,6 +1,6 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { call } from "../api.mjs";
-import { emit, fail, ctxFrom, withCommonOpts, table, truncate } from "../ui.mjs";
+import { emit, fail, ctxFrom, withCommonOpts, table, truncate, confirmDestructive } from "../ui.mjs";
 
 const n = (v) => (v == null ? "" : String(v));
 
@@ -782,6 +782,115 @@ export function registerVideo(program) {
         emit(this, r, (d) => process.stdout.write(`${d.share_url ?? "not shared"}\n`));
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(v.command("avatars"))
+    .description("List the avatars curated for this workspace")
+    .action(async function () {
+      try {
+        const r = await call("video", "avatars", {}, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["avatar_id", "name", "gender", "voice", "default"],
+            (d.avatars || []).map((x) => [
+              truncate(x.avatar_id, 20), truncate(x.avatar_name, 24), n(x.gender),
+              truncate(n(x.default_voice_id), 20), x.is_default ? "yes" : "",
+            ]),
+          ) + `\n${d.avatars?.length ?? 0} rows\n`);
+          if (d.note) process.stdout.write(`${d.note}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("create"))
+    .description("Generate a new AI video (talking head or explainer)")
+    .option("--prompt <text>", "brief or script context")
+    .option("--source-url <url>", "generate an explainer from a web page")
+    .option("--content-item <id>", "generate from a content item")
+    .option("--kind <k>", "talking_head | explainer", "talking_head")
+    .option("--avatar <id>", "avatar_id (see `video avatars`)")
+    .option("--voice <id>", "voice_id")
+    .option("--style <s>", "professional | casual | educational | inspirational")
+    .option("--format <f>", "platform format (e.g. linkedin, shorts)")
+    .option("--duration <n>", "target duration in seconds")
+    .option("--script-mode <m>", "verbatim to use --prompt as the exact script")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        if (!o.prompt && !o.sourceUrl && !o.contentItem) {
+          throw new Error("Provide --prompt, --source-url or --content-item");
+        }
+        const r = await call("video", "create", {
+          prompt: o.prompt,
+          source_url: o.sourceUrl,
+          content_item_id: o.contentItem,
+          video_kind: o.kind,
+          avatar_id: o.avatar,
+          voice_id: o.voice,
+          style: o.style,
+          video_format: o.format,
+          target_duration: o.duration ? Number(o.duration) : undefined,
+          script_mode: o.scriptMode,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.video ?? d, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("update <id>"))
+    .description("Update video metadata (title, episode label, CTA)")
+    .option("--title <t>")
+    .option("--episode <label>")
+    .option("--cta-type <t>", "book_call | visit_site | subscribe | custom | none")
+    .option("--cta-label <l>")
+    .option("--cta-url <u>")
+    .option("--summary <s>")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("video", "update", {
+          id, title: o.title, episode_label: o.episode,
+          cta_type: o.ctaType, cta_label: o.ctaLabel, cta_url: o.ctaUrl, summary: o.summary,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.video, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("publish <id>"))
+    .description("Make the video publicly shareable")
+    .action(async function (id) {
+      try {
+        const r = await call("video", "publish", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`${d.share_url ?? "published"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("unpublish <id>"))
+    .description("Revoke the public share link")
+    .action(async function (id) {
+      try {
+        const r = await call("video", "unpublish", { id }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write("unpublished\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("refresh <id>"))
+    .description("Re-check the render status with the provider")
+    .action(async function (id) {
+      try {
+        const r = await call("video", "refresh", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.video ?? d, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("delete <id>"))
+    .description("Delete a video project")
+    .option("--yes", "skip confirmation")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete video project ${id}. This cannot be undone.`);
+        const r = await call("video", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
 }
 
 export function registerWatchlist(program) {
@@ -950,6 +1059,64 @@ export function registerActivity(program) {
     });
 }
 
+export function registerAudit(program) {
+  const a = program.command("audit").description("Audit trail of CLI / agent / assistant actions");
+
+  withCommonOpts(a.command("list"))
+    .description("List audited actions (newest first)")
+    .option("--status <s>", "ok | denied | error")
+    .option("--surface <s>", "cli | mcp | api | internal")
+    .option("--resource <r>", "e.g. leads, campaigns, content")
+    .option("--actor <email>", "filter by person")
+    .option("--writes", "only actions that changed data")
+    .option("--since <iso>", "ISO timestamp lower bound")
+    .option("--until <iso>", "ISO timestamp upper bound")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("audit", "list", {
+          status: o.status, surface: o.surface, resource: o.resource,
+          actor_email: o.actor, writes_only: !!o.writes,
+          since: o.since, until: o.until, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["when", "who", "from", "action", "status", "ms"],
+            (d.entries || []).map((x) => [
+              n(x.created_at).replace("T", " ").slice(0, 19),
+              truncate(x.actor_email || x.agent_name || "-", 24),
+              n(x.surface),
+              truncate(`${x.resource}.${x.action}`, 28),
+              n(x.status),
+              n(x.duration_ms),
+            ]),
+          ) + `\n${d.entries?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("show <id>"))
+    .description("Full request and outcome for one audited action")
+    .action(async function (id) {
+      try {
+        const r = await call("audit", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.entry, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("stats"))
+    .description("Rolled-up audit summary")
+    .option("--since <iso>", "ISO timestamp lower bound")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("audit", "stats", { since: o.since }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+}
+
 export function registerWorkspacesExtras(program) {
   const w = program.command("workspaces").description("Workspaces (admin keys only)");
 
@@ -1024,11 +1191,36 @@ export function registerIntegrations(program) {
     });
 
   withCommonOpts(i.command("check <platform>"))
-    .description("Health-check one integration")
+    .description("Health-check one integration (e.g. linkedin_tool, resend)")
     .action(async function (platform) {
       try {
         const r = await call("integrations", "check", { platform }, ctxFrom(this));
         emit(this, r, (d) => process.stdout.write(JSON.stringify(d, null, 2) + "\n"));
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(i.command("health"))
+    .description("Live verdict: is Resend configured and are LinkedIn seats connected?")
+    .action(async function () {
+      try {
+        const r = await call("integrations", "health", {}, ctxFrom(this));
+        emit(this, r, (d) => {
+          const flag = d.healthy ? "✔ healthy" : "✖ issues: " + (d.issues || []).join(", ");
+          process.stdout.write(`${flag}\n`);
+          process.stdout.write(table(
+            ["integration", "state", "detail"],
+            [
+              ["resend", d.resend?.state ?? "unknown",
+                d.resend?.configured ? `from=${d.resend?.from_email ?? "?"}` : (d.resend?.detail ?? "not configured")],
+              ...(d.linkedin?.seats?.length
+                ? d.linkedin.seats.map((s) => [
+                    `linkedin:${truncate(s.display_name || s.account_id || "?", 22)}`,
+                    s.state, s.connection_status ?? "",
+                  ])
+                : [["linkedin", d.linkedin?.verdict ?? "unknown", "no seats"]]),
+            ],
+          ) + "\n");
+        });
+      } catch (e) { fail(e); }
+    });
 }

package/src/commands/resources.mjs

@@ -1049,11 +1049,27 @@ export function registerContent(program) {
     });
 
   withCommonOpts(c.command("schedule <id> <isoTimestamp>"))
-    .description("Schedule a content item")
-    .action(async function (id, ts) {
+    .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", "schedule", { id, scheduled_date: ts }, ctxFrom(this));
-        emit(this, r, (d) => process.stdout.write(`✓ Scheduled ${d.content?.id} → ${d.content?.scheduled_date}\n`));
+        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); }
     });
 
@@ -1066,15 +1082,58 @@ export function registerContent(program) {
       } 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("Dispatch publication via agent-content-posting")
-    .action(async function (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 {
-        const r = await call("content", "publish", { id }, ctxFrom(this));
-        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.publish, null, 2) + "\n"));
+        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")
@@ -1181,11 +1240,13 @@ export function registerCalendar(program) {
     .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,
@@ -1221,17 +1282,99 @@ export function registerCalendar(program) {
     });
 
   withCommonOpts(cal.command("delete <id>"))
-    .description("Delete a calendar post")
+    .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}\n`));
+        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");
 

package/src/commands/strategies.mjs

@@ -0,0 +1,242 @@
+import { call } from "../api.mjs";
+import { emit, fail, ctxFrom, withCommonOpts, table, truncate, confirmDestructive } from "../ui.mjs";
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export function registerStrategies(program) {
+  const s = program
+    .command("strategy")
+    .alias("strategies")
+    .description("Build and manage AI content strategies (multi-week content arcs)");
+
+  withCommonOpts(s.command("ideate"))
+    .description("Propose 3 grounded strategy directions from KB + signals")
+    .option("--hint <text>", "steer the ideation (theme, audience, launch…)")
+    .option("--no-tone", "do not apply the workspace tone of voice")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("strategies", "ideate", {
+          hint: o.hint, apply_tone_of_voice: o.tone !== false,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          (d.strategies || []).forEach((st, i) => {
+            process.stdout.write(
+              `\n${i + 1}. ${st.name}\n   audience: ${st.audience}\n   outcome:  ${st.outcome}\n   pillars:  ${(st.pillars || []).join(", ")}\n   ${st.narrative}\n`,
+            );
+          });
+          process.stdout.write("\n");
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("create"))
+    .description("Build a full strategy: plans the arc and queues every post for drafting")
+    .requiredOption("--name <name>", "strategy name")
+    .option("--narrative <text>", "the story arc")
+    .option("--audience <text>", "who it targets")
+    .option("--outcome <text>", "what it should achieve")
+    .option("--pillars <list>", "comma-separated content pillars")
+    .option("--months <n>", "duration in months", "1")
+    .option("--per-week <n>", "posts per week (1-5)", "3")
+    .option("--format <f>", "linkedin | blog | mixed", "linkedin")
+    .option("--no-tone", "do not apply the workspace tone of voice")
+    .option("--wait", "poll resume until every post is drafted")
+    .action(async function (opts) {
+      try {
+        const ctx = ctxFrom(this);
+        const r = await call("strategies", "create", {
+          strategy: {
+            name: opts.name, narrative: opts.narrative, audience: opts.audience,
+            outcome: opts.outcome,
+            pillars: opts.pillars ? String(opts.pillars).split(",").map((p) => p.trim()) : [],
+          },
+          duration_months: Number(opts.months),
+          posts_per_week: Number(opts.perWeek),
+          format_mix: opts.format,
+          apply_tone_of_voice: opts.tone !== false,
+        }, ctx);
+        const id = r?.data?.strategy?.id ?? r?.strategy?.id;
+        if (opts.wait && id) {
+          for (let i = 0; i < 90; i++) {
+            await sleep(8000);
+            const p = await call("strategies", "resume", { id }, ctx);
+            const d = p?.data ?? p;
+            process.stderr.write(`  … ${d.progress?.done ?? 0}/${d.progress?.total ?? "?"} done\n`);
+            if (d.status === "ready" || d.status === "failed") break;
+          }
+          const final = await call("strategies", "get", { id, include_posts: false }, ctx);
+          return emit(this, final, (d) => process.stdout.write(`✓ ${d.strategy?.name} — ${d.strategy?.status}\n`));
+        }
+        emit(this, r, (d) => process.stdout.write(
+          `✓ Created strategy ${d.strategy?.id} (${d.total_posts ?? "?"} posts queued)\n  Run: advisoros strategy resume ${d.strategy?.id}\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("list"))
+    .description("List content strategies")
+    .option("--status <s>", "planning | generating | ready | failed | archived")
+    .option("--search <q>", "search by name")
+    .option("--limit <n>", "max rows", "25")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("strategies", "list", {
+          status: o.status, search: o.search, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "status", "posts", "wk", "name"],
+            (d.strategies || []).map((st) => [
+              truncate(st.id, 8), st.status, st.total_posts ?? "", st.posts_per_week ?? "",
+              truncate(st.name, 46),
+            ]),
+          ) + `\n${d.strategies?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("show <id>"))
+    .description("Show a strategy with its planned posts")
+    .option("--no-posts", "omit the post list")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("strategies", "get", { id, include_posts: opts.posts !== false }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const st = d.strategy || {};
+          process.stdout.write(`${st.name}  [${st.status}]\n${st.narrative ?? ""}\n\n`);
+          if (d.posts?.length) {
+            process.stdout.write(table(
+              ["#", "wk", "status", "format", "date", "hook"],
+              d.posts.map((p) => [p.position, p.week_no, p.status, p.format, p.planned_date ?? "", truncate(p.hook, 44)]),
+            ) + "\n");
+          }
+          if (d.progress) process.stdout.write(`\n${JSON.stringify(d.progress)}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("resume <id>"))
+    .description("Push the drafting queue along (repeat until status is ready)")
+    .option("--wait", "keep polling until done")
+    .action(async function (id, opts) {
+      try {
+        const ctx = ctxFrom(this);
+        let r = await call("strategies", "resume", { id }, ctx);
+        if (opts.wait) {
+          for (let i = 0; i < 90; i++) {
+            const d = r?.data ?? r;
+            if (d.status === "ready" || d.status === "failed") break;
+            process.stderr.write(`  … ${d.progress?.done ?? 0}/${d.progress?.total ?? "?"} done\n`);
+            await sleep(8000);
+            r = await call("strategies", "resume", { id }, ctx);
+          }
+        }
+        emit(this, r, (d) => process.stdout.write(`${d.status} — ${JSON.stringify(d.progress)}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("update <id>"))
+    .description("Patch a strategy")
+    .option("--name <n>")
+    .option("--narrative <text>")
+    .option("--audience <text>")
+    .option("--outcome <text>")
+    .option("--pillars <list>", "comma-separated")
+    .option("--status <s>", "planning | generating | ready | failed | archived")
+    .option("--campaign <id>", "link to a campaign")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("strategies", "update", {
+          id, name: opts.name, narrative: opts.narrative, audience: opts.audience,
+          outcome: opts.outcome, status: opts.status, campaign_id: opts.campaign,
+          pillars: opts.pillars ? String(opts.pillars).split(",").map((p) => p.trim()) : undefined,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.strategy?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("delete <id>"))
+    .description("Delete a strategy and its planned posts")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete strategy ${id} and every planned post. This cannot be undone.`);
+        const r = await call("strategies", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("posts <id>"))
+    .description("List the planned posts of a strategy")
+    .option("--status <s>", "queued | claimed | done | failed | skipped")
+    .option("--limit <n>", "max rows", "200")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("strategies", "posts", { id, status: o.status, limit: Number(o.limit) }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["post_id", "#", "wk", "status", "format", "date", "hook"],
+            (d.posts || []).map((p) => [
+              truncate(p.id, 8), p.position, p.week_no, p.status, p.format,
+              p.planned_date ?? "", truncate(p.hook, 38),
+            ]),
+          ) + `\n${JSON.stringify(d.progress)}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("post <postId>"))
+    .description("Show one planned post")
+    .action(async function (postId) {
+      try {
+        const r = await call("strategies", "get_post", { post_id: postId }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.post, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("update-post <postId>"))
+    .description("Patch a planned post before it is drafted")
+    .option("--pillar <p>")
+    .option("--hook <text>")
+    .option("--objective <text>")
+    .option("--title <text>", "title_seed")
+    .option("--brief <text>")
+    .option("--format <f>", "linkedin | blog")
+    .option("--date <YYYY-MM-DD>", "planned_date")
+    .option("--week <n>", "week_no")
+    .option("--status <s>", "queued | claimed | done | failed | skipped")
+    .action(async function (postId, opts) {
+      try {
+        const r = await call("strategies", "update_post", {
+          post_id: postId, pillar: opts.pillar, hook: opts.hook, objective: opts.objective,
+          title_seed: opts.title, brief: opts.brief, format: opts.format,
+          planned_date: opts.date, week_no: opts.week ? Number(opts.week) : undefined,
+          status: opts.status,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated post ${d.post?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("retry-post <postId>"))
+    .description("Re-queue a failed post for drafting")
+    .action(async function (postId) {
+      try {
+        const r = await call("strategies", "retry_post", { post_id: postId }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Re-queued ${d.post?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("delete-post <postId>"))
+    .description("Remove a planned post")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (postId) {
+      try {
+        await confirmDestructive(this, `Delete planned post ${postId}.`);
+        const r = await call("strategies", "delete_post", { post_id: postId }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
+}

package/src/commands/voice.mjs

@@ -0,0 +1,202 @@
+import { call } from "../api.mjs";
+import { emit, fail, ctxFrom, withCommonOpts, table, truncate, confirmDestructive } from "../ui.mjs";
+
+export function registerVoice(program) {
+  const v = program
+    .command("voice")
+    .alias("tone")
+    .description("Read, write and delete the workspace Tone of Voice (directive, samples, scores)");
+
+  withCommonOpts(v.command("show"))
+    .alias("get")
+    .description("Show the workspace tone of voice configuration")
+    .action(async function () {
+      try {
+        const r = await call("voice", "get", {}, ctxFrom(this));
+        emit(this, r, (d) => {
+          const t = d.voice || {};
+          process.stdout.write(
+            `Directive: ${t.has_directive ? "set" : "(none)"}${t.source ? `  [source: ${t.source}]` : ""}\n` +
+              `Applied by default: ${t.apply_by_default ? "yes" : "no"}\n` +
+              `Writing samples: ${t.style_reference_count}${t.primary_style_reference_id ? `  (pinned: ${t.primary_style_reference_id})` : ""}\n` +
+              (t.synced_at ? `Last synced: ${t.synced_at}\n` : "") +
+              (t.directive ? `\n${t.directive}\n` : ""),
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("set"))
+    .description("Write the tone of voice directive and/or the apply-by-default toggle")
+    .option("--directive <text>", "the tone of voice directive")
+    .option("--source <text>", "where the directive came from", undefined)
+    .option("--apply-default <yes|no>", "apply tone of voice to new content by default")
+    .action(async function (opts) {
+      try {
+        const params = { directive: opts.directive, source: opts.source };
+        if (opts.applyDefault !== undefined) {
+          params.apply_by_default = /^(y|yes|true|1|on)$/i.test(String(opts.applyDefault));
+        }
+        const r = await call("voice", "set", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `✓ Tone of voice updated (directive ${d.voice?.has_directive ? "set" : "empty"}, default ${d.voice?.apply_by_default ? "on" : "off"})\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("delete"))
+    .alias("clear")
+    .description("Delete the tone of voice directive")
+    .option("--with-references", "also unmark every writing sample")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (opts) {
+      try {
+        await confirmDestructive(this, "Delete this workspace's tone of voice directive.");
+        const r = await call("voice", "delete", { clear_references: !!opts.withReferences }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write("✓ Tone of voice cleared\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("sync"))
+    .description("Re-pull the directive from Business Build")
+    .option("--email <email>", "identity to resolve the client by")
+    .action(async function (opts) {
+      try {
+        const r = await call("voice", "sync", { email: opts.email }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `${d.voice?.has_directive ? "✓ Directive synced" : "No directive found"}\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  // ── writing samples (benchmark corpus) ──
+  withCommonOpts(v.command("references"))
+    .alias("samples")
+    .description("List the knowledge base items used as writing samples")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function (opts) {
+      try {
+        const r = await call("voice", "references", { limit: Number(opts.limit) }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          table(
+            ["id", "primary", "name", "category"],
+            (d.references || []).map((x) => [truncate(x.id, 8), x.is_primary ? "★" : "", truncate(x.name, 44), x.category ?? ""]),
+          ) + `\n${d.references?.length ?? 0} rows\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("add-reference <knowledgeItemId>"))
+    .description("Mark a knowledge base item as a writing sample")
+    .option("--primary", "also pin it as the benchmark sample")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("voice", "add_reference", { knowledge_item_id: id, set_primary: !!opts.primary }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write(`✓ ${id} is now a writing sample\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("remove-reference <knowledgeItemId>"))
+    .description("Unmark a writing sample")
+    .action(async function (id) {
+      try {
+        const r = await call("voice", "remove_reference", { knowledge_item_id: id }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write(`✓ ${id} removed from the writing samples\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("set-primary [knowledgeItemId]"))
+    .description("Pin (or clear, when no id is given) the benchmark writing sample")
+    .action(async function (id) {
+      try {
+        const r = await call("voice", "set_primary", { knowledge_item_id: id ?? null }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          d.primary_style_reference_id ? `✓ Pinned ${d.primary_style_reference_id}\n` : "✓ Benchmark unpinned\n",
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  // ── derived card + scoring ──
+  withCommonOpts(v.command("card"))
+    .description("Show the measured voice card (house rules + stylometric targets)")
+    .option("--rebuild", "rebuild it from the writing samples")
+    .action(async function (opts) {
+      try {
+        const r = await call("voice", "card", { rebuild: !!opts.rebuild }, ctxFrom(this));
+        emit(this, r, (d) => {
+          if (!d.card) return process.stdout.write("No voice card — add a writing sample first.\n");
+          process.stdout.write(
+            `Built: ${d.card.built_at}\nReferences: ${(d.card.reference_titles || []).join(", ")}\n\nRules:\n` +
+              (d.card.rules || []).map((x) => ` - ${x}`).join("\n") +
+              `\n\nTargets:\n` + (d.targets || []).map((x) => ` - ${x}`).join("\n") + "\n",
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("score"))
+    .description("Score a piece of writing against the workspace voice")
+    .option("--text <text>", "text to score")
+    .option("--content <id>", "content item to score")
+    .option("--reference <id>", "knowledge item to score against (defaults to the pinned sample)")
+    .option("--no-persist", "do not stamp the score onto the content item")
+    .action(async function (opts) {
+      try {
+        const r = await call("voice", "score", {
+          text: opts.text, content_item_id: opts.content,
+          reference_item_id: opts.reference, persist: opts.persist !== false,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `Match: ${d.report?.overall_score ?? d.overall_score ?? "?"}%\n${d.report?.rationale ?? d.rationale ?? ""}\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("redraft"))
+    .description("Rewrite a piece in the author's voice (returns text, saves nothing)")
+    .option("--text <text>", "text to rewrite")
+    .option("--content <id>", "content item to rewrite")
+    .action(async function (opts) {
+      try {
+        const r = await call("voice", "redraft", { text: opts.text, content_item_id: opts.content }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`${d.text ?? d.redraft ?? JSON.stringify(d)}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  // ── reports ──
+  withCommonOpts(v.command("reports"))
+    .description("List voice match reports")
+    .option("--content <id>", "only reports for this content item")
+    .option("--limit <n>", "max rows", "25")
+    .action(async function (opts) {
+      try {
+        const r = await call("voice", "reports", { content_item_id: opts.content, limit: Number(opts.limit) }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          table(
+            ["id", "score", "created", "subject"],
+            (d.reports || []).map((x) => [truncate(x.id, 8), x.overall_score, (x.created_at || "").slice(0, 16), truncate(x.subject_title, 40)]),
+          ) + `\n${d.reports?.length ?? 0} rows\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("report <id>"))
+    .description("Show one voice match report")
+    .action(async function (id) {
+      try {
+        const r = await call("voice", "get_report", { report_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.report, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("delete-report <id>"))
+    .description("Delete a voice match report")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete voice match report ${id}. This cannot be undone.`);
+        const r = await call("voice", "delete_report", { report_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
+}

package/src/index.mjs

@@ -1,4 +1,7 @@
+import { registerStrategies } from "./commands/strategies.mjs";
+import { registerVoice } from "./commands/voice.mjs";
 import { Command } from "commander";
+import { readFileSync } from "node:fs";
 import { registerAuth } from "./commands/auth.mjs";
 import {
   registerLeads, registerCampaigns, registerSequences,
@@ -10,17 +13,18 @@ import {
   registerCampaignAnalytics, registerAnalytics, registerSafety, registerCtas,
   registerNotifications, registerAudiences, registerNewsletter, registerVideo,
   registerWatchlist, registerMeetings, registerActivity, registerWorkspacesExtras,
-  registerExport, registerIntegrations,
+  registerExport, registerIntegrations, registerAudit,
 } from "./commands/insights.mjs";
 import { registerFlow } from "./commands/flow.mjs";
 import { registerVaultSync } from "./commands/knowledge-sync.mjs";
 
 const program = new Command();
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 
 program
   .name("advisoros")
   .description("AdvisorPro CLI — drive leads, campaigns, sequences and agents from your terminal.")
-  .version("0.7.0")
+  .version(pkg.version)
   .option("--json", "machine-readable JSON output (applies to all subcommands)")
   .option("--as-agent <name>", "caller identity sent as agent_name (audit label only)");
 
@@ -34,6 +38,8 @@ registerCalendar(program);
 registerKnowledge(program);
 registerSignals(program);
 registerPipelines(program);
+registerStrategies(program);
+registerVoice(program);
 registerAuthority(program);
 registerBriefs(program);
 registerAgents(program);
@@ -51,6 +57,7 @@ registerVideo(program);
 registerWatchlist(program);
 registerMeetings(program);
 registerActivity(program);
+registerAudit(program);
 registerWorkspacesExtras(program);
 registerExport(program);