@audienti/cli 0.1.144 → 0.2.0-exora.1

package/bin/audienti-mcp.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../cli/mcp.mjs";

package/cli/account-intake-operations.mjs

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+const uuid = z.string().uuid();
+// JSON Schema counts Unicode code points. Domain validation and normalization stay
+// server-owned; z.string().max() would instead reject valid astral text by UTF-16 length.
+const bounded = maxLength => z.string().meta({ maxLength });
+const dateTime = () => z.string().meta({ format: 'date-time' });
+const identity = z.union([
+  z.object({ kind: z.literal('person'), provider: bounded(64), providerId: bounded(256) }).strict(),
+  z.object({ kind: z.literal('person'), provider: bounded(64), url: bounded(2048) }).strict(),
+]);
+const target = z.union([
+  z.object({ kind: z.literal('existing'), prospectId: uuid }).strict(),
+  z.object({ kind: z.literal('create'), identity, displayName: bounded(200).optional(), profileObservedAt: dateTime().nullable().optional() }).strict(),
+]);
+const payload = z.object({
+  direction: z.enum(['inbound', 'outbound']), conversationType: z.enum(['direct', 'public_thread']), occurredAt: dateTime(),
+  subject: bounded(512).nullable(), body: bounded(32000).nullable(),
+  participants: z.array(z.object({ role: z.enum(['sender', 'recipient', 'cc', 'bcc']), value: bounded(320) }).strict()).max(20).nullable(),
+}).strict();
+const item = z.object({ source: z.object({ provider: bounded(64), accountRef: bounded(200), itemId: bounded(256), threadId: bounded(256).nullable().optional() }).strict(), payload }).strict();
+const body = ({ workspaceId, prospectId, ...rest }) => rest;
+const root = a => `/workspaces/${a.workspaceId}/prospects/${a.prospectId}/conversation-evidence`;
+export const accountIntakeOperations = {
+  workspace_prospect_intake: { schema: z.object({ workspaceId: uuid.optional(), requestId: uuid, target, item }).strict(), method: 'POST', scoped: true, path: a => `/workspaces/${a.workspaceId}/prospects/intake`, body },
+  workspace_conversation_append: { schema: z.object({ workspaceId: uuid.optional(), prospectId: uuid, requestId: uuid, item }).strict(), method: 'POST', scoped: true, path: root, body },
+  workspace_conversation_list: { schema: z.object({ workspaceId: uuid.optional(), prospectId: uuid, cursor: uuid.optional(), limit: z.number().int().min(1).max(100).optional() }).strict(), method: 'GET', scoped: true,
+    path: a => { const q = new URLSearchParams(); for (const k of ['cursor', 'limit']) if (a[k] !== undefined) q.set(k, String(a[k])); return root(a) + (q.size ? '?' + q : ''); } },
+};

package/cli/account-intake.mjs

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { callWorkspace, configuration } from './workspaces.mjs';
+export async function accountIntakeCli(args) {
+  const flags = {}, positions = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]; if (arg === '--json') continue;
+    if (!arg.startsWith('--')) { positions.push(arg); continue; }
+    const key = arg.slice(2);
+    if (!['workspace', 'profile', 'file', 'cursor', 'limit'].includes(key) || Object.hasOwn(flags, key) || !args[i+1] || args[i+1].startsWith('--')) throw Error('Unknown, repeated or incomplete intake option.');
+    flags[key] = args[++i];
+  }
+  const intake = positions[1] === 'intake';
+  const command = intake ? 'intake' : positions[2];
+  if (positions[0] !== 'prospects' || (!intake && positions[1] !== 'conversation') || !['intake', 'append', 'list'].includes(command) || positions.length !== (intake ? 2 : 4)) throw Error('Use prospects intake or prospects conversation append|list PERSON --workspace ID.');
+  const allowed = ['workspace', 'profile', ...(command === 'list' ? ['cursor', 'limit'] : ['file'])];
+  if (Object.keys(flags).some(k => !allowed.includes(k))) throw Error('Option does not apply to this intake command.');
+  let input = {};
+  if (command !== 'list') {
+    if (!flags.file) throw Error('--file INPUT.json is required.');
+    let raw; try { raw = readFileSync(flags.file); } catch { throw Error('Could not read the intake input file.'); }
+    if (raw.length > 65536) throw Error('payload_too_large');
+    try { input = JSON.parse(raw.toString('utf8')); } catch { throw Error('validation_error'); }
+    if (!input || typeof input !== 'object' || Array.isArray(input) || ['workspaceId', 'prospectId'].some(k => Object.hasOwn(input, k))) throw Error('invalid_fields');
+  }
+  input.workspaceId = flags.workspace;
+  if (!intake) input.prospectId = positions[3];
+  if (flags.cursor !== undefined) input.cursor = flags.cursor;
+  if (flags.limit !== undefined) {
+    if (!/^\d+$/.test(flags.limit)) throw Error('invalid_fields');
+    input.limit = Number(flags.limit);
+  }
+  console.log(JSON.stringify(await callWorkspace({ intake: 'workspace_prospect_intake', append: 'workspace_conversation_append', list: 'workspace_conversation_list' }[command], input, configuration(flags.profile))));
+}

