@series-a/cli 0.22.3 → 0.23.1

package/CHANGELOG.md

@@ -4,6 +4,20 @@ 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.23.0 — Bulk lead upserts, named profiles, atomic mutations
+
+- `leads bulk_upsert` works at scale again. The database now enforces one lead per LinkedIn URL per workspace, so bulk imports update existing leads in place instead of failing with a Postgres conflict error. Repeated URLs inside a single request are collapsed, and leads without a LinkedIn URL stay separate records.
+- Named workspace profiles: `login -p <name>` stores a profile per workspace, and logging into a new workspace no longer silently re-points your `default` profile — you are warned and can opt in with `--set-default` (or skip the prompt with `--force`).
+- Workspace isolation on agent reads and mutations: `agents show <name>` and every agent mutation now resolve strictly inside the authenticated workspace, so same-named agents in other workspaces can never be returned or changed.
+- Every mutation returns JSON. `voice card --rebuild`, `intel-prompts resync` and watchlist toggles now return the changed record, the workspace id and an explicit success/error status instead of exiting silently.
+- Watchlist operations are atomic and de-duplicated by workspace + normalised name + type; removed items stay removed (suppressions) and are no longer reintroduced by automatic prompt sync, which now only reads active, approved, human-authored knowledge records.
+- `agents pipeline [name]` (alias `inspect`) exposes an agent's configuration, pipeline stages, blocking gates and advisory gates for inspection — defaults to the Content Creator Agent.
+- Content pipeline quality: signals are retrieved workspace-wide (drafts no longer report "0 signals" when teammates persisted them), signal sources are integrity-checked and quarantined when URL, title, publisher, text and summary disagree, publication dates and source authority are required before evidence is accepted, and alignment + evidence + citation checks must all complete before an article is eligible.
+- P0 watchlist topics are treated as highest research priority, not mandatory inclusion — all P0s are searched, only relevant ones are used, and searched/selected/excluded topics are recorded with scores and reasons.
+- Voice benchmarks are built from cleaned document structure (PDF page furniture, headers/footers and hard line wraps removed), so paragraph and heading metrics are realistic, and generation and scoring share the same benchmark and reference set.
+- Image generation failures now surface the real reason (model, input or storage error) in the app instead of a generic non-2xx message.
+
+
 ## 0.22.3 — Sales Navigator imports from the CLI
 
 - Import Sales Navigator lead lists straight from the CLI: `leads import-from sales_nav_url --url "<search-url>"` or `sales_nav_keywords --query "..."`. These queue as cap-aware background imports that drip-feed inside your LinkedIn read limits instead of blocking live campaigns.

package/package.json

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

package/src/commands/auth.mjs

@@ -1,14 +1,40 @@
 import prompts from "prompts";
 import chalk from "chalk";
-import { getProfile, setProfile, listProfiles, deleteProfile, CONFIG_PATH, DEFAULTS } from "../config.mjs";
+import { getProfile, setProfiles, listProfiles, deleteProfile, allProfiles, CONFIG_PATH, DEFAULTS } from "../config.mjs";
 import { call } from "../api.mjs";
 import { emit, fail, ctxFrom, withCommonOpts } from "../ui.mjs";
 
+/**
+ * Replacing the "default" profile silently re-points every unqualified command
+ * at another workspace. Always confirm first; in a non-interactive shell the
+ * caller must pass --force.
+ */
+async function confirmDefaultReplacement(workspace, opts, currentWorkspace) {
+  if (opts.force) return true;
+  if (!currentWorkspace) return true;
+  if (!process.stdin.isTTY) {
+    process.stdout.write(chalk.yellow(
+      `\n! Default profile currently points at workspace ${currentWorkspace}.\n` +
+      `  Not replacing it — re-run with --force to move it to ${workspace}.\n`,
+    ));
+    return false;
+  }
+  const r = await prompts({
+    type: "confirm",
+    name: "v",
+    message: `Replace the default profile (workspace ${currentWorkspace}) with ${workspace}?`,
+    initial: false,
+  });
+  return !!r.v;
+}
+
 export function registerAuth(program) {
   program
     .command("login")
     .description("Save an API key + workspace to ~/.advisoros/config.json")
-    .option("-p, --profile <name>", "profile name", "default")
+    .option("-p, --profile <name>", "profile name (defaults to the workspace id)")
+    .option("--set-default", "also point the \"default\" profile at this workspace", false)
+    .option("--force", "replace an existing default profile without asking", false)
     .option("--api-key <key>", "API key (otherwise prompted)")
     .option("--workspace <id>", "workspace id (otherwise prompted, unless --admin)")
     .option("--admin", "admin key login — verify cross-workspace, no workspace required", false)
@@ -50,7 +76,15 @@ export function registerAuth(program) {
             apiKey, baseUrl, agentName,
           });
           const count = verify?.pagination?.total ?? verify?.workspaces?.length ?? 0;
