@audienti/cli 0.2.0-exora.3 → 0.2.0-exora.30

package/cli/rooms.mjs

@@ -6,9 +6,9 @@ import {setTimeout as sleep} from 'node:timers/promises';
 import {callWorkspace,configuration} from './workspaces.mjs';
 import {readJsonFile} from './json-file.mjs';
 // Agent rooms client. Delivery is polled by the agent; nothing here opens a port.
-const valued=['profile','workspace','sort','since','about','limit','to','room','thread','body','body-file','file','answer-by','expires-at','request-id','with','slug','title','purpose','members','after','handle','exec','interval','timeout'];
-const switches=['retired','stop','once','json','unable','clear'];
-export const roomsUsage='Rooms: audienti rooms directory [--sort load] | inbox [--since ITEM] [--about TYPE:ID] [--limit N] | ack ITEM... | send (--to HANDLE|--room ROOM) [--thread ID] (--body TEXT|--body-file PATH|-) [--about TYPE:ID,...] [--answer-by ISO] [--expires-at ISO] [--unable] [--request-id UUID] | note (--body TEXT|--body-file PATH|-|--clear) | thread ID [--after N] | threads --about TYPE:ID | create (--with HANDLE | --slug S --title T [--purpose P] [--members a,b]) | list [--retired] | retire ROOM | restore ROOM | redact MESSAGE | resume THREAD | pause on|off | profile AGENT_ID [--handle H] [--about TEXT] | hook [--stop] | watch --exec CMD [--interval SECONDS] [--once] | wait --thread ID [--timeout SECONDS]';
+const valued=['profile','workspace','sort','since','about','limit','to','room','thread','body','body-file','file','answer-by','expires-at','request-id','with','slug','title','purpose','members','after','q','handle','exec','interval','timeout','question','options','deciders','rule','deadline','default','if-no-answer','supersedes','summary','due','for','status','note','goal','state','next-action','open-items','risks','action','stance','option','reason','question-id','kind','name'];
+const switches=['retired','stop','once','json','unable','clear','brief','any-one'];
+export const roomsUsage='Rooms: audienti rooms directory [--sort load] | inbox [--since ITEM] [--about TYPE:ID] [--limit N] [--brief] | ack ITEM... | send (--to HANDLE|--room ROOM) [--thread ID] (--body TEXT|--body-file PATH|-) [--about TYPE:ID,...] [--answer-by ISO [--if-no-answer TEXT] [--any-one]] [--expires-at ISO] [--unable] [--request-id UUID] | note (--body TEXT|--body-file PATH|-|--clear) | thread ID [--after N] | threads --about TYPE:ID | create (--with HANDLE | --slug S --title T [--purpose P] [--members a,b]) | list [--retired] [--q TEXT] | read ROOM [--q TEXT] | retire ROOM | restore ROOM | redact MESSAGE | resume THREAD | pause on|off | profile AGENT_ID [--handle H] [--about TEXT] | request-decision --question T --options A|B[|C] --deciders h1,h2 --rule one|any|all|majority --deadline ISO [--default OPTION] [--if-no-answer T] [--supersedes ID] [--room R|--thread ID] | respond DECISION --stance support|object|abstain [--option O] --reason T | withdraw DECISION | commit --summary T [--due ISO] [--for HANDLE] [--room R|--thread ID] | commit-update COMMITMENT --status done|released [--note T] | handoff COMMITMENT (--to HANDLE|--any-one) --goal T --state T --next-action T [--open-items a|b] [--risks a|b] [--answer-by ISO] | handoff-reply COMMITMENT --action accept|decline [--note T] | claim MESSAGE | ask-owner --question-id ID [--room R|--thread ID] [--answer-by ISO] [--if-no-answer T] | owner-create (--kind direct --members a,b[,c] | --kind group --name N [--purpose P] --members a,b) | owner-post ROOM [--thread ID] --body TEXT | member-add ROOM AGENT_ID | hook [--stop] | watch --exec CMD [--interval SECONDS] [--once] | wait --thread ID [--timeout SECONDS]';
 export const WATCH_MIN_INTERVAL=60,WAIT_MAX_TIMEOUT=900,WAIT_POLL=30,HOOK_CACHE=60;
 function parse(args){
  const position=[],flags={};
@@ -29,6 +29,10 @@ const references=value=>value===undefined?undefined:value.split(',').map(entry=>
  const type=entry.slice(0,at),rest=entry.slice(at+1);
  return type==='url'?{type,url:rest,title:rest}:{type,id:rest};
 });