package/cli/account-replies.mjs

@@ -0,0 +1,35 @@
+import { readFileSync } from 'node:fs';
+import { callWorkspace, configuration } from './workspaces.mjs';
+export async function accountRepliesCli(args) {
+  const flags = {}, positions = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') continue;
+    if (!arg.startsWith('--')) { positions.push(arg); continue; }
+    const key = arg.slice(2);
+    if (!['workspace', 'profile', 'file', 'evidence', 'cursor', 'limit', 'history-cursor', 'history-limit', 'status'].includes(key) || Object.hasOwn(flags, key) || !args[i+1] || args[i+1].startsWith('--')) throw Error('Unknown, repeated or incomplete reply option.');
+    flags[key] = args[++i];
+  }
+  const command = positions[2];
+  if (positions[0] !== 'prospects' || positions[1] !== 'replies' || !['set', 'get', 'list'].includes(command) || positions.length !== 4) throw Error('Use prospects replies set|get|list PERSON --workspace ID.');
+  const allowed = ['workspace', 'profile', ...(command === 'set' ? ['file', 'evidence'] : command === 'get' ? ['evidence', 'history-cursor', 'history-limit'] : ['cursor', 'limit', 'status'])];
+  if (Object.keys(flags).some(k => !allowed.includes(k))) throw Error('Option does not apply to this reply command.');
+  if (command !== 'list' && !flags.evidence) throw Error('--evidence EVIDENCE is required.');
+  let input = {};
+  if (command === 'set') {
+    if (!flags.file) throw Error('--file INPUT.json is required.');
+    let raw; try { raw = readFileSync(flags.file); } catch { throw Error('Could not read the reply input file.'); }
+    if (raw.length > 65536) throw Error('payload_too_large');
+    try { input = JSON.parse(raw.toString('utf8')); } catch { throw Error('validation_error'); }
+    if (!input || typeof input !== 'object' || Array.isArray(input) || ['workspaceId', 'prospectId', 'evidenceId'].some(k => Object.hasOwn(input, k))) throw Error('invalid_fields');
+  }
+  input.workspaceId = flags.workspace;
+  input.prospectId = positions[3];
+  if (flags.evidence !== undefined) input.evidenceId = flags.evidence;
+  for (const [flag, key] of [['cursor', 'cursor'], ['history-cursor', 'historyCursor'], ['status', 'status']]) if (flags[flag] !== undefined) input[key] = flags[flag];
+  for (const [flag, key] of [['limit', 'limit'], ['history-limit', 'historyLimit']]) if (flags[flag] !== undefined) {
+    if (!/^\d+$/.test(flags[flag])) throw Error('invalid_fields');
+    input[key] = Number(flags[flag]);
+  }
+  console.log(JSON.stringify(await callWorkspace(`workspace_reply_${command}`, input, configuration(flags.profile))));
+}

package/cli/account-reply-operations.mjs

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+const uuid = z.string().uuid();
+const scope = { workspaceId: uuid.optional(), prospectId: uuid };
+const item = { ...scope, evidenceId: uuid };
+const status = z.enum(['needs_handling', 'handled', 'not_reply']);
+const outcome = z.enum(['response_recorded', 'closed_without_response', 'suppressed']);
+const limit = z.number().int().min(1).max(100);
+const root = a => `/workspaces/${a.workspaceId}/prospects/${a.prospectId}`;
+const detail = a => `${root(a)}/conversation-evidence/${a.evidenceId}/reply`;
+const query = (path, a, keys) => {
+  const q = new URLSearchParams();
+  for (const key of keys) if (a[key] !== undefined) q.set(key, String(a[key]));
+  return path + (q.size ? `?${q}` : '');
+};
+export const accountReplyOperations = {
+  workspace_reply_set: {
+    schema: z.object({ ...item, requestId: uuid, expectedVersion: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER), status,
+      outcome: outcome.nullable().describe("Null for needs_handling/not_reply; a handling outcome is required for handled."), reason: z.string().meta({ minLength: 1, maxLength: 2000 }).describe("Required trimmed NFC reason, 1–2000 codepoints. Interior control characters including newline and tab are rejected."), responseEvidenceId: uuid.nullable().describe("Required for response_recorded; null otherwise. Must identify matching outbound account evidence.") }).strict().describe("Explicit inbound classification. needs_handling/not_reply require null outcome and responseEvidenceId. handled requires an outcome; response_recorded requires matching outbound evidence, closed_without_response an explicit closure reason, and suppressed active DNC or Reject."),
+    method: 'POST', scoped: true, path: detail,
+    body: ({ workspaceId, prospectId, evidenceId, ...rest }) => rest,
+  },
+  workspace_reply_get: {
+    schema: z.object({ ...item, historyCursor: uuid.optional(), historyLimit: limit.optional() }).strict(),
+    method: 'GET', scoped: true, path: a => query(detail(a), a, ['historyCursor', 'historyLimit']),
+  },
+  workspace_reply_list: {
+    schema: z.object({ ...scope, cursor: uuid.optional(), limit: limit.optional(), status: status.optional() }).strict(),
+    method: 'GET', scoped: true, path: a => query(`${root(a)}/replies`, a, ['cursor', 'limit', 'status']),
+  },
+};