-          await setProfile(profile, { apiKey, baseUrl, admin: true, agentName, ...(opts.email ? { email: opts.email } : {}), ...(workspace ? { workspaceId: workspace } : {}) });
+          const adminData = { apiKey, baseUrl, admin: true, agentName, ...(opts.email ? { email: opts.email } : {}), ...(workspace ? { workspaceId: workspace } : {}) };
+          const adminName = profile || "admin";
+          const adminWrites = { [adminName]: adminData };
+          if (adminName !== "default" && (opts.setDefault || !(await getProfile("default")))) {
+            const okDefault = await confirmDefaultReplacement(workspace || "(admin)", opts);
+            if (okDefault) adminWrites.default = adminData;
+          }
+          await setProfiles(adminWrites, adminName);
+          profile = adminName;
           process.stdout.write(chalk.green(
             `\n✓ Logged in as admin profile "${profile}" — ${count} workspaces reachable\n` +
             `  Config: ${CONFIG_PATH}\n` +
@@ -64,11 +98,40 @@ export function registerAuth(program) {
           apiKey, workspaceId: workspace, baseUrl, agentName,
         });
         const count = verify?.agents?.length ?? 0;
-        await setProfile(profile, { apiKey, workspaceId: workspace, baseUrl, agentName, ...(opts.email ? { email: opts.email } : {}) });
+        // Named workspace profiles: without -p, the profile is named after the
+        // workspace so a second login can never silently overwrite the first.
+        const profileName = profile || workspace;
+        const data = { apiKey, workspaceId: workspace, baseUrl, agentName, ...(opts.email ? { email: opts.email } : {}) };
+        const writes = { [profileName]: data };
+
+        let defaultNote = "";
+        if (profileName !== "default") {
+          const existingDefault = await getProfile("default");
+          if (!existingDefault) {
+            writes.default = data;
+            defaultNote = `  Default profile set to workspace ${workspace}.\n`;
+          } else if (existingDefault.workspaceId === workspace) {
+            writes.default = data;
+          } else if (opts.setDefault || opts.force) {
+            const ok = await confirmDefaultReplacement(workspace, opts, existingDefault.workspaceId);
+            if (ok) {
+              writes.default = data;
+              defaultNote = `  Default profile moved from ${existingDefault.workspaceId} to ${workspace}.\n`;
+            } else {
+              defaultNote = `  Default profile left on workspace ${existingDefault.workspaceId}.\n`;
+            }
+          } else {
+            defaultNote =
+              `  Default profile still points at workspace ${existingDefault.workspaceId} — unchanged.\n` +
+              `  Use this workspace with: --profile ${profileName}   (or re-run login with --set-default)\n`;
+          }
+        }
+
+        await setProfiles(writes, profileName);
         process.stdout.write(chalk.green(
-          `\n✓ Logged in as profile "${profile}" — workspace ${workspace} (${count} agents visible)\n` +
+          `\n✓ Logged in as profile "${profileName}" — workspace ${workspace} (${count} agents visible)\n` +
           `  Config: ${CONFIG_PATH}\n`,
-        ));
+        ) + chalk.gray(defaultNote));
       } catch (e) { fail(e); }
     });
 
@@ -109,9 +172,14 @@ export function registerAuth(program) {
     .command("profiles")
     .description("List saved profiles")
     .action(async () => {
-      const ps = await listProfiles();
-      if (!ps.length) return process.stdout.write("(no profiles — run `advisoros login`)\n");
-      for (const name of ps) process.stdout.write(`- ${name}\n`);
+      const profiles = await allProfiles();
+      const names = Object.keys(profiles);
+      if (!names.length) return process.stdout.write("(no profiles — run `advisoros login`)\n");
+      for (const name of names) {
+        const p = profiles[name];
+        const scope = p?.admin ? "admin" : (p?.workspaceId || "(no workspace)");
+        process.stdout.write(`- ${name}  →  ${scope}\n`);
+      }
     });
 
   program

package/src/commands/insights.mjs

@@ -1298,7 +1298,9 @@ export function registerWatchlist(program) {
         if (o.on) body.is_active = true;
         if (o.off) body.is_active = false;
         const r = await call("watchlist", "toggle", body, ctxFrom(this));
-        emit(this, r, (d) => process.stdout.write(`✔ ${d.item?.name} → ${d.item?.is_active ? "active" : "inactive"}\n`));
+        emit(this, r, (d) => process.stdout.write(
+          `✔ ${d.item?.name ?? id} → ${d.item?.is_active ? "active" : "inactive"} (id ${d.item?.id ?? id}, workspace ${d.workspace_id || "?"}, ${d.status || "ok"})\n`,
+        ));
       } catch (e) { fail(e); }
     });
 