+const list=(value,separator)=>value===undefined?undefined:value.split(separator).map(item=>item.trim()).filter(Boolean);
+const pick=(flags,pairs)=>Object.fromEntries(pairs.filter(([flag])=>flags[flag]!==undefined).map(([flag,key])=>[key,flags[flag]]));
+const placeOf=flags=>({...(flags.room?{room:flags.room}:{}),...(flags.thread?{threadId:flags.thread}:{})});
+const requestId=flags=>flags['request-id']??randomUUID();
 function messageBody(flags,rest){
  const sources=[flags.body!==undefined,flags['body-file']!==undefined,rest[0]==='-'].filter(Boolean).length;
  if(sources!==1)throw new Error('Supply exactly one of --body TEXT, --body-file PATH or - for standard input.');
@@ -51,7 +55,7 @@ async function hook(flags,now=Date.now()){
  const path=statePath(flags),state=readState(path);
  let items=state.items;
  if(!items||!state.checkedAt||now-state.checkedAt>=HOOK_CACHE*1000){
-  try{items=(await call('rooms_inbox',{limit:20},flags)).data.items.map(i=>({id:i.id,reason:i.reason,overdue:i.overdue,answerBy:i.answerBy,message:{threadId:i.message.threadId,from:{handle:i.message.from.handle}}}))}catch{return}
+  try{items=(await call('rooms_inbox',{limit:20,brief:true},flags)).data.items.map(i=>({id:i.id,reason:i.reason,overdue:i.overdue,answerBy:i.answerBy,message:{threadId:i.message.threadId,from:{handle:i.message.from.handle}}}))}catch{return}
   Object.assign(state,{checkedAt:now,items});
  }
  if(flags.stop){
@@ -102,7 +106,7 @@ export async function roomsCli(args){
  const need=(count,text)=>{if(rest.length!==count)throw new Error(`Use audienti rooms ${text}.`)};
  switch(command){
   case 'directory':need(0,'directory [--sort load]');return print(await call('rooms_directory',{...(flags.sort?{sort:flags.sort}:{})},flags));
-  case 'inbox':need(0,'inbox');return print(await call('rooms_inbox',{...(flags.since?{since:flags.since}:{}),...(flags.about?{about:flags.about}:{}),...(flags.limit?{limit:integer(flags.limit,'Limit')}:{})},flags));
+  case 'inbox':need(0,'inbox');return print(await call('rooms_inbox',{...(flags.since?{since:flags.since}:{}),...(flags.about?{about:flags.about}:{}),...(flags.limit?{limit:integer(flags.limit,'Limit')}:{}),...(flags.brief?{brief:true}:{})},flags));
   case 'ack':if(!rest.length)throw new Error('Use audienti rooms ack ITEM....');return print(await call('rooms_ack',{ids:rest},flags));
   case 'send':{
    if(rest.length>1||(rest.length===1&&rest[0]!=='-'))throw new Error('Use audienti rooms send (--to HANDLE|--room ROOM) --body TEXT.');
@@ -111,6 +115,8 @@ export async function roomsCli(args){
    for(const [flag,key] of [['to','to'],['room','room'],['thread','threadId'],['answer-by','answerBy'],['expires-at','expiresAt']])if(flags[flag]!==undefined)input[key]=flags[flag];
    if(flags.about)input.about=references(flags.about);
    if(flags.unable)input.unable=true;
+   if(flags['if-no-answer']!==undefined)input.ifNoAnswer=flags['if-no-answer'];
+   if(flags['any-one'])input.anyOne=true;
    return print(await call('rooms_send',input,flags));
   }
   case 'note':{
@@ -120,12 +126,32 @@ export async function roomsCli(args){
   case 'thread':need(1,'thread ID [--after N]');return print(await call('rooms_thread',{threadId:rest[0],...(flags.after?{after:integer(flags.after,'After')}:{})},flags));
   case 'threads':need(0,'threads --about TYPE:ID');return print(await call('rooms_threads',{about:flags.about},flags));
   case 'create':need(0,'create (--with HANDLE | --slug S --title T)');return print(await call('rooms_create',flags.with?{kind:'direct',with:flags.with}:{kind:'group',slug:flags.slug,title:flags.title,...(flags.purpose?{purpose:flags.purpose}:{}),...(flags.members?{members:flags.members.split(',')}:{})},flags));
-  case 'list':need(0,'list [--retired]');return print(await call('rooms_list',{...(flags.retired?{retired:true}:{})},flags));
+  case 'list':need(0,'list [--retired] [--q TEXT]');return print(await call('rooms_list',{...(flags.retired?{retired:true}:{}),...(flags.q!==undefined?{q:flags.q}:{})},flags));
+  case 'read':need(1,'read ROOM [--q TEXT]');return print(await call('rooms_read',{room:rest[0],...(flags.q!==undefined?{q:flags.q}:{})},flags));
   case 'retire':case 'restore':need(1,`${command} ROOM`);return print(await call(`rooms_${command}`,{room:rest[0]},flags));
   case 'redact':need(1,'redact MESSAGE');return print(await call('rooms_redact',{messageId:rest[0]},flags));
   case 'resume':need(1,'resume THREAD');return print(await call('rooms_resume',{threadId:rest[0]},flags));
   case 'pause':if(rest.length!==1||!['on','off'].includes(rest[0]))throw new Error('Use audienti rooms pause on|off.');return print(await call('rooms_pause',{paused:rest[0]==='on'},flags));
   case 'profile':need(1,'profile AGENT_ID [--handle H] [--about TEXT]');return print(await call('rooms_profile_set',{agentId:rest[0],...(flags.handle?{handle:flags.handle}:{}),...(flags.about!==undefined?{about:flags.about}:{})},flags));
+  case 'request-decision':{
+   need(0,'request-decision --question T --options A|B --deciders h1,h2 --rule one --deadline ISO');
+   return print(await call('rooms_decision_request',{...placeOf(flags),question:flags.question,options:list(flags.options,'|'),deciders:list(flags.deciders,','),rule:flags.rule,deadline:flags.deadline,...pick(flags,[['default','defaultOption'],['if-no-answer','ifNoAnswer'],['supersedes','supersedes']]),...(flags.about?{about:references(flags.about)}:{}),requestId:requestId(flags)},flags));
+  }
+  case 'respond':need(1,'respond DECISION --stance support|object|abstain --reason T');return print(await call('rooms_decision_respond',{decisionId:rest[0],stance:flags.stance,reason:flags.reason,...pick(flags,[['option','option']]),requestId:requestId(flags)},flags));
+  case 'withdraw':need(1,'withdraw DECISION');return print(await call('rooms_decision_withdraw',{decisionId:rest[0]},flags));
+  case 'commit':need(0,'commit --summary T');return print(await call('rooms_commit',{...placeOf(flags),summary:flags.summary,...pick(flags,[['due','dueAt'],['for','for']]),...(flags.about?{about:references(flags.about)}:{}),requestId:requestId(flags)},flags));
+  case 'commit-update':need(1,'commit-update COMMITMENT --status done|released');return print(await call('rooms_commit_update',{commitmentId:rest[0],status:flags.status,...pick(flags,[['note','note']]),requestId:requestId(flags)},flags));
+  case 'handoff':{
+   need(1,'handoff COMMITMENT (--to HANDLE|--any-one) --goal T --state T --next-action T');
+   const note={goal:flags.goal,state:flags.state,nextAction:flags['next-action'],...(flags['open-items']?{openItems:list(flags['open-items'],'|')}:{}),...(flags.risks?{risks:list(flags.risks,'|')}:{})};
+   return print(await call('rooms_handoff',{commitmentId:rest[0],...(flags.to?{to:flags.to}:{}),...(flags['any-one']?{anyOne:true}:{}),note,...pick(flags,[['answer-by','answerBy']]),...(flags.about?{about:references(flags.about)}:{}),requestId:requestId(flags)},flags));
+  }
+  case 'handoff-reply':need(1,'handoff-reply COMMITMENT --action accept|decline');return print(await call('rooms_handoff_reply',{commitmentId:rest[0],action:flags.action,...pick(flags,[['note','note']]),requestId:requestId(flags)},flags));
+  case 'claim':need(1,'claim MESSAGE');return print(await call('rooms_claim',{messageId:rest[0],requestId:requestId(flags)},flags));
+  case 'ask-owner':need(0,'ask-owner --question-id ID');return print(await call('rooms_ask_owner',{...placeOf(flags),questionId:flags['question-id'],...pick(flags,[['answer-by','answerBy'],['if-no-answer','ifNoAnswer']]),requestId:requestId(flags)},flags));
+  case 'owner-create':need(0,'owner-create --kind direct|group --members a,b');return print(await call('rooms_owner_create',{kind:flags.kind,members:list(flags.members,','),...pick(flags,[['name','name'],['purpose','purpose']])},flags));
+  case 'owner-post':need(1,'owner-post ROOM --body TEXT');return print(await call('rooms_owner_post',{room:rest[0],...(flags.thread?{threadId:flags.thread}:{}),body:flags.body,requestId:requestId(flags)},flags));
+  case 'member-add':need(2,'member-add ROOM AGENT_ID');return print(await call('rooms_member_add',{room:rest[0],agentId:rest[1]},flags));
   case 'hook':need(0,'hook [--stop]');return hook(flags);
   case 'watch':need(0,'watch --exec CMD');return watch(flags);
   case 'wait':need(0,'wait --thread ID');return wait(flags);

package/cli/secret-operations.mjs

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+const workspace = { workspaceId: z.string().uuid().optional() };
+export const secretName = z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/, 'A secret name uses capital letters, digits and underscores, for example HUBSPOT_TOKEN.');
+export const secretOperations = {
+ workspace_secret_list: { schema: z.object(workspace).strict(), method: 'GET', path: a => `/workspaces/${a.workspaceId}/secrets`, scoped: true, description: 'List the names of the secrets in the workspace Vault. Names only, never values. Use workspace_secret_get for one value.' },
+ workspace_secret_get: { schema: z.object({ ...workspace, name: secretName }).strict(), method: 'GET', path: a => `/workspaces/${a.workspaceId}/secrets/${encodeURIComponent(a.name)}`, scoped: true, description: 'Get one secret by name from the workspace Vault (for example HUBSPOT_TOKEN). Every agent in the workspace can read every secret and reading is free. Each read records who read it last and when. Use the value for the task only: never print it, paste it into a message or save it to a file.' },
+};

package/cli/secrets.mjs

@@ -0,0 +1,30 @@
+import { callWorkspace, configuration } from './workspaces.mjs';
+
+/** secret get NAME prints the value alone (so $(audienti secret get NAME) works); secret list prints names. --json prints the API answer. */
+export async function secretsCli(args) {
+ const flags = {}, positions = [];
+ let json = false;
+ for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === '--json') { json = true; continue; }
+  if (!arg.startsWith('--')) { positions.push(arg); continue; }
+  const key = arg.slice(2);
+  if (!['workspace', 'profile'].includes(key) || Object.hasOwn(flags, key) || i + 1 >= args.length) throw Error(`Invalid flag --${key}.`);
+  flags[key] = args[++i];
+ }
+ const usage = 'Use secret list [--workspace ID] or secret get NAME [--workspace ID] [--json].';
+ if (positions[0] !== 'secret' && positions[0] !== 'secrets') throw Error(usage);
+ const input = { workspaceId: flags.workspace }, config = configuration(flags.profile);
+ if (positions[1] === 'list' && positions.length === 2) {
+  const result = await callWorkspace('workspace_secret_list', input, config);
+  if (json) { console.log(JSON.stringify(result)); return; }
+  for (const secret of result.data.secrets) console.log(secret.name);
+  return;
+ }
+ if (positions[1] === 'get' && positions.length === 3) {
+  const result = await callWorkspace('workspace_secret_get', { ...input, name: positions[2] }, config);
+  if (json) console.log(JSON.stringify(result)); else console.log(result.data.value);
+  return;
+ }
+ throw Error(usage);
+}

package/cli/sender-account-operations.mjs

@@ -5,20 +5,25 @@ const base={requestId:uuid,reason:text(1,2000).describe('Trimmed NFC; no control
 const alias={provider:z.enum(['email','linkedin']),accountRef:text(1,200).regex(/^[A-Za-z0-9@._:+\/-]+$/),expectedAliasVersion:version};
 const identity=z.object({namespace:text(1,64).describe('Discovery namespace: trimmed and lowercased.'),accountId:text(1,256).describe('Trimmed printable ASCII provider identity; case-sensitive assertion, not verification.')}).strict();
 const actionType=z.enum(['email.send','linkedin.send']);
+const capability=z.enum(['profile.read','profile.connection.request','profile.connection.withdraw','profile.follow','profile.message.send','profile.inmail.send','profile.inbox.read','people.search','post.comment','post.react','post.publish','profile.visit','profile.views.read']).describe('Account action. Audienti gates profile.connection.request, profile.connection.withdraw and profile.message.send at send time; the agent follows the user\'s mode for the others. Email accounts have profile.message.send and inbox.read.');
+const useIn=z.object({allWorkspaces:z.boolean(),workspaceIds:z.array(uuid).max(200)}).strict().describe('Where the account is used: all of the user\'s workspaces, or only the listed ones. Left out, a new account is used in all of them and an account approved before keeps its workspaces. Approving an unbound account again starts over: the workspaces you choose replace the old ones. An account still approved elsewhere only gains workspaces.');
 const pageLimit=z.number().int().min(1).max(100).optional();
 const query=a=>{const q=new URLSearchParams(Object.entries(a).map(([k,v])=>[k,String(v)]));return q.size?'?'+q:'';};
 const path=a=>`/sender-accounts/${encodeURIComponent(a.senderAccountId)}`;
-const body=a=>Object.fromEntries(Object.entries(a).filter(([key])=>!['senderAccountId','actionType'].includes(key)));
+const body=a=>Object.fromEntries(Object.entries(a).filter(([key])=>!['senderAccountId','actionType','capability'].includes(key)));
 const opaque=z.string().trim().min(1).max(256).regex(/^[ -~]+$/);
 export const senderAccountOperations={
  sender_activity_report:{schema:z.object({...base,senderAccountId:uuid,sourceEventId:opaque,namespace:identity.shape.namespace,occurredAt:z.iso.datetime({offset:true}),providerMessageId:opaque.nullable(),relatedAttemptId:uuid.nullable()}).strict(),method:'POST',path:a=>path(a)+'/activity',body},
  sender_alias_get:{schema:z.object({provider:alias.provider,accountRef:alias.accountRef}).strict(),method:'GET',path:a=>'/sender-accounts/alias'+query(a),ownerOnly:true},
  sender_accounts_list:{schema:z.object({cursor:uuid.optional(),limit:pageLimit}).strict(),method:'GET',path:a=>'/sender-accounts'+query(a)},
- sender_account_get:{schema:z.object({senderAccountId:uuid,aliasesCursor:text(1,1024).optional(),aliasesLimit:pageLimit,historyCursor:uuid.optional(),historyLimit:pageLimit}).strict(),method:'GET',path:a=>path(a)+query(body(a))},
- sender_account_register:{schema:z.object({...base,...alias,agentId:uuid,accountIdentity:identity}).strict(),method:'POST',path:()=>'/sender-accounts',ownerOnly:true},
+ sender_account_get:{schema:z.object({senderAccountId:uuid,aliasesCursor:text(1,1024).optional(),aliasesLimit:pageLimit,historyCursor:uuid.optional(),historyLimit:pageLimit}).strict(),method:'GET',path:a=>path(a)+query(body(a)),description:'Reads one sending account: its bound names and useIn (allWorkspaces and the workspaces, id and name, it is used in; only workspaces its user belongs to).'},
+ sender_account_register:{schema:z.object({...base,...alias,agentId:uuid,accountIdentity:identity,useIn:useIn.optional()}).strict(),method:'POST',path:()=>'/sender-accounts',ownerOnly:true},
  sender_alias_bind:{schema:z.object({...base,...alias,senderAccountId:uuid,agentId:uuid}).strict(),method:'POST',path:a=>path(a)+'/aliases',body,ownerOnly:true},
  sender_alias_unbind:{schema:z.object({...base,...alias,senderAccountId:uuid}).strict(),method:'POST',path:a=>path(a)+'/aliases/unbind',body,ownerOnly:true},
  sender_account_state_set:{schema:z.object({...base,senderAccountId:uuid,expectedVersion:version,state:z.enum(['active','retired'])}).strict(),method:'POST',path:a=>path(a)+'/lifecycle',body,ownerOnly:true},
+ sender_account_workspaces_set:{schema:z.object({...base,senderAccountId:uuid,useIn:useIn.describe('Where the account is used from now on, replacing the earlier choice: allWorkspaces true with an empty workspaceIds for all of the user\'s workspaces, or allWorkspaces false with at least one workspace id the user belongs to.')}).strict(),method:'POST',path:a=>path(a)+'/workspaces',body,ownerOnly:true,description:'Changes where an approved sending account is used: all of the user\'s workspaces, or only the listed ones, each a workspace the user belongs to. Replaces the earlier choice. The answer carries useIn, the same shape sender_account_get gives.'},
  sender_automation_get:{schema:z.object({senderAccountId:uuid,actionType}).strict(),method:'GET',path:a=>path(a)+'/automation/'+encodeURIComponent(a.actionType)},
  sender_automation_set:{schema:z.object({...base,senderAccountId:uuid,actionType,expectedVersion:version,enabled:z.boolean()}).strict(),method:'POST',path:a=>path(a)+'/automation/'+encodeURIComponent(a.actionType),body,ownerOnly:true},
+ sender_action_modes_get:{schema:z.object({senderAccountId:uuid}).strict(),method:'GET',path:a=>path(a)+'/action-modes'},
+ sender_action_mode_set:{schema:z.object({...base,senderAccountId:uuid,capability,expectedVersion:version,mode:z.enum(['not_allowed','approval','automatic']).describe('not_allowed is Off: the agent may not do this, and the action is blocked even when approved. approval is Draft for approval: the agent does the prep and writes it; a person approves, edits or rejects it, and it needs an exact approval before it is sent. automatic is Automatic: the agent does it and sends it, so only the approval card is skipped.')}).strict(),method:'POST',path:a=>path(a)+'/action-modes/'+encodeURIComponent(a.capability),body,ownerOnly:true},
 };

package/cli/sender-accounts.mjs

@@ -1,23 +1,33 @@
 import {senderAccountOperations} from './sender-account-operations.mjs';
 import {callOwnerAccountOperation} from './owner-account-client.mjs';
 import {readJsonFile} from './json-file.mjs';
-import {WorkspaceRequestError} from './workspaces.mjs';
+import {WorkspaceRequestError,callWorkspace,configuration} from './workspaces.mjs';
 export async function callSenderAccounts(name,args,profilePath){
- return callOwnerAccountOperation(senderAccountOperations[name],args,profilePath,'sender account');
+ return callOwnerAccountOperation(senderAccountOperations[name],args,profilePath,'sender account',true);
 }
 export async function senderAccountsCli(args){
- const flags={},positions=[];const known=['profile','file','cursor','limit','aliases-cursor','aliases-limit','history-cursor','history-limit','action-type','provider','account-ref'];
+ const flags={},positions=[];const known=['profile','file','cursor','limit','aliases-cursor','aliases-limit','history-cursor','history-limit','action-type','capability','provider','account-ref','workspace','plan'];
  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(!known.includes(key)||Object.hasOwn(flags,key)||!args[i+1]||args[i+1].startsWith('--'))throw Error('Unknown, repeated or incomplete sender option.');flags[key]=args[++i];}
- if(positions[0]!=='sender'||positions[1]!=='accounts')throw Error('Use sender accounts list|get|alias|register|bind|unbind|state|automation.');
- const automation=positions[2]==='automation',activity=positions[2]==='activity',nested=automation||activity,command=nested?`${positions[2]}-${positions[3]}`:positions[2];
- const names={'activity-report':'sender_activity_report',alias:'sender_alias_get',list:'sender_accounts_list',get:'sender_account_get',register:'sender_account_register',bind:'sender_alias_bind',unbind:'sender_alias_unbind',state:'sender_account_state_set','automation-get':'sender_automation_get','automation-set':'sender_automation_set'};
+ if(positions[0]==='sender'&&positions[1]==='managed'){
+  if(positions[2]==='plan'){
+   const plans=['free','premium_career','premium_business','premium_all_in_one','sales_navigator_core','sales_navigator_advanced','recruiter_lite'],usage=`Use sender managed plan MANAGED_ACCOUNT_ID --plan ${plans.join('|')}|none [--workspace ID] [--profile PATH]  (the user only; none clears it).`;
+   if(positions.length!==4||Object.keys(flags).some(key=>!['profile','plan','workspace'].includes(key))||!flags.plan||![...plans,'none'].includes(flags.plan))throw Error(flags.plan&&![...plans,'none'].includes(flags.plan)?`${flags.plan} is not a plan. ${usage}`:usage);
+   console.log(JSON.stringify(await callWorkspace('workspace_managed_account_plan_set',{workspaceId:flags.workspace,managedAccountId:positions[3],plan:flags.plan==='none'?null:flags.plan},configuration(flags.profile??process.env.AUDIENTI_PROFILE))));return;
+  }
+  const names={list:'workspace_managed_accounts_list',connect:'workspace_managed_account_connect'};
+  if(!names[positions[2]]||positions.length!==3||Object.keys(flags).some(key=>!['profile','workspace'].includes(key)))throw Error('Use sender managed list|connect|plan [--workspace ID] [--profile PATH].');
+  console.log(JSON.stringify(await callWorkspace(names[positions[2]],{workspaceId:flags.workspace},configuration(flags.profile??process.env.AUDIENTI_PROFILE))));return;
+ }
+ if(positions[0]!=='sender'||positions[1]!=='accounts')throw Error('Use sender accounts list|get|alias|register|bind|unbind|state|workspaces|automation|modes.');
+ const automation=positions[2]==='automation',modes=positions[2]==='modes',activity=positions[2]==='activity',nested=automation||modes||activity,command=nested?`${positions[2]}-${positions[3]}`:positions[2];
+ const names={'activity-report':'sender_activity_report',alias:'sender_alias_get',list:'sender_accounts_list',get:'sender_account_get',register:'sender_account_register',bind:'sender_alias_bind',unbind:'sender_alias_unbind',state:'sender_account_state_set',workspaces:'sender_account_workspaces_set','automation-get':'sender_automation_get','automation-set':'sender_automation_set','modes-get':'sender_action_modes_get','modes-set':'sender_action_mode_set'};
  const name=names[command];if(!name)throw Error('Unknown sender account command.');
- const operation=senderAccountOperations[name],hasId=!['list','register','alias'].includes(command),expected=nested?5:hasId?4:3;if(positions.length!==expected)throw Error('Unexpected sender arguments.');
- const allowed=['profile',...(operation.method==='POST'?['file']:command==='alias'?['provider','account-ref']:command==='list'?['cursor','limit']:command==='get'?['aliases-cursor','aliases-limit','history-cursor','history-limit']:[]),...(automation?['action-type']:[])];
+ const operation=senderAccountOperations[name],hasId=!['list','register','alias'].includes(command),expected=nested?5:hasId?4:3;if(positions.length!==expected)throw Error('Unexpected sender arguments.'+(command==='workspaces'?' Use sender accounts workspaces ACCOUNT_ID --file scope.json [--profile PATH].':''));
+ const allowed=['profile',...(operation.method==='POST'?['file']:command==='alias'?['provider','account-ref']:command==='list'?['cursor','limit']:command==='get'?['aliases-cursor','aliases-limit','history-cursor','history-limit']:[]),...(automation?['action-type']:[]),...(command==='modes-set'?['capability']:[])];
  if(Object.keys(flags).some(key=>!allowed.includes(key)))throw Error('Option does not apply to this sender command.');
- let input={};if(operation.method==='POST'){if(!flags.file)throw Error('--file INPUT.json is required.');input=readJsonFile(flags.file,65536,'Sender input');if(!input||typeof input!=='object'||Array.isArray(input))throw Error('invalid_fields: input must be a JSON object.');if(Object.hasOwn(input,'senderAccountId')||Object.hasOwn(input,'actionType')||Object.hasOwn(input,'workspaceId'))throw Error('Path IDs and workspaceId are not allowed in the file.');}
+ let input={};if(operation.method==='POST'){if(!flags.file)throw Error('--file INPUT.json is required.');input=readJsonFile(flags.file,65536,'Sender input');if(!input||typeof input!=='object'||Array.isArray(input))throw Error('invalid_fields: input must be a JSON object.');if(Object.hasOwn(input,'senderAccountId')||Object.hasOwn(input,'actionType')||Object.hasOwn(input,'capability')||Object.hasOwn(input,'workspaceId'))throw Error('Path IDs and workspaceId are not allowed in the file.');}
  if(command==='alias'){input.provider=flags.provider;input.accountRef=flags['account-ref'];}
- if(hasId)input.senderAccountId=positions[nested?4:3];if(automation)input.actionType=flags['action-type'];
+ if(hasId)input.senderAccountId=positions[nested?4:3];if(automation)input.actionType=flags['action-type'];if(command==='modes-set')input.capability=flags.capability;
  for(const key of ['cursor','limit','aliases-cursor','aliases-limit','history-cursor','history-limit'])if(flags[key]!==undefined){const field=key.replace(/-([a-z])/g,(_,c)=>c.toUpperCase());if(key.endsWith('limit')){if(!/^\d+$/.test(flags[key]))throw new WorkspaceRequestError(400,'invalid_fields','Page limit must be 1–100.');input[field]=Number(flags[key]);}else input[field]=flags[key];}
  console.log(JSON.stringify(await callSenderAccounts(name,input,flags.profile??process.env.AUDIENTI_PROFILE)));
 }

package/cli/skills-mcp.mjs

@@ -1,13 +1,17 @@
 import { z } from 'zod';
 import { helperContracts, SKILL_VERSION } from '../skills/audienti/scripts/contracts.mjs';
 import { runHelper } from '../skills/audienti/scripts/profile-helpers.mjs';
-import { skillArtifact, skillCatalog, skillDetails, SKILL_IDS } from './skills.mjs';
+import { skillArtifact, skillCatalog, skillDetails, skillResource, SKILL_IDS } from './skills.mjs';
 
 const annotations = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 const result = value => ({ content: [{ type: 'text', text: JSON.stringify(value) }], structuredContent: value });
 
 export function registerSkills(server) {
-  server.registerTool('skills_list', { description: 'List bundled agent skills and deterministic helpers. Local, no authentication or provider calls.', inputSchema: z.object({}).strict(), annotations }, async () => result(skillCatalog()));
+  server.registerTool('skills_list', { description: 'List bundled agent skills and deterministic helpers. Pass compact:true for descriptions and resource names without instructions or schemas. Local, no authentication or provider calls.', inputSchema: z.object({ compact: z.boolean().optional() }).strict(), annotations }, async ({ compact }) => result(skillCatalog({ compact })));
+  server.registerTool('skills_read', { description: 'Read one bundled skill resource: SKILL.md first, then a reference or helpers/NAME.json named by skills_list with compact:true. Reading never installs or runs anything.', inputSchema: z.object({ id: z.enum(SKILL_IDS), resource: z.string().min(1).max(160) }).strict(), annotations }, async ({ id, resource }) => {
+    try { return result(skillResource(id, resource)); }
+    catch { return { isError: true, content: [{ type: 'text', text: 'Unknown bundled skill resource. Use skills_list with compact:true.' }] }; }
+  });
   server.registerTool('skills_show', { description: 'Read bundled skill instructions, references, version, digest and helper schemas. Run getting-started once right after connecting.', inputSchema: z.object({ id: z.enum(SKILL_IDS) }).strict(), annotations }, async ({ id }) => result(skillDetails(id)));
   for (const [name, contract] of Object.entries(helperContracts)) {
     server.registerTool(`skills_${name.replaceAll('-', '_')}`, {

package/cli/skills.mjs

@@ -6,14 +6,23 @@ import { executeHelperFile } from '../skills/audienti/scripts/run.mjs';
 const bundles = {
   audienti: {
     version: SKILL_VERSION,
-    description: 'Agent-owned profile research with deterministic local helpers and guarded CRM writes.',
     files: ['SKILL.md', 'references/profile-workflows.md', 'references/helpers.md', 'references/workflow-receipt.md', 'scripts/contracts.mjs', 'scripts/profile-helpers.mjs', 'scripts/run.mjs'],
     helpers: true,
   },
   'getting-started': {
+    version: '1.5.1',
+    files: ['SKILL.md', 'references/capabilities.md', 'references/campaign-draft.md', 'references/audience.md', 'references/outcome-checks.md', 'references/replies.md', 'references/reply-checks.md', 'references/mailbox-check.md'],
+    helpers: false,
+  },
+  'playbook-design': {
+    version: '1.1.0',
+    files: ['SKILL.md', 'references/fields.md'],
+    helpers: false,
+  },
+  'agent-rooms': {
     version: '1.0.0',
-    description: 'Run once after connecting: report the tools you already have, introduce yourself, and set up the first audience and campaign with the owner.',
-    files: ['SKILL.md', 'references/inventory.md', 'references/campaign-draft.md'],
+    description: "Talk with your user's other registered agents in rooms: check your inbox each run, ask and answer, reply unable, and leave a turnover note.",
+    files: ['SKILL.md', 'references/commands.md'],
     helpers: false,
   },
 };
@@ -24,11 +33,14 @@ function readSkill(id = 'audienti') {
   if (!bundle) throw new Error('Unknown bundled skill. Use skills list.');
   const root = new URL(`../skills/${id}/`, import.meta.url);
   const contents = bundle.files.map(path => ({ path, text: readFileSync(new URL(path, root), 'utf8') }));
+  const front = contents[0].text.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? '';
+  const name = front.match(/^name: (.+)$/m)?.[1].trim(), description = front.match(/^description: (.+)$/m)?.[1].trim();
+  if (name !== id || !description) throw new Error('Bundled skill requires a matching name and description in SKILL.md frontmatter.');
   const hash = createHash('sha256');
   for (const file of contents) hash.update(`${file.path}\0${Buffer.byteLength(file.text)}\0`).update(file.text);
   return { contents, details: {
     id, version: bundle.version, digest: hash.digest('hex'),
-    description: bundle.description,
+    description,
     instructions: contents[0].text,
     references: contents.filter(file => file.path.startsWith('references/')),
     helpers: bundle.helpers ? Object.entries(helperContracts).map(([name, contract]) => ({ name, ...contract })) : [],
@@ -37,34 +49,65 @@ function readSkill(id = 'audienti') {
 
 export function skillDetails(id = 'audienti') { return readSkill(id).details; }
 
-export function skillCatalog() {
-  return { skills: SKILL_IDS.map(id => { const { instructions, references, ...entry } = skillDetails(id); return entry; }) };
+const helperPath = name => `helpers/${name}.json`;
+
+// Compact discovery omits instructions and schemas so an agent can pick a skill,
+// then read only the files it needs with skillResource.
+export function skillCatalog({ compact = false } = {}) {
+  if (!compact) return { skills: SKILL_IDS.map(id => { const { instructions, references, ...entry } = skillDetails(id); return entry; }) };
+  return { skills: SKILL_IDS.map(id => {
+    const { version, digest, description, helpers } = skillDetails(id);
+    return {
+      id, version, digest, description,
+      resources: [...bundles[id].files, ...helpers.map(({ name }) => helperPath(name))],
+      helpers: helpers.map(({ name, description: about }) => ({ name, description: about, resource: helperPath(name) })),
+    };
+  }) };
 }
 
+export function skillResource(id, path) {
+  const artifact = skillArtifact(id);
+  // Match shipped resource names exactly; never turn input into a disk path.
+  const file = artifact.files.find(entry => entry.path === path);
+  const helper = artifact.helpers.find(entry => helperPath(entry.name) === path);
+  if (!file && !helper) throw new Error('Unknown bundled skill resource. Use skills list --compact.');
+  return { id: artifact.id, version: artifact.version, digest: artifact.digest, path, content: file ? file.content : JSON.stringify(helper) };
+}
+
+const usage = `Usage: audienti skills list [--compact] | show ${SKILL_IDS.join('|')} | read SKILL RESOURCE | helper NAME --file INPUT.json|- [--json]`;
+
 export function skillArtifact(id = 'audienti') {
   const { details, contents } = readSkill(id);
   return { ...details, files: contents.map(({ path, text }) => ({ path, content: text })) };
 }
 
 export async function skillsCli(argv) {
-  const args = argv.slice(1), json = args.includes('--json');
+  // Skills are public; ignore --profile and --workspace so agents can pass them everywhere.
+  const raw = argv.slice(1), drop = new Set();
+  raw.forEach((value, i) => { if (value === '--profile' || value === '--workspace') { drop.add(i); drop.add(i + 1); } });
+  const args = raw.filter((_, i) => !drop.has(i)), json = args.includes('--json');
   const filtered = args.filter(value => value !== '--json');
   if (args.filter(value => value === '--json').length > 1) throw new Error('Invalid skills options.');
   if (filtered.length === 1 && ['--help', 'help'].includes(filtered[0])) {
-    process.stdout.write('Usage: audienti skills list | show audienti|getting-started | helper NAME --file INPUT.json|- [--json]\nLocal skill instructions/helpers; no login, installation or provider calls.\n'); return;
+    process.stdout.write(`${usage}\nLocal skill instructions/helpers; no login, installation or provider calls.\n`); return;
   }
-  if (filtered[0] === 'list' && filtered.length === 1) {
-    const catalog = skillCatalog();
+  if (filtered[0] === 'list' && (filtered.length === 1 || (filtered.length === 2 && filtered[1] === '--compact'))) {
+    const compact = filtered.length === 2, catalog = skillCatalog({ compact });
+    if (compact && !json) { process.stdout.write(catalog.skills.map(skill => `${skill.id}@${skill.version} — ${skill.description}\n${skill.resources.map(path => `  ${path}\n`).join('')}`).join('')); return; }
     process.stdout.write(json ? `${JSON.stringify(catalog)}\n` : catalog.skills.map(skill => `${skill.id}@${skill.version} — ${skill.description}\n`).join('')); return;
   }
   if (filtered[0] === 'show' && filtered.length === 2) {
     const details = skillDetails(filtered[1]);
-    process.stdout.write(json ? `${JSON.stringify(details)}\n` : `${details.instructions}\n`); return;
+    process.stdout.write(json ? `${JSON.stringify(details)}\n` : `${details.instructions}\n${details.references.map(file => `\n--- ${file.path} ---\n${file.text}\n`).join('')}`); return;
+  }
+  if (filtered[0] === 'read' && filtered.length === 3) {
+    const resource = skillResource(filtered[1], filtered[2]);
+    process.stdout.write(json ? `${JSON.stringify(resource)}\n` : `${resource.content}\n`); return;
   }
   if (filtered[0] === 'helper' && filtered.length === 4 && filtered[2] === '--file') {
     try { process.stdout.write(`${JSON.stringify(executeHelperFile(filtered[1], filtered[3]))}\n`); }
     catch { throw new Error('Skill helper failed. Inspect its schema and provide valid JSON of at most 1 MiB.'); }
     return;
   }
-  throw new Error('Usage: audienti skills list | show audienti|getting-started | helper NAME --file INPUT.json|- [--json]');
+  throw new Error(usage);
 }

package/cli/tools-operations.mjs

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 const uuid = z.string().uuid(), workspace = { workspaceId: uuid.optional() };
 const root = a => `/workspaces/${a.workspaceId}/tools`;
+const toolId = z.string().regex(/^[a-z][a-z0-9._]{0,63}$/);
 const key = z.string().regex(/^[a-z][a-z0-9_]{0,47}$/).refine(v => !['constructor','prototype'].includes(v));
 const instruction = z.string().trim().min(1).max(4000);
 const question = z.discriminatedUnion('type', [
@@ -15,18 +16,18 @@ const contentInputs = {
  'posts.search':z.object({query:z.string().trim().min(1).max(500),topicId:uuid,postedLimit,...page,sortBy:z.enum(['relevance','date']).optional()}).strict(),
  'posts.comments':z.object({postId:uuid,...page}).strict(),
  'posts.reactions':z.object({postId:uuid,page:page.page}).strict(),
- 'profiles.search':z.object({kind:z.enum(['person','company']).optional(),query:z.string().trim().min(1).max(500).optional(),title:z.string().trim().min(1).max(200).optional(),location:z.string().trim().min(1).max(200).optional(),geoId:z.string().regex(/^\d{1,20}$/).optional(),industryIds:z.array(z.string().regex(/^\d{1,20}$/)).max(20).optional(),keywordsCompany:z.string().trim().min(1).max(200).optional(),currentCompany:z.string().trim().min(1).max(1024).optional(),companySizes:z.array(z.enum(['1-10','11-50','51-200','201-500','501-1000','1001-5000','5001-10000','10001+'])).max(8).optional(),page:page.page}).strict(),
+ 'profiles.search':z.object({kind:z.enum(['person','company']).optional(),query:z.string().trim().min(1).max(500).optional(),title:z.string().trim().min(1).max(200).optional(),location:z.string().trim().min(1).max(200).optional(),geoId:z.string().regex(/^\d{1,20}$/).optional(),industryIds:z.array(z.string().regex(/^\d{1,20}$/)).max(20).optional(),keywordsCompany:z.string().trim().min(1).max(200).optional(),currentCompany:z.string().trim().min(1).max(1024).optional(),companySizes:z.array(z.enum(['1-10','11-50','51-200','201-500','501-1000','1001-5000','5001-10000','10001+'])).max(8).optional(),page:page.page,saveProfiles:z.boolean().optional()}).strict(),
  'profiles.posts':z.object({profileId:uuid,topicId:uuid,postedLimit,...page}).strict(),
 };
 const contentOperations = Object.fromEntries(Object.entries(contentInputs).map(([tool,input])=>[`tools_${tool.replaceAll('.','_')}`,{tool,paid:true,schema:z.object({...workspace,requestId:uuid,input}).strict(),method:'POST',path:a=>root(a)+'/'+tool,body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000}]));
 const recordsRoot = (a,kind) => `/workspaces/${a.workspaceId}/${kind}`;
 const contactInputs = {
- 'email.find':z.object({profileId:uuid,domain:z.string().trim().min(1).max(253),refresh:z.boolean().optional()}).strict(),
- 'mobile.find':z.object({profileId:uuid,email:z.string().min(1).max(320).optional(),refresh:z.boolean().optional()}).strict(),
+ 'email.find':z.object({profileId:uuid,domain:z.string().trim().min(1).max(253),refresh:z.boolean().optional(),cached:z.boolean().optional()}).strict(),
+ 'mobile.find':z.object({profileId:uuid,email:z.string().min(1).max(320).optional(),refresh:z.boolean().optional(),cached:z.boolean().optional()}).strict(),
 };
 export const hostedToolOperations = {
  ...Object.fromEntries(Object.entries(contactInputs).map(([tool,input])=>[`tools_${tool.replaceAll('.','_')}`,{tool,paid:true,limits:{cacheDays:7,maximumAttempts:tool==='email.find'?130:3},schema:z.object({...workspace,requestId:uuid,input}).strict(),method:'POST',path:a=>root(a)+'/'+tool,body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:60000}])),
- tools_email_verify:{tool:'email.verify',paid:true,limits:{providerCalls:1,cacheDays:7},schema:z.object({...workspace,requestId:uuid,input:z.object({email:z.string().max(320),refresh:z.boolean().optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/email.verify',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ tools_email_verify:{tool:'email.verify',paid:true,limits:{providerCalls:1,cacheDays:7},schema:z.object({...workspace,requestId:uuid,input:z.object({email:z.string().max(320),refresh:z.boolean().optional(),cached:z.boolean().optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/email.verify',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
  ...contentOperations,
  topics_create:{traced:true,schema:z.object({...workspace,requestId:uuid,name:z.string().trim().min(1).max(200),slug:z.string().max(200).optional(),description:z.string().max(4000).optional()}).strict(),method:'POST',path:a=>recordsRoot(a,'topics'),body:({workspaceId,...a})=>a,scoped:true},
  ...Object.fromEntries(['topics','posts'].flatMap(kind=>[
@@ -34,12 +35,16 @@ export const hostedToolOperations = {
   [`${kind}_get`,{traced:true,schema:z.object({...workspace,id:uuid}).strict(),method:'GET',path:a=>recordsRoot(a,kind)+'/'+a.id,scoped:true}],
  ])),
  tools_list:{schema:z.object(workspace).strict(),method:'GET',path:root,scoped:true},
- tools_web_search:{tool:'web.search',paid:true,limits:{providerCalls:1,cacheHours:24},schema:z.object({...workspace,requestId:uuid,input:z.object({query:z.string().trim().min(1).max(1000),country:z.string().regex(/^[A-Za-z]{2}$/).optional(),language:z.string().regex(/^[a-z]{2}(?:-[A-Z]{2})?$/).optional(),page:z.number().int().min(1).max(100).optional(),limit:z.number().int().min(1).max(10).optional(),timeRange:z.enum(['day','week','month','year']).optional(),refresh:z.boolean().optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/web.search',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ tools_search:{schema:z.object({...workspace,query:z.string().trim().min(1).max(200),limit:z.number().int().min(1).max(50).optional()}).strict(),method:'GET',path:a=>root(a)+'/search?'+new URLSearchParams({q:a.query,...a.limit!==undefined?{limit:String(a.limit)}:{}}),scoped:true,description:'One search across hosted tools, Audienti CLI commands and skills. Product words work (ICP finds audience tools, commands and skills; enrich finds profile tools) and so do provider names. Returns compact rows only: id, kind (tool, command or skill), one-line description and, for paid tools, the price per call or the metered unit. Then tools_get for a tool\'s inputs and tools_call to run it.'},
+ tools_get:{schema:z.object({...workspace,tool:toolId}).strict(),method:'GET',path:a=>root(a)+'/'+encodeURIComponent(a.tool),scoped:true,description:'One catalog tool: input JSON schema, limits, price per call, whether it is configured and available now, and this workspace\'s own 30-day call count, success rate and median speed.'},
+ tools_call:{paid:true,generic:true,schema:z.object({...workspace,tool:toolId,requestId:uuid,input:z.record(z.string(),z.unknown())}).strict(),method:'POST',path:a=>root(a)+'/call',body:a=>({tool:a.tool,requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:90000,description:'Run any catalog tool by id (audienti.<object>.<verb>) or old name (find ids with tools_search, inputs with tools_get). Record tools accept input cached:false to skip the saved record and make a fresh paid call. Charged through workspace credits like the per-tool operations. Generate requestId once and reuse it with the same input after any interruption or error: a replay is free and returns the saved result, a new ID is a new purchase. A timeout may have consumed paid work; inspect tools_runs_get rather than redispatching with a new ID. Positive credit balance is required for paid dispatch; completion may overdraw. Rejected means no provider dispatch.'},
+ tools_web_search:{tool:'web.search',paid:true,limits:{providerCalls:1,cacheHours:24},schema:z.object({...workspace,requestId:uuid,input:z.object({query:z.string().trim().min(1).max(1000),country:z.string().regex(/^[A-Za-z]{2}$/).optional(),language:z.string().regex(/^[a-z]{2}(?:-[A-Z]{2})?$/).optional(),page:z.number().int().min(1).max(100).optional(),limit:z.number().int().min(1).max(10).optional(),timeRange:z.enum(['day','week','month','year']).optional(),refresh:z.boolean().optional(),cached:z.boolean().optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/web.search',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
  tools_web_fetch:{tool:'web.fetch',paid:true,limits:{providerCalls:3,resultCache:false},schema:z.object({...workspace,requestId:uuid,input:z.object({url:z.string().min(1).max(2048)}).strict()}).strict(),method:'POST',path:a=>root(a)+'/web.fetch',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:90000},
  tools_proxy_sessions_create:{tool:'proxy.sessions.create',paid:true,limits:{maxSeconds:3600,concurrentWorkspaceConnections:32,meter:'upstream_tcp_payload_bytes'},schema:z.object({...workspace,requestId:uuid,input:z.object({ttlSeconds:z.number().int().min(60).max(3600).optional(),parentOperationId:uuid.optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/proxy.sessions.create',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
- tools_proxy_sessions_close:{schema:z.object({...workspace,operationId:uuid}).strict(),method:'POST',path:a=>root(a)+'/proxy.sessions.close',body:a=>({operationId:a.operationId}),scoped:true},
+ tools_proxy_sessions_close:{tool:'proxy.sessions.close',schema:z.object({...workspace,operationId:uuid}).strict(),method:'POST',path:a=>root(a)+'/proxy.sessions.close',body:a=>({operationId:a.operationId}),scoped:true},
  tools_decide:{tool:'decide',paid:true,schema:z.object({...workspace,requestId:uuid,input:z.object({state:z.union([z.string(),z.record(z.string(),z.unknown()),z.array(z.unknown())]),questions:z.record(key,question).refine(v=>Object.keys(v).length>=1&&Object.keys(v).length<=16)}).strict()}).strict(),method:'POST',path:a=>root(a)+'/decide',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
- tools_profiles_fetch:{tool:'profiles.fetch',paid:true,schema:z.object({...workspace,requestId:uuid,input:z.object({url:z.string().min(1).max(1024),refresh:z.boolean().optional(),fields:z.array(z.enum(['name','headline','about','location','experience','currentPositions','education','skills','websites','photo','connections','followers','certifications','languages','industries','employeeCount','employeeCountRange','founded','specialities','locations'])).min(1).max(20).optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/profiles.fetch',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ tools_intent_label:{tool:'intent.label',paid:true,limits:{textCharacters:4000,contextCharacters:2000,suggestions:2},description:'Suggest what a message means. Paid: built on decide, billed on the input tokens the provider measures at the decide price (read it first with tools_get audienti.intent.label: tokenPrice). Give the message text, direction (inbound or outbound) and channel, and optionally context. Returns up to two suggestions from the intent label list (one reading, one meeting label), each with a quote that is words of the message, a plain reason, a confidence and any typed detail still to add (needs). Records nothing and sends nothing: record a suggestion you keep with intent_record, which runs every check again. Reuse requestId after any interruption; a replay is free.',schema:z.object({...workspace,requestId:uuid,input:z.object({text:z.string().min(1).max(4000),direction:z.enum(['inbound','outbound']),channel:z.enum(['email','linkedin']),context:z.string().trim().min(1).max(2000).optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/intent.label',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
+ tools_profiles_fetch:{tool:'profiles.fetch',paid:true,schema:z.object({...workspace,requestId:uuid,input:z.object({url:z.string().min(1).max(1024),refresh:z.boolean().optional(),cached:z.boolean().optional(),fields:z.array(z.enum(['name','headline','about','location','experience','currentPositions','education','skills','websites','photo','connections','followers','certifications','languages','industries','employeeCount','employeeCountRange','founded','specialities','locations','companyType'])).min(1).max(20).optional()}).strict()}).strict(),method:'POST',path:a=>root(a)+'/profiles.fetch',body:a=>({requestId:a.requestId,input:a.input}),scoped:true,timeoutMs:30000},
  tools_runs_get:{schema:z.object({...workspace,operationId:uuid,attemptAfter:z.number().int().min(0).max(2147483647).optional(),entryAfter:uuid.optional()}).strict(),method:'GET',path:a=>root(a)+`/runs/${a.operationId}`+((a.attemptAfter!==undefined||a.entryAfter)?`?${new URLSearchParams({...a.attemptAfter!==undefined?{attemptAfter:String(a.attemptAfter)}:{},...a.entryAfter?{entryAfter:a.entryAfter}:{}})}`:''),scoped:true},
  tools_runs_list:{schema:z.object({...workspace,cursor:uuid.optional()}).strict(),method:'GET',path:a=>root(a)+'/runs'+(a.cursor?`?cursor=${encodeURIComponent(a.cursor)}`:''),scoped:true},
  tools_balance:{schema:z.object(workspace).strict(),method:'GET',path:a=>root(a)+'/balance',scoped:true},
@@ -59,12 +64,16 @@ hostedToolOperations.tools_profiles_discover = {
  path: a => root(a) + '/profiles.discover',
 };
 export const paidToolOperations = Object.fromEntries(Object.entries(hostedToolOperations).filter(([,operation])=>operation.paid));
-export const paidToolByName = Object.fromEntries(Object.entries(paidToolOperations).map(([name,operation])=>[operation.tool,{name,...operation}]));
-export const isPaidToolOperation = name => Object.hasOwn(paidToolOperations,name);
+export const paidToolByName = Object.fromEntries(Object.entries(paidToolOperations).filter(([,operation])=>operation.tool).map(([name,operation])=>[operation.tool,{name,...operation}]));
+// tools_call is paid except for the free proxy.sessions.close control call, which has no requestId or fee.
+export const isPaidToolOperation = (name, args) => name === 'tools_call' ? !['proxy.sessions.close', 'audienti.proxy.session.close'].includes(args?.tool) : Object.hasOwn(paidToolOperations, name);
 
 // Only known descriptor shape decides where a paid operation lives. Never infer
 // a nested operation for unrelated responses or let projection state mask billing.
-export const paidToolResult = (name, data) => {
+// Through tools_call the shape follows the resolved tool: profiles.enrich nests its operation.
+export const paidToolResult = (name, data, args) => {
+ if (name === 'tools_call') return ['profiles.enrich', 'audienti.people.profile.enrich'].includes(args?.tool) ? data?.operation : data;
  const descriptor = paidToolOperations[name];
  return descriptor?.resultKey ? data?.[descriptor.resultKey] : data;
 };
+

package/cli/tools.mjs

@@ -1,15 +1,25 @@
-import { z } from 'zod';
+import { randomUUID } from 'node:crypto';
 import { hostedToolOperations, paidToolByName, isPaidToolOperation, paidToolResult } from './tools-operations.mjs';
 import { parseArgs } from 'node:util';
 import { readJsonFile } from './json-file.mjs';
 import { callWorkspace, configuration } from './workspaces.mjs';
 const help = `Usage:
-  audienti tools list [--workspace UUID] [--json]
-  audienti tools proxy.sessions.close UUID [--workspace UUID]
-  audienti tools describe decide|email.verify|email.find|mobile.find|profiles.fetch|posts.fetch|posts.search|posts.comments|posts.reactions|profiles.posts|profiles.search|proxy.sessions.create|web.search|web.fetch
-  audienti tools decide|email.verify|email.find|mobile.find|profiles.fetch|posts.fetch|posts.search|posts.comments|posts.reactions|profiles.posts|profiles.search|proxy.sessions.create|web.search|web.fetch --input FILE|- --request-id UUID [--workspace UUID] [--json]
+  audienti call TOOL ['JSON_INPUT'] [--input FILE|-] [--request-id UUID] [--workspace UUID] [--json]
+  audienti tools search "WORDS" [--limit N] [--workspace UUID]   one server search over tools, audienti commands and skills; rows: id, kind, description, price
+  audienti tools get TOOL [--workspace UUID]         one tool: inputs, price, availability, your 30-day success rate and speed
+  audienti tools list [--workspace UUID] [--json]    the whole catalog
   audienti tools runs get UUID [--attempt-after ORDINAL] [--entry-after UUID] | list [--cursor UUID]
   audienti tools balance
+  audienti tools NAME --input FILE|- --request-id UUID [--workspace UUID] [--json]   same as call NAME; kept for existing scripts
+  audienti tools proxy.sessions.close UUID [--workspace UUID]
+
+The server catalog is the only source of tool names, inputs and prices: run tools search or tools get, then call.
+call sends {tool,requestId,input} to one route for every tool. Published ids look like audienti.email.verify;
+an old name (for example profiles.enrich) resolves on the server. A tool with no configured provider is not listed or callable.
+Record tools (profile read and enrich, email and mobile find, email.verify, web.search) reuse a saved record when one is
+current; put "cached":false in the input to skip it, make a fresh paid call and save the result.
+Without --request-id, call generates one and prints it to stderr. Save it: replaying the same ID is free and
+returns the saved result; a new ID is a new purchase.
 
 email.find and mobile.find may return running: poll tools runs get OPERATION_ID.
 Keep the same request ID after interruptions; never submit a new one to retry a purchase.
@@ -23,12 +33,12 @@ profiles.fetch accepts a person /in/ or company /company/ URL as {url,fields?,re
 Explicit refresh requires paid admission; the result includes saved profile/prospect IDs.
 Fields: name, headline, about, location, experience, currentPositions, education, skills,
 websites, photo, connections, followers, certifications, languages. Company-specific fields:
-industries, employeeCount, employeeCountRange, founded, specialities, locations.
+industries, employeeCount, employeeCountRange, founded, specialities, locations, companyType.
 profiles.enrich accepts the same fields as profiles.fetch, using url or saved profileId.
 Its operation has the same admission identity as profiles.fetch; the Prospect projection is a current free read.
 profiles.discover is the clear external-search alias of profiles.search; profiles list searches saved workspace records.
 profiles.search accepts person filters or {kind:"company",query,companySizes?}; results are partial profiles.
-Use describe for exact fields. No implicit email lookup.
+Use tools get TOOL for exact fields. No implicit email lookup.
 decide accepts {state,questions}; question types: boolean, choice, score.
 Questions have instructions; choice requires named criteria; score criteria are ordered
 from level zero. State is text, an object or an array. At most 32 KiB, 16 questions,
@@ -43,13 +53,41 @@ async function readStdin() {
  for await(const chunk of process.stdin){size+=chunk.length;if(size>32768)throw new Error('Tool input exceeds 32 KiB.');chunks.push(chunk);}
  try{return JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(Buffer.concat(chunks)));}catch{throw new Error('Tool input must be valid UTF-8 JSON.');}
 }
+const asJson=value=>{try{return JSON.parse(value);}catch{throw new Error('Tool input must be valid JSON.');}};
+export async function printPaid(name,args,values){
+ try{
+  const result=await callWorkspace(name,args,configuration(values.profile));
+  const paidResult=paidToolResult(name,result?.data,args);
+  if(['failed','uncertain','rejected'].includes(paidResult?.status)){
+   process.stderr.write(JSON.stringify({error:{code:paidResult.error?.code??'tool_incomplete'},operationId:paidResult.operationId,requestId:args.requestId,billing:paidResult.billing,...(paidResult.result?.persistence?{result:paidResult.result}:{}),requestTraceId:result.requestTraceId,recovery:paidResult.status==='rejected'?'resolve_rejection_then_new_request_id':paidResult.result?.persistence?.recovery??'retry_same_request_id'})+'\n');if(values.explain)process.stderr.write(values.explain(paidResult)+'\n');process.exitCode=1;return;
+  }
+  console.log(JSON.stringify(result));
+ }catch(error){
+  if(isPaidToolOperation(name,args))process.stderr.write(`Retain request ID ${args.requestId}; retry with the same ID to inspect/recover this operation.\n`);
+  throw error;
+ }
+}
+const parseOptions={help:{type:'boolean',short:'h'},json:{type:'boolean'},input:{type:'string'},'request-id':{type:'string'},workspace:{type:'string'},profile:{type:'string'},cursor:{type:'string'},limit:{type:'string'},'attempt-after':{type:'string'},'entry-after':{type:'string'}};
+/** audienti call TOOL ['JSON'] : one generic route for every catalog tool. */
+export async function callCli(argv) {
+ const {positionals,values}=parseArgs({args:argv.slice(1),allowPositionals:true,strict:true,options:parseOptions});
+ if(values.help||positionals.length===0){console.log(help);return;}
+ const [tool,inline]=positionals;
+ if(positionals.length>2||(inline!==undefined&&values.input))throw new Error('Give the input once: a JSON argument or --input FILE|-.');
+ const input=inline!==undefined?asJson(inline):values.input?(values.input==='-'?await readStdin():readJsonFile(values.input,32768,'Tool input')):{};
+ if(!input||typeof input!=='object'||Array.isArray(input))throw new Error('Tool input must be a JSON object.');
+ const requestId=values['request-id']??randomUUID();
+ if(!values['request-id'])process.stderr.write(`request-id: ${requestId}\n`);
+ await printPaid('tools_call',{workspaceId:values.workspace,tool,requestId,input},values);
+}
 export async function toolsCli(argv) {
- const {positionals,values}=parseArgs({args:argv.slice(1),allowPositionals:true,strict:true,options:{help:{type:'boolean',short:'h'},json:{type:'boolean'},input:{type:'string'},'request-id':{type:'string'},workspace:{type:'string'},profile:{type:'string'},cursor:{type:'string'},'attempt-after':{type:'string'},'entry-after':{type:'string'}}});
+ const {positionals,values}=parseArgs({args:argv.slice(1),allowPositionals:true,strict:true,options:parseOptions});
  if(values.help||positionals.length===0){console.log(help);return;}
  const [verb,sub,id]=positionals;
- if(verb==='describe'&&Object.hasOwn(paidToolByName,sub)&&positionals.length===2){console.log(JSON.stringify({name:sub,version:'1',canonicalTool:paidToolByName[sub].canonicalTool??sub,responseOperationPath:paidToolByName[sub].resultKey??null,inputSchema:z.toJSONSchema(paidToolByName[sub].schema.shape.input),limits:paidToolByName[sub].limits??(sub==='decide'?{bytes:32768,depth:32,questions:16,choices:32,scoreLevels:10}:sub==='profiles.fetch'?{providerCalls:1,normalizedBytes:65536,cacheDays:30}:{providerCalls:1,resultCache:false}),retry:'Reuse the same requestId and authenticated principal after interruptions.'},null,values.json?undefined:2));return;}
  let name,args={workspaceId:values.workspace};
  if(verb==='list'&&positionals.length===1)name='tools_list';
+ else if(verb==='search'&&positionals.length>=2){name='tools_search';args.query=positionals.slice(1).join(' ');if(values.limit!==undefined)args.limit=Number(values.limit);}
+ else if((verb==='get'||verb==='describe')&&positionals.length===2){name='tools_get';args.tool=sub;}
  else if(verb==='balance'&&positionals.length===1)name='tools_balance';
  else if(verb==='runs'&&sub==='get'&&positionals.length===3){name='tools_runs_get';args.operationId=id;args.entryAfter=values['entry-after'];if(values['attempt-after']!==undefined)args.attemptAfter=Number(values['attempt-after']);}
  else if(verb==='runs'&&sub==='list'&&positionals.length===2){name='tools_runs_list';args.cursor=values.cursor;}
@@ -58,15 +96,5 @@ export async function toolsCli(argv) {
   if(!values.input||!values['request-id'])throw new Error(`${verb} requires --input FILE|- and --request-id UUID. Keep the request ID for retries.`);
   name=paidToolByName[verb].name;args.requestId=values['request-id'];args.input=values.input==='-'?await readStdin():readJsonFile(values.input,32768,'Tool input');
  }else throw new Error('Unknown tools command. Use audienti tools --help.');
- try{
-  const result=await callWorkspace(name,args,configuration(values.profile));
-  const paidResult = paidToolResult(name,result?.data);
-  if(['failed','uncertain','rejected'].includes(paidResult?.status)){
-   process.stderr.write(JSON.stringify({error:{code:paidResult.error?.code??'tool_incomplete'},operationId:paidResult.operationId,requestId:args.requestId,billing:paidResult.billing,...(paidResult.result?.persistence?{result:paidResult.result}:{}),requestTraceId:result.requestTraceId,recovery:paidResult.status==='rejected'?'resolve_rejection_then_new_request_id':paidResult.result?.persistence?.recovery??'retry_same_request_id'})+'\n');process.exitCode=1;return;
-  }
-  console.log(JSON.stringify(result));
- }catch(error){
-  if(isPaidToolOperation(name))process.stderr.write(`Retain request ID ${args.requestId}; retry with the same ID to inspect/recover this operation.\n`);
-  throw error;
- }
+ await printPaid(name,args,values);
 }

package/cli/work-execution-operations.mjs

@@ -25,8 +25,15 @@ const body=({workspaceId,planId,clientActionId,attemptId,...rest})=>rest;
 export const workspaceExecutionOperations={
  workspace_work_claim:{schema:z.object({...location,expectedRevision:z.number().int().positive(),requestId:uuid}).strict(),scoped:true,method:'POST',path:a=>`${path(a)}/claims`,body},
  workspace_work_start:{schema:z.object({...location,claimId:uuid,requestId:uuid}).strict(),scoped:true,method:'POST',path:a=>`${path(a)}/start`,body},
+ workspace_work_send:{schema:z.object({...location,claimId:uuid,requestId:uuid}).strict(),scoped:true,method:'POST',path:a=>`${path(a)}/send`,body,description:'LinkedIn accounts connected through Audienti only. Starts the claimed, approved action and sends it once through the managed account, then records the result. Replaying the same claim returns the recorded send; it never sends again.'},
  workspace_work_attempt_get:{schema:z.object({...location,historyCursor:uuid.optional(),historyLimit:z.number().int().min(1).max(100).optional()}).strict(),scoped:true,method:'GET',path:a=>{const q=new URLSearchParams();for(const key of ['historyCursor','historyLimit'])if(a[key]!==undefined)q.set(key,String(a[key]));return `${path(a)}/attempt?${q}`;}},
 };
+// LinkedIn accounts connected through Audienti. Only the user connects one; agents list them and send through work send.
+export const managedAccountOperations={
+ workspace_managed_accounts_list:{schema:z.object({workspaceId:uuid.optional()}).strict(),scoped:true,method:'GET',path:a=>`/workspaces/${a.workspaceId}/managed-accounts`,description:'List the LinkedIn accounts connected through Audienti in this workspace, with their sending account IDs and status.'},
+ workspace_managed_account_plan_set:{schema:z.object({workspaceId:uuid.optional(),managedAccountId:uuid,plan:z.enum(['free','premium_career','premium_business','premium_all_in_one','sales_navigator_core','sales_navigator_advanced','recruiter_lite']).nullable()}).strict(),scoped:true,method:'PUT',path:a=>`/workspaces/${a.workspaceId}/managed-accounts/${a.managedAccountId}/plan`,body:a=>({plan:a.plan}),description:'The user only, not agents. States the LinkedIn plan of a managed account, which sets how long a connection note may be. Pass plan null to clear it; the safer figures then apply. Returns the account.'},
+ workspace_managed_account_connect:{schema:z.object({workspaceId:uuid.optional()}).strict(),scoped:true,method:'POST',path:a=>`/workspaces/${a.workspaceId}/managed-accounts/connect`,body:()=>({}),description:'The user only, not agents. Returns a sign-in link, valid 15 minutes, where the user connects a LinkedIn account through Audienti.'},
+};
 export const narrowExecutionOperations={
  work_claim_release:{schema:z.object({claimId:uuid,requestId:uuid,reason}).strict(),method:'POST',path:a=>`/work-execution/claims/${a.claimId}/release`,body:({claimId,...rest})=>rest},
  work_attempt_lookup:{schema:z.object({claimId:uuid}).strict(),method:'GET',path:a=>`/work-execution/claims/${a.claimId}/attempt`},