package/cli/agents.mjs

@@ -0,0 +1,107 @@
+import { readProfile, writeProfile, validateUrl, configuration, WorkspaceRequestError } from './workspaces.mjs';
+import { z } from 'zod';
+import {readJsonFile} from './json-file.mjs';
+
+export const agentManagementOperations = ['agent_list','agent_revoke','agent_permission','agent_capabilities_get','agent_capability_sharing_get','agent_capability_sharing_set','agent_account_authorizations_get','agent_account_authorization_set'];
+export const agentOperations = {
+ agent_account_authorizations_get:{schema:z.object({id:z.string().uuid()}).strict()},
+ agent_account_authorizations_show:{schema:z.object({}).strict()},
+ agent_account_authorization_set:{schema:z.object({id:z.string().uuid(),provider:z.enum(['email','linkedin']),accountRef:z.string().min(1).max(200),authorized:z.boolean()}).strict()},
+ agent_capability_sharing_get: {schema:z.object({id:z.string().uuid()}).strict()},
+ agent_capability_sharing_set: {schema:z.object({id:z.string().uuid(),provider:z.enum(['email','linkedin']),accountRef:z.string().min(1).max(200),workspaceId:z.string().uuid(),shared:z.boolean()}).strict()},
+ agent_capabilities_report: {schema:z.object({provider:z.enum(['email','linkedin']),accountRef:z.string().min(1).max(200),status:z.enum(['healthy','unavailable','disconnected']),accountIdentity:z.object({namespace:z.string(),accountId:z.string()}).strict().optional(),capabilities:z.array(z.object({capability:z.string(),tools:z.array(z.string()).min(1).max(8)}).strict()).max(16)}).strict()},
+ agent_capabilities_show: {schema:z.object({}).strict()},
+ agent_capabilities_get: {schema:z.object({id:z.string().uuid()}).strict()},
+ agent_permission: {schema:z.object({id:z.string().uuid(),scope:z.enum(['workspace:read','workspace:access'])}).strict()},
+ agent_connect: { schema: z.object({ name: z.string().trim().min(1).max(80) }).strict() },
+ agent_poll: { schema: z.object({}).strict() },
+ agent_cancel: { schema: z.object({}).strict() },
+ agent_list: { schema: z.object({}).strict() },
+ agent_revoke: { schema: z.object({ id: z.string().uuid() }).strict() },
+};
+async function request(config, path, body, authenticated = false, method = body === undefined ? 'GET' : 'POST') {
+ const url = validateUrl(config.url);
+ let response;
+ try { response = await fetch(new URL(`/api/v1${path}`, url), { method, headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...(authenticated ? { Authorization: `Bearer ${config.token ?? ''}` } : {}) }, ...(body === undefined ? {} : { body: JSON.stringify(body) }), redirect: 'error', signal: AbortSignal.timeout(10000) }); }
+ catch { throw new Error('Could not reach the API. Redirects are not followed.'); }
+ let result; try { result = await response.json(); } catch { throw new Error('The API returned an invalid response.'); }
+ if (!response.ok) {
+  const code = typeof result?.error?.code === 'string' && /^[a-z_]+$/.test(result.error.code) ? result.error.code : 'request_failed';
+  throw new WorkspaceRequestError(response.status, code, `Agent request failed: ${code} (HTTP ${response.status}).`);
+ }
+ if (!result || !Object.hasOwn(result, 'data')) throw new Error('The API returned an invalid response.');
+ return result.data;
+}
+export async function callAgent(name, args, config, profilePath) {
+ const input = agentOperations[name]?.schema.safeParse(args);
+ if (!input?.success) throw new Error('Invalid agent command or arguments.');
+ if (agentManagementOperations.includes(name) && (config.profile?.agent || config.profile?.pendingAgent)) throw new Error('Use a separate user management profile with an agents:manage token.');
+ if(name==='agent_account_authorizations_get') return {data:await request(config,`/agents/${input.data.id}/account-authorizations`,undefined,true)};
+ if(name==='agent_account_authorization_set') {const {id,...body}=input.data;return {data:await request(config,`/agents/${id}/account-authorizations`,body,true)};}
+ if(name==='agent_account_authorizations_show') {
+  if(!config.profile?.agent || !/^agt_/.test(config.token ?? '')) throw new Error('Use an active agent profile for authorization self readback.');
+  return {data:await request(config,'/agent-account-authorizations',undefined,true)};
+ }
+ if (name === 'agent_capability_sharing_get') return {data:await request(config,`/agents/${input.data.id}/capability-sharing`,undefined,true)};
+ if (name === 'agent_capability_sharing_set') {const {id,...body}=input.data;return {data:await request(config,`/agents/${id}/capability-sharing`,body,true)};}
+ if (name === 'agent_capabilities_get') return {data:await request(config,`/agents/${input.data.id}/capabilities`,undefined,true)};
+ if (name === 'agent_capabilities_show' || name === 'agent_capabilities_report') {
+  if (!config.profile?.agent || !/^agt_/.test(config.token ?? '')) throw new Error('Use an active agent profile for capability check-in and self readback.');
+  return {data:await request(config,'/agent-capabilities',name==='agent_capabilities_report' ? input.data : undefined,true,name==='agent_capabilities_report' ? 'PUT' : 'GET')};
+ }
+ if (name === 'agent_list') return { data: await request(config, '/agents', undefined, true) };
+ if (name === 'agent_permission') return {data:await request(config, `/agents/${input.data.id}/permission`, {scope:input.data.scope}, true)};
+ if (name === 'agent_revoke') return { data: await request(config, `/agents/${input.data.id}/revoke`, {}, true) };
+ if (!profilePath) throw new Error('Use a separate private --profile PATH for each agent.');
+ const profile = readProfile(profilePath);
+ const url = validateUrl(config.url).toString().replace(/\/$/, '');
+ if (name === 'agent_connect') {
+  if (profile.pendingAgent || profile.agent) throw new Error('This profile already has an agent connection. Poll/cancel the pending connection or choose a new profile.');
+  if (Object.keys(profile.tokens ?? {}).length) throw new Error('Use a new agent profile without user API tokens.');
+  // Prove that private persistence is possible before asking the server for secrets.
+  writeProfile(profilePath, { ...profile, url });
+  const data = await request(config, '/agent-connections', input.data);
+  if (!/^adc_[A-Za-z0-9_-]{43}$/.test(data.secret) || !/^agt_[A-Za-z0-9_-]{43}$/.test(data.credential) || !z.string().uuid().safeParse(data.id).success || !/^[A-F0-9]{4}-[A-F0-9]{4}$/.test(data.code)) throw new Error('Invalid connection response.');
+  writeProfile(profilePath, { ...profile, url, pendingAgent: { id: data.id, secret: data.secret, credential: data.credential, expiresAt: data.expiresAt } });
+  config.token = undefined; config.workspaceId = undefined;
+  return { data: { status: 'pending', id: data.id, code: data.code, approvalUrl: data.approvalUrl, approvalPath: `/agents/connect/${data.id}`, expiresAt: data.expiresAt, interval: 5, instructions: 'Open the approval URL, sign in, enter the matching code and approve. Then run agent poll with this profile.' } };
+ }
+ const secret = profile.pendingAgent?.secret ?? profile.connectionSecret;
+ if (!secret) throw new Error('No connection in this profile.');
+ if (url !== profile.url) throw new Error('The pending connection belongs to a different API host.');
+ const data = await request(config, name === 'agent_poll' ? '/agent-connections/poll' : '/agent-connections/cancel', { secret });
+ if (data.status === 'active') {
+  const credential = profile.pendingAgent?.credential ?? profile.tokens?.['workspace:read'];
+  writeProfile(profilePath, { ...profile, agent: data.agent, connectionSecret: secret, pendingAgent: undefined, tokens: { 'workspace:read': credential } });
+  config.token = credential;
+ } else if (['denied', 'expired'].includes(data.status)) { writeProfile(profilePath, { ...profile, pendingAgent: undefined, agent: undefined, connectionSecret: undefined, tokens: undefined, workspaceId: undefined }); config.token = undefined; config.workspaceId = undefined; }
+ return { data };
+}
+export async function agentCli(args) {
+ const flags = {}; const positions = [];
+ for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--json') continue;
+  if (args[i].startsWith('--')) {
+   const key = args[i].slice(2);
+   if (!['profile', 'name','scope','file','id','provider','account','workspace','shared','authorized'].includes(key) || !args[i+1] || args[i+1].startsWith('--')) throw new Error('Unknown or incomplete agent option.');
+   flags[key] = args[++i];
+  } else positions.push(args[i]);
+ }
+ let name = `agent_${positions[1]}`;
+ let input = positions[1] === 'permission' ? {id:positions[2],scope:flags.scope} : positions[1] === 'connect' ? { name: flags.name } : positions[1] === 'revoke' ? { id: positions[2] } : {};
+ if(positions[1]==='accounts') {
+  if(positions[2]==='show') {name=flags.id ? 'agent_account_authorizations_get' : 'agent_account_authorizations_show';input=flags.id ? {id:flags.id} : {};}
+  else if(positions[2]==='authorize' && ['true','false'].includes(flags.authorized)) {name='agent_account_authorization_set';input={id:flags.id,provider:flags.provider,accountRef:flags.account,authorized:flags.authorized==='true'};}
+  else throw new Error('Use agent accounts show [--id ID] or authorize --id ID --provider PROVIDER --account REF --authorized true|false.');
+ }
+ if (positions[1] === 'capabilities') {
+  if (positions[2] === 'sharing' && flags.id) {name='agent_capability_sharing_get';input={id:flags.id};}
+  else if (positions[2] === 'share' && flags.id && ['true','false'].includes(flags.shared)) {name='agent_capability_sharing_set';input={id:flags.id,provider:flags.provider,accountRef:flags.account,workspaceId:flags.workspace,shared:flags.shared==='true'};}
+  else if (positions[2] === 'report'  && flags.file && !flags.id) {name='agent_capabilities_report';input=readCapabilityFile(flags.file);}
+  else if (positions[2] === 'show' && !flags.file) {name=flags.id ? 'agent_capabilities_get' : 'agent_capabilities_show';input=flags.id ? {id:flags.id} : {};}
+  else throw new Error('Use agent capabilities report --file PATH or show [--id ID].');
+ }
+ console.log(JSON.stringify(await callAgent(name, input, configuration(flags.profile, agentManagementOperations.includes(name) ? 'agents:manage' : 'workspace:access'), flags.profile)));
+}
+
+function readCapabilityFile(path) {return readJsonFile(path,32768,'Capability file');}