@@ -1316,7 +1318,10 @@ export function registerWatchlist(program) {
     .action(async function () {
       try {
         const r = await call("watchlist", "sync_prompts", {}, ctxFrom(this));
-        emit(this, r, () => process.stdout.write("✔ Prompts resynced\n"));
+        emit(this, r, (d) => process.stdout.write(
+          `✔ Prompts resynced — ${d.count ?? (d.prompts || []).length} prompt(s), workspace ${d.workspace_id || "?"} (${d.status || "ok"})\n` +
+          (d.prompts || []).map((x) => ` - ${x.prompt_type || x.type || x.id}`).join("\n") + "\n",
+        ));
       } catch (e) { fail(e); }
     });
 
@@ -1405,7 +1410,10 @@ export function registerIntelligencePrompts(program) {
     .action(async function () {
       try {
         const r = await call("intelligence_prompts", "resync", {}, ctxFrom(this));
-        emit(this, r, () => process.stdout.write("✔ Prompts resynced\n"));
+        emit(this, r, (d) => process.stdout.write(
+          `✔ Prompts resynced — ${d.count ?? (d.prompts || []).length} prompt(s), workspace ${d.workspace_id || "?"} (${d.status || "ok"})\n` +
+          (d.prompts || []).map((x) => ` - ${x.prompt_type || x.type || x.id}`).join("\n") + "\n",
+        ));
       } catch (e) { fail(e); }
     });
 }

package/src/commands/resources.mjs

@@ -1916,6 +1916,25 @@ export function registerAgents(program) {
       } catch (e) { fail(e); }
     });
 
+  withCommonOpts(a.command("pipeline [name]"))
+    .alias("inspect")
+    .description("Inspect an agent's configuration and content pipeline (default: Content Creator Agent)")
+    .action(async function (name) {
+      try {
+        const r = await call("agents", "pipeline", { agent_name: name || "Content Creator Agent" }, ctxFrom(this));
+        emit(this, r, (d) => {
+          if (!d.agent) { process.stdout.write(`${d.error || "Agent not found"}\n`); return; }
+          process.stdout.write(`${d.agent.name} — ${d.agent.status} (${d.agent.agent_type || "agent"})\n\n`);
+          process.stdout.write(table(
+            ["stage", "what it does"],
+            (d.pipeline?.stages || []).map((s) => [s.id, truncate(s.detail, 80)]),
+          ) + "\n");
+          process.stdout.write(`Blocking gates: ${(d.pipeline?.blocking_gates || []).join(", ")}\n`);
+          process.stdout.write(`Advisory gates: ${(d.pipeline?.advisory_gates || []).join(", ")}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
   withCommonOpts(a.command("runs"))
     .description("List recent agent runs in this workspace")
     .option("--agent <name>", "filter by agent_name")

package/src/commands/voice.mjs

@@ -124,11 +124,21 @@ export function registerVoice(program) {
       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");
+          if (!d.card) {
+            process.stdout.write(
+              `✖ ${d.error || "No voice card — add a writing sample first."}\n` +
+              `  workspace: ${d.workspace_id || "?"}  status: ${d.status || "error"}\n`,
+            );
+            process.exitCode = 1;
+            return;
+          }
           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",
+              `\n\nTargets:\n` + (d.targets || []).map((x) => ` - ${x}`).join("\n") +
+              `\n\nWorkspace: ${d.workspace_id || "?"}  ${d.rebuilt ? "rebuilt" : "cached"}  status: ${d.status || "ok"}` +
+              `\nReference ids: ${(d.reference_item_ids || []).join(", ") || "(none recorded)"}` +
+              (d.primary_reference_id ? `\nPrimary reference: ${d.primary_reference_id}` : "") + "\n",
           );
         });
       } catch (e) { fail(e); }

package/src/config.mjs

@@ -38,6 +38,32 @@ export async function setProfile(name, data) {
   await writeConfig(cfg);
 }
 
+/** Save several profiles in one write (e.g. "default" plus a workspace alias). */
+export async function setProfiles(entries, currentProfile) {
+  const cfg = await readConfig();
+  cfg.profiles = cfg.profiles ?? {};
+  for (const [name, data] of Object.entries(entries)) cfg.profiles[name] = data;
+  if (currentProfile) cfg.currentProfile = currentProfile;
+  await writeConfig(cfg);
+}
+
+/** All saved profiles with their data — used to detect overwrite collisions. */
+export async function allProfiles() {
+  const cfg = await readConfig();
+  return cfg.profiles ?? {};
+}
+
+/** The saved profile already pointing at this workspace, if any. */
+export async function findProfileByWorkspace(workspaceId) {
+  if (!workspaceId) return null;
+  const profiles = await allProfiles();
+  for (const [name, p] of Object.entries(profiles)) {
+    if (p?.workspaceId === workspaceId) return { name, profile: p };
+  }
+  return null;
+}
+
+
 export async function listProfiles() {
   const cfg = await readConfig();
   return Object.keys(cfg.profiles ?? {});