package/cli/approach-operations.mjs

@@ -0,0 +1,12 @@
+import {z} from 'zod';
+const uuid=z.string().uuid(),scope={workspaceId:uuid.optional()},stage=z.object({key:uuid,name:z.string().trim().min(1).max(120)}).strict();
+const fields=z.object({name:z.string().trim().min(1).max(120),stages:z.array(stage).min(2).max(30),goalKey:uuid,offRamps:z.array(stage.extend({reason:z.enum(['rejected','not_fit','nurture','unresponsive','other'])})).max(30)}).strict();
+const base=a=>`/workspaces/${a.workspaceId}`,query=(a,skip=[])=>new URLSearchParams(Object.entries(a).filter(([k,v])=>k!=='workspaceId'&&!skip.includes(k)&&v!==undefined).map(([k,v])=>[k,String(v)]));
+export const approachOperations={
+ approach_list:{schema:z.object({...scope,cursor:uuid.optional(),limit:z.number().int().min(1).max(100).optional()}).strict(),method:'GET',path:a=>`${base(a)}/approaches?${query(a)}`,scoped:true,description:'List immutable versioned approaches in the current workspace. Free CRM read.'},
+ approach_get:{schema:z.object({...scope,id:uuid,revision:z.number().int().positive().optional()}).strict(),method:'GET',path:a=>`${base(a)}/approaches/${a.id}?${query(a,['id'])}`,scoped:true,description:'Read an approach version: stable stage keys, goal and terminal off-ramps.'},
+ approach_save:{schema:z.object({...scope,id:uuid.optional(),requestId:uuid,expectedRevision:z.number().int().nonnegative(),fields}).strict(),method:'POST',path:a=>`${base(a)}/approaches`,body:({workspaceId,...a})=>a,scoped:true,description:'Create or revise an approach with optimistic version and idempotent request. Does not change existing experiment or participation pins.'},
+ approach_progress_get:{schema:z.object({...scope,participationId:uuid}).strict(),method:'GET',path:a=>`${base(a)}/participations/${a.participationId}/progress`,scoped:true,description:'Read the participation’s admitted approach pin and recorded stage/outcome history.'},
+ approach_progress_record:{schema:z.object({...scope,participationId:uuid,expectedVersion:z.number().int().nonnegative(),requestId:uuid,stageKey:uuid.optional(),offRampKey:uuid.optional(),reason:z.string().trim().min(1).max(2000),evidence:z.array(z.object({kind:z.enum(['observation','conversation']),id:uuid}).strict()).max(20)}).strict(),method:'POST',path:a=>`${base(a)}/participations/${a.participationId}/progress`,body:({workspaceId,participationId,...a})=>a,scoped:true,description:'Record one forward stage or terminal off-ramp using stored evidence for this person. Assigned owner/Admin only. Goal ends prospecting; post-goal forward reporting never reactivates. No send or provider call.'},
+ workspace_analytics_get:{schema:z.object({...scope,experimentId:uuid.optional(),pinId:uuid.optional(),from:z.string().datetime(),to:z.string().datetime()}).strict(),method:'GET',path:a=>`${base(a)}/analytics?${query(a)}`,scoped:true,description:'Read UTC-period distinct outcomes and explicit stage events. Missing activity or cost attribution is not tracked, never fabricated zero. Maximum 366 days; narrow large scopes.'}
+};

package/cli/assignment-operations.mjs

@@ -0,0 +1,218 @@
+import { z } from "zod";
+const uuid = z.string().uuid();
+const workspace = { workspaceId: uuid.optional() };
+const request = { ...workspace, requestId: uuid };
+const version = z.number().int().nonnegative();
+const page = z
+  .object({
+    cursor: uuid.optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+  })
+  .strict();
+const location = z
+  .object({
+    key: z.string().nullable().optional(),
+    providerId: z.string().nullable().optional(),
+    name: z.string(),
+  })
+  .strict();
+const criteria = z
+  .object({
+    experimentIds: z.array(uuid).max(50).optional(),
+    companyLocations: z.array(location).max(50).optional(),
+    personLocations: z.array(location).max(50).optional(),
+    personTitles: z.array(z.string()).max(50).optional(),
+  })
+  .strict();
+const rule = z
+  .object({
+    id: uuid,
+    name: z.string(),
+    enabled: z.boolean(),
+    assigneeUserId: uuid,
+    criteria,
+  })
+  .strict();
+const root = (a) => `/workspaces/${a.workspaceId}`;
+const person = (a) => `${root(a)}/prospects/${a.prospectId}`;
+const omit = (a, keys) =>
+  Object.fromEntries(Object.entries(a).filter(([k]) => !keys.includes(k)));
+const body = (a) => omit(a, ["workspaceId", "prospectId"]);
+function qs(a, keys = ["workspaceId", "prospectId", "experimentId"]) {
+  const values = {};
+  for (const [k, v] of Object.entries(omit(a, keys))) {
+    if (v === undefined) continue;
+    if (typeof v === "object" && v !== null)
+      for (const [child, value] of Object.entries(v))
+        values[k + child[0].toUpperCase() + child.slice(1)] = String(value);
+    else values[k] = String(v);
+  }
+  return new URLSearchParams(values).toString();
+}
+export const assignmentOperations = {
+  workspace_prospect_assignments: {
+    schema: z
+      .object({
+        ...workspace,
+        assignedToUserId: uuid.optional(),
+        unassigned: z.boolean().optional(),
+        experimentId: uuid.optional(),
+        search: z.string().optional(),
+        cursor: uuid.optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+      })
+      .strict(),
+    method: "GET",
+    path: (a) => root(a) + "/assignments?" + qs(a, ["workspaceId"]),
+    scoped: true,
+  },
+  workspace_prospect_assignment: {
+    schema: z
+      .object({
+        ...workspace,
+        prospectId: uuid,
+        history: page.optional(),
+        participations: page.optional(),
+        participationEvents: page.optional(),
+        routingReports: page.optional(),
+      })
+      .strict(),
+    method: "GET",
+    path: (a) => person(a) + "/assignment?" + qs(a),
+    scoped: true,
+  },
+  workspace_prospect_experiment_fit: {
+    schema: z
+      .object({
+        ...workspace,
+        prospectId: uuid,
+        experimentId: uuid,
+        overrides: page.optional(),
+      })
+      .strict(),
+    method: "GET",
+    path: (a) => person(a) + `/experiments/${a.experimentId}/fit?` + qs(a),
+    scoped: true,
+  },
+  workspace_prospect_assignment_set: {
+    schema: z
+      .object({
+        ...request,
+        prospectId: uuid,
+        assigneeUserId: uuid.nullable(),
+        expectedAssignmentVersion: version,
+        reason: z.string(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => person(a) + "/assignment",
+    body,
+    scoped: true,
+  },
+  workspace_routing_rules_get: {
+    schema: z.object(workspace).strict(),
+    method: "GET",
+    path: (a) => root(a) + "/routing-rules",
+    scoped: true,
+  },
+  workspace_routing_rules_replace: {
+    schema: z
+      .object({
+        ...request,
+        expectedRulesVersion: version,
+        rules: z.array(rule).max(100),
+      })
+      .strict(),
+    method: "PUT",
+    path: (a) => root(a) + "/routing-rules",
+    body: (a) => omit(a, ["workspaceId"]),
+    scoped: true,
+  },
+  workspace_routing_apply: {
+    schema: z
+      .object({
+        ...request,
+        prospectId: uuid,
+        experimentId: uuid.optional(),
+        expectedAssignmentVersion: version,
+        rulesVersion: version,
+        outcomes: z
+          .array(
+            z
+              .object({
+                ruleId: uuid,
+                result: z.enum(["match", "no_match", "unknown"]),
+                reason: z.string().optional(),
+              })
+              .strict(),
+          )
+          .max(100),
+        skill: z.object({ id: z.string(), version: z.string() }).strict(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => person(a) + "/routing",
+    body,
+    scoped: true,
+  },
+  workspace_fit_override_set: {
+    schema: z
+      .object({
+        ...request,
+        prospectId: uuid,
+        experimentId: uuid,
+        experimentRevision: z.number().int().positive(),
+        expectedOverrideVersion: version,
+        action: z.enum(["set", "clear"]),
+        value: z.enum(["high", "moderate", "low", "no_fit"]).optional(),
+        reason: z.string(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => person(a) + "/fit-override",
+    body,
+    scoped: true,
+  },
+  workspace_prospect_move: {
+    schema: z
+      .object({
+        ...request,
+        prospectId: uuid,
+        expectedSourceParticipationId: uuid,
+        sourceExperimentId: uuid,
+        destinationExperimentId: uuid,
+        destinationExperimentRevision: z.number().int().positive(),
+        destinationQualificationReceiptId: uuid,
+        expectedAssignmentVersion: version,
+        reason: z.string(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => person(a) + "/move",
+    body,
+    scoped: true,
+  },
+  workspace_member_remove: {
+    schema: z
+      .object({
+        ...request,
+        expectedMembershipId: uuid,
+        memberUserId: uuid,
+        reason: z.string(),
+      })
+      .strict(),
+    method: "POST",
+    path: (a) => root(a) + "/members/remove",
+    body: (a) => omit(a, ["workspaceId"]),
+    scoped: true,
+  },
+  workspace_leave: {
+    schema: z
+      .object({ ...request, expectedMembershipId: uuid, reason: z.string() })
+      .strict(),
+    method: "POST",
+    path: (a) => root(a) + "/members/leave",
+    body: (a) => omit(a, ["workspaceId"]),
+    scoped: true,
+  },
+};

package/cli/assignment.mjs

@@ -0,0 +1,116 @@
+import { callWorkspace, configuration } from "./workspaces.mjs";
+import { readJsonFile } from "./json-file.mjs";
+export function isAssignmentCommand(args) {
+  return (
+    args[0] === "workspace" &&
+    (["assignments", "prospect", "routing-rules", "routing", "leave"].includes(
+      args[1],
+    ) ||
+      (args[1] === "member" && args[2] === "remove"))
+  );
+}
+export async function assignmentCli(args) {
+  const flags = {},
+    position = [];
+  const children = [
+    "history",
+    "participations",
+    "participation-events",
+    "routing-reports",
+    "overrides",
+  ];
+  const allowed = [
+    "profile",
+    "workspace",
+    "file",
+    "request-id",
+    "prospect-id",
+    "experiment-id",
+    "assigned-to-user-id",
+    "unassigned",
+    "search",
+    "cursor",
+    "limit",
+    ...children.flatMap((k) => [k + "-cursor", k + "-limit"]),
+  ];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--json") continue;
+    if (!args[i].startsWith("--")) {
+      position.push(args[i]);
+      continue;
+    }
+    const key = args[i].slice(2);
+    if (
+      !allowed.includes(key) ||
+      args[i + 1] === undefined ||
+      args[i + 1].startsWith("--") ||
+      Object.hasOwn(flags, key)
+    )
+      throw new Error("Unknown, repeated, or incomplete assignment option.");
+    flags[key] = args[++i];
+  }
+  const command = position.join(" ");
+  const names = {
+    "workspace assignments list": "workspace_prospect_assignments",
+    "workspace prospect assignment get": "workspace_prospect_assignment",
+    "workspace prospect assignment set": "workspace_prospect_assignment_set",
+    "workspace prospect experiment-fit get":
+      "workspace_prospect_experiment_fit",
+    "workspace routing-rules get": "workspace_routing_rules_get",
+    "workspace routing-rules replace": "workspace_routing_rules_replace",
+    "workspace routing apply": "workspace_routing_apply",
+    "workspace prospect fit-override set": "workspace_fit_override_set",
+    "workspace prospect fit-override clear": "workspace_fit_override_set",
+    "workspace prospect move": "workspace_prospect_move",
+    "workspace member remove": "workspace_member_remove",
+    "workspace leave": "workspace_leave",
+  };
+  const name = names[command];
+  if (!name)
+    throw new Error(
+      "Unknown assignment command. Use workspace assignments list, prospect assignment get/set, routing-rules get/replace, routing apply, prospect experiment-fit get, prospect fit-override set/clear, prospect move, member remove, or leave. Mutations require --file INPUT.json.",
+    );
+  const read = [
+    "workspace_prospect_assignments",
+    "workspace_prospect_assignment",
+    "workspace_prospect_experiment_fit",
+    "workspace_routing_rules_get",
+  ].includes(name);
+  let input = read ? {} : readJsonFile(flags.file, 65536, "Assignment file");
+  for (const [flag, key] of [
+    ["workspace", "workspaceId"],
+    ["request-id", "requestId"],
+    ["prospect-id", "prospectId"],
+    ["experiment-id", "experimentId"],
+    ["assigned-to-user-id", "assignedToUserId"],
+    ["search", "search"],
+    ["cursor", "cursor"],
+  ])
+    if (flags[flag] !== undefined) input[key] = flags[flag];
+  if (flags.limit !== undefined) input.limit = Number(flags.limit);
+  if (flags.unassigned !== undefined) {
+    if (!["true", "false"].includes(flags.unassigned))
+      throw new Error("--unassigned must be true or false.");
+    input.unassigned = flags.unassigned === "true";
+  }
+  for (const child of children) {
+    const cursor = flags[child + "-cursor"],
+      limit = flags[child + "-limit"];
+    if (cursor !== undefined || limit !== undefined)
+      input[child.replace(/-([a-z])/g, (_, c) => c.toUpperCase())] = {
+        ...(cursor === undefined ? {} : { cursor }),
+        ...(limit === undefined ? {} : { limit: Number(limit) }),
+      };
+  }
+  if (name === "workspace_fit_override_set") {
+    const action = position.at(-1);
+    if (input.action !== undefined && input.action !== action)
+      throw new Error("File action must match the command.");
+    input.action = action;
+  }
+  console.log(
+    JSON.stringify(
+      await callWorkspace(name, input, configuration(flags.profile)),
+    ),
+  );
+}

package/cli/audience-operations.mjs

@@ -0,0 +1,16 @@
+import {z} from 'zod';
+const uuid=z.string().uuid(),workspace={workspaceId:uuid.optional()},locator={...workspace,audienceId:uuid};
+const criterion=z.object({name:z.string(),providerId:z.string().nullable().optional(),negative:z.boolean().optional()}).strict();
+const location=criterion.extend({key:z.string().nullable().optional()}).strict();
+const strings=z.array(z.string()).optional(),criteria=z.array(criterion).optional(),locations=z.array(location).optional();
+const fields=z.object({name:z.string(),tags:strings,textCriteria:z.string().optional(),notes:z.string().optional(),discoveryKeyword:z.string().optional(),seniorityMatchMode:z.enum(['at_least','exact']).optional(),company:z.object({industries:criteria,industryGroups:strings,sizes:criteria,types:criteria,locations,keywords:z.object({include:strings,exclude:strings}).strict().optional()}).strict(),person:z.object({locations,currentTitles:criteria,pastTitles:criteria,seniorities:criteria,functions:criteria,bioPhrases:z.array(z.object({phrase:z.string(),negative:z.boolean().optional()}).strict()).optional(),allowedTitleExceptions:strings}).strict()}).strict();
+const path=a=>`/workspaces/${a.workspaceId}/audiences`;
+export const audienceOperations={
+ audience_options:{schema:z.object({...workspace,kind:z.enum(['industries','industry_groups','sizes','types','seniorities','titles','locations','functions']),q:z.string().max(200).optional()}).strict(),method:'GET',path:a=>`/workspaces/${a.workspaceId}/audience-options?`+new URLSearchParams({kind:a.kind,...(a.q!==undefined?{q:a.q}:{})}),scoped:true},
+ audience_list:{schema:z.object({...workspace,archived:z.boolean().optional(),limit:z.number().int().optional(),after:uuid.optional(),q:z.string().optional()}).strict(),method:'GET',path:a=>path(a)+'?'+new URLSearchParams(Object.fromEntries(Object.entries({archived:a.archived,limit:a.limit,after:a.after,q:a.q}).filter(([,v])=>v!==undefined).map(([k,v])=>[k,String(v)]))),scoped:true},
+ audience_get:{schema:z.object({...locator,revision:z.number().int().optional()}).strict(),method:'GET',path:a=>path(a)+`/${a.audienceId}`+(a.revision===undefined?'':`?revision=${a.revision}`),scoped:true},
+ audience_create:{schema:z.object({...workspace,requestId:uuid,fields}).strict(),method:'POST',path,body:a=>({requestId:a.requestId,fields:a.fields}),scoped:true},
+ audience_update:{schema:z.object({...locator,expectedRevision:z.number().int(),fields}).strict(),method:'POST',path:a=>path(a)+`/${a.audienceId}/revisions`,body:a=>({expectedRevision:a.expectedRevision,fields:a.fields}),scoped:true},
+ audience_archive:{schema:z.object(locator).strict(),method:'POST',path:a=>path(a)+`/${a.audienceId}/archive`,scoped:true},
+ audience_restore:{schema:z.object(locator).strict(),method:'POST',path:a=>path(a)+`/${a.audienceId}/restore`,scoped:true},
+};

package/cli/audiences.mjs

@@ -0,0 +1,26 @@
+import {callWorkspace,configuration} from './workspaces.mjs';
+import {readJsonFile} from './json-file.mjs';
+export async function audienceCli(args){
+ const position=[],flags={};for(let i=0;i<args.length;i++){
+  if(!args[i].startsWith('--')){position.push(args[i]);continue}
+  const key=args[i].slice(2);if(!['profile','workspace','file','request-id','expected-revision','revision','archived','limit','after','q','kind'].includes(key)||!args[i+1]||args[i+1].startsWith('--')||Object.hasOwn(flags,key))throw new Error('Unknown or incomplete audience option.');
+  flags[key]=args[++i];
+ }
+ const command=position[1],name={options:'audience_options',list:'audience_list',show:'audience_get',create:'audience_create',update:'audience_update',archive:'audience_archive',restore:'audience_restore'}[command];
+ if(!name||position.length!==(['list','create','options'].includes(command)?2:3))throw new Error('Use audience options --kind KIND [--q TEXT]|list|show ID|create|update ID|archive ID|restore ID.');
+ const input={workspaceId:flags.workspace};
+ if(position[2])input.audienceId=position[2];
+ if(command==='options'){input.kind=flags.kind;if(flags.q!==undefined)input.q=flags.q;}
+ if(command==='list'){
+  if(flags.archived!==undefined&&!['true','false'].includes(flags.archived))throw new Error('Archived must be true or false.');
+  if(flags.archived!==undefined)input.archived=flags.archived==='true';
+  if(flags.limit!==undefined)input.limit=Number(flags.limit);
+  if(flags.after)input.after=flags.after;
+  if(flags.q!==undefined)input.q=flags.q;
+ }
+ if(command==='show'&&flags.revision!==undefined)input.revision=Number(flags.revision);
+ if(['create','update'].includes(command)){if(!flags.file)throw new Error('Supply --file PATH containing Audience fields.');input.fields=readJsonFile(flags.file,65536,'Audience file');}
+ if(command==='create')input.requestId=flags['request-id'];
+ if(command==='update')input.expectedRevision=Number(flags['expected-revision']);
+ console.log(JSON.stringify(await callWorkspace(name,input,configuration(flags.profile))));
+}