@indemn/cli 1.7.8 → 1.7.10

package/test/mcp/campaigns.test.ts

@@ -0,0 +1,165 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { on, recordFetch, type RecordedCall, type Responder } from '../helpers/fetch-recorder.js';
+import { cleanEnv } from '../helpers/config-home.js';
+import { connectPair } from '../helpers/mcp-pair.js';
+import { IndemnClient } from '../../src/sdk/client.js';
+import { registerTools } from '../../src/mcp/tools.js';
+import { TOOL_META } from '../../src/mcp/tool-meta.js';
+
+const ORG = 'aaaaaaaaaaaaaaaaaaaaaaaa';
+const solutionsOn = on('GET', `/organization/${ORG}/configurations`, { json: { enableSolutions: true } });
+const approve = () => ({ action: 'accept' as const, content: { confirm: true } });
+async function pair(elicit: () => { action: 'accept' | 'decline'; content?: Record<string, unknown> } = approve) {
+  cleanEnv();
+  const client = new IndemnClient({ apiKey: `ind_dev_${'a'.repeat(64)}`, orgId: ORG, environment: 'dev' });
+  return connectPair((server) => { registerTools(server, client); }, { elicit });
+}
+const fetches = (responders: Responder[]) => recordFetch([solutionsOn, ...responders]);
+const writes = (calls: RecordedCall[]) => calls.filter((c) => c.method !== 'GET').map((c) => `${c.method} ${c.url.split('campaigns-service')[1]}`);
+const draft = { audience: null, touchpoints: [], escalation_policy: {}, channel_policy: {} };
+const campaign = { id: 'c1', name: 'GL renewals', status: 'draft', current_version_n: null, draft };
+
+describe('campaign tools', () => {
+  let p: Awaited<ReturnType<typeof pair>> | undefined;
+  afterEach(async () => { await p?.close(); p = undefined; });
+
+  it('with Solutions off, reads and changes are refused before any card or call, saying how to turn it on', async () => {
+    const { calls } = recordFetch([on('GET', '/configurations', { json: { enableSolutions: false } })]);
+    p = await pair();
+    for (const [name, args] of [['get_campaigns', { what: 'list' }], ['save_campaign', { solution_id: 's1', book_id: 'b1', name: 'X', campaign_type: 'renewal' }]] as const) {
+      const res = await p.call(name, args);
+      expect(res.isError).toBe(true);
+      expect(String(res.body)).toMatch(/Solutions is not turned on.*set_org_admin_settings.*Nothing was changed/);
+    }
+    expect(p.questions).toHaveLength(0);
+    expect(calls.filter((c) => c.url.includes('campaigns-service'))).toHaveLength(0);
+  });
+
+  it('save_campaign without an id creates, asking first by name; confirm and empty fields never reach the service', async () => {
+    const { calls } = fetches([on('GET', '/campaigns-service/books/b1', { json: { id: 'b1', name: 'GL book' } }), on('POST', '/campaigns-service/campaigns', { json: campaign })]);
+    p = await pair();
+    const res = await p.call('save_campaign', { solution_id: 's1', book_id: 'b1', name: 'GL renewals', campaign_type: 'renewal', closes: '', confirm: true });
+    expect(res.isError).toBe(false);
+    expect(p.questions[0].message).toContain('create campaign "GL renewals" as a draft; it sends nothing until it is published and started');
+    expect(writes(calls)).toEqual(['POST /campaigns']);
+    expect(calls.find((c) => c.method === 'POST')!.body).toEqual({ solution_id: 's1', book_id: 'b1', name: 'GL renewals', campaign_type: 'renewal' });
+  });
+
+  it('a create missing what it needs is answered at once: no card, no call', async () => {
+    const { calls } = fetches([]);
+    p = await pair();
+    const res = await p.call('save_campaign', { name: 'GL renewals' });
+    expect(res.isError).toBe(true);
+    expect(String(res.body)).toContain('To create a campaign also give solution_id, book_id, campaign_type');
+    expect(p.questions).toHaveLength(0);
+    expect(writes(calls)).toEqual([]);
+  });
+
+  it('save_campaign with an id changes only the draft parts given, by name on the card', async () => {
+    const touchpoints = [{ key: 't1', channel: 'email' }];
+    const { calls } = fetches([
+      on('GET', '/campaigns-service/campaigns/c1', { json: { ...campaign, draft: { ...draft, touchpoints } } }),
+      on('PUT', '/campaigns-service/campaigns/c1/draft', (c) => ({ json: c.body })),
+    ]);
+    p = await pair();
+    const res = await p.call('save_campaign', { campaign_id: 'c1', audience: '{"field":"status","op":"eq","value":"active"}' });
+    expect(res.isError).toBe(false);
+    expect(p.questions[0].message).toContain('change the audience in the draft of campaign "GL renewals"');
+    expect(calls.find((c) => c.method === 'PUT')!.body).toEqual({ ...draft, touchpoints, audience: { field: 'status', op: 'eq', value: 'active' } });
+  });
+
+  it('set_touchpoint takes flat fields and rules as JSON text, and drafts unless told to send', async () => {
+    const { calls } = fetches([
+      on('GET', '/campaigns-service/campaigns/c1', { json: campaign }),
+      on('PUT', '/campaigns-service/campaigns/c1/draft', (c) => ({ json: c.body })),
+    ]);
+    p = await pair();
+    const res = await p.call('set_touchpoint', { campaign_id: 'c1', key: 't1_60', channel: 'email', when: '{"field":"derived.days_out","op":"lte","value":60}' });
+    expect(res.isError).toBe(false);
+    expect((calls.find((c) => c.method === 'PUT')!.body as typeof draft).touchpoints).toEqual([{ key: 't1_60', channel: 'email', terminal_action: 'draft', when: { field: 'derived.days_out', op: 'lte', value: 60 } }]);
+    expect(p.questions[0].message).toContain('touchpoint "t1_60" in the draft of campaign "GL renewals" (email)');
+  });
+
+  it('starting a campaign is its own approval and says it reaches customers; a decline changes nothing', async () => {
+    const { calls } = fetches([on('GET', '/campaigns-service/campaigns/c1', { json: campaign }), on('POST', '/status', { json: { ...campaign, status: 'running' } })]);
+    p = await pair(() => ({ action: 'decline' }));
+    await p.call('set_campaign_status', { campaign_id: 'c1', status: 'running' });
+    expect(p.questions[0].message).toMatch(/START campaign "GL renewals".*reach real customers/);
+    expect(writes(calls)).toEqual([]);
+  });
+
+  it("the service's refusal reaches the person as it is", async () => {
+    fetches([
+      on('GET', '/campaigns-service/campaigns/c1', { json: campaign }),
+      on('POST', '/status', { status: 409, json: { detail: 'cannot start a campaign that has never published a version' } }),
+    ]);
+    p = await pair();
+    const res = await p.call('set_campaign_status', { campaign_id: 'c1', status: 'running' });
+    expect(res.isError).toBe(true);
+    expect(String(res.body)).toContain('never published a version');
+  });
+
+  it('an id that names nothing gets no card', async () => {
+    const { calls } = fetches([on('GET', '/campaigns-service/campaigns/nope', { status: 404, json: { detail: 'not found' } })]);
+    p = await pair();
+    const res = await p.call('publish_campaign', { campaign_id: 'nope' });
+    expect(String(res.body)).toContain('Not found: campaign nope');
+    expect(p.questions).toHaveLength(0);
+    expect(writes(calls)).toEqual([]);
+  });
+
+  it('save_campaign_template with an id saves a new version from the latest one, named on the card', async () => {
+    const { calls } = fetches([
+      on('GET', '/campaigns-service/templates/tpl1/versions', { json: { items: [{ version_n: 1, subject: 'Renewal', body: 'Old', uses_variables: [] }] } }),
+      on('GET', '/campaigns-service/templates/tpl1', { json: { id: 'tpl1', name: 'GL reminder' } }),
+      on('POST', '/campaigns-service/templates/tpl1/versions', (c) => ({ json: { version_n: 2, ...(c.body as object) } })),
+    ]);
+    p = await pair();
+    const res = await p.call('save_campaign_template', { template_id: 'tpl1', body: 'New', subject: '' });
+    expect(res.isError).toBe(false);
+    expect(calls.find((c) => c.method === 'POST')!.body).toEqual({ subject: 'Renewal', body: 'New', uses_variables: [] });  // "" kept the subject
+    expect(p.questions[0].message).toContain('new version of template "GL reminder" (body)');
+  });
+
+  it('save_template_skill creates and changes, by name on the card', async () => {
+    const { calls } = fetches([
+      on('GET', '/campaigns-service/template-skills/sk1', { json: { id: 'sk1', name: 'Tone', instructions: 'Brief.' } }),
+      (c) => (c.method === 'GET' ? undefined : { json: { id: 'sk1' } }),
+    ]);
+    p = await pair();
+    await p.call('save_template_skill', { solution_id: 's1', key: 'tone', name: 'Tone', instructions: 'Brief.' });
+    await p.call('save_template_skill', { template_skill_id: 'sk1', instructions: 'Warm.' });
+    expect(writes(calls)).toEqual(['POST /template-skills', 'PUT /template-skills/sk1']);
+    expect(calls.filter((c) => c.method !== 'GET').map((c) => c.body)).toEqual([{ solution_id: 's1', key: 'tone', name: 'Tone', instructions: 'Brief.' }, { name: 'Tone', instructions: 'Warm.' }]);
+    expect(p.questions[1].message).toContain('change template skill "Tone" (instructions)');
+  });
+
+  it('save_book changes only the parts given; a create whose change is refused says the book exists', async () => {
+    const { calls } = fetches([
+      on('GET', '/campaigns-service/books/b1', { json: { id: 'b1', name: 'GL book' } }),
+      on('POST', '/campaigns-service/books', { json: { id: 'b2', name: 'New book' } }),
+      on('PUT', '/books/b2/display', { status: 400, json: { detail: 'display names keys absent from the schema: no.such' } }),
+      (c) => (c.method === 'GET' ? undefined : { json: { id: 'b1' } }),
+    ]);
+    p = await pair();
+    const res = await p.call('save_book', { book_id: 'b1', identity_keys: ['policy.number'], display: '{"primary":["policy.number"],"secondary":["insured.name"]}' });
+    expect(res.isError).toBe(false);
+    expect(p.questions[0].message).toContain('change book "GL book": identity keys to policy.number; display to primary policy.number; secondary insured.name.');
+    const made = await p.call('save_book', { solution_id: 's1', name: 'New book', display: '{"primary":["no.such"]}' });
+    expect(String(made.body)).toMatch(/The book was created \(id b2\), but .*no\.such.*do not create it again/);
+    expect(writes(calls)).toEqual(['PUT /books/b1/identity-keys', 'PUT /books/b1/display', 'POST /books', 'PUT /books/b2/display']);
+  });
+
+  it('a book change card shows the new values', () => {
+    expect(TOOL_META.save_book.describe!({ book_id: 'b1', source: { kind: 'upload' }, field_map: [{ source_path: 'Policy #', schema_key: 'policy.number' }, { source_path: 'Insured', schema_key: 'insured.name' }] }))
+      .toBe('This will change book b1: source to upload; field map to Policy # → policy.number, Insured → insured.name.');
+  });
+
+  it('get_campaigns reads books', async () => {
+    const { calls } = fetches([on('GET', '/campaigns-service/books', { json: { total: 1, items: [{ id: 'b1', name: 'GL book' }] } })]);
+    p = await pair();
+    const res = await p.call('get_campaigns', { what: 'books', solution_id: 's1' });
+    expect(res.isError).toBe(false);
+    expect(calls.some((c) => c.method === 'GET' && c.url.includes('/campaigns-service/books?') && c.url.includes('solution_id=s1'))).toBe(true);
+  });
+});

package/test/mcp/tools-snapshot.test.ts

@@ -17,7 +17,7 @@ describe('MCP tool list', () => {
       expect(typeof tool.annotations?.readOnlyHint, tool.name).toBe('boolean');
     }
     expect(tools.map((t) => t.name).sort()).toMatchSnapshot();
-    expect(tools).toHaveLength(141); // +numbers // +set_agent_transcriber // +set_org_admin_settings // +remove_holiday // +create_sandbox_org
+    expect(tools).toHaveLength(149); // +invite_org_member // +7 campaign tools // +numbers // +set_agent_transcriber // +set_org_admin_settings // +remove_holiday // +create_sandbox_org
     const props = (name: string) => Object.keys((tools.find((t) => t.name === name)!.inputSchema as { properties?: object }).properties ?? {});
     for (const name of ['list_agents', 'delete_agent', 'set_prompt', 'list_org_members', 'list_channels', 'chat_with_agent']) {
       expect(props(name), name).toContain('org_id');
@@ -26,7 +26,7 @@ describe('MCP tool list', () => {
       expect(props(name), name).not.toContain('org_id');
     }
     // Writes that change what customers get or reach outside ask first on every host (a dry run, then confirm).
-    for (const name of ['delete_agent', 'create_function', 'test_function', 'add_kb_data', 'scrape_url', 'upload_kb_file']) {
+    for (const name of ['delete_agent', 'create_function', 'test_function', 'add_kb_data', 'scrape_url', 'upload_kb_file', 'save_campaign', 'set_touchpoint', 'publish_campaign', 'set_campaign_status', 'save_campaign_template', 'save_template_skill', 'save_book']) {
       expect(props(name), name).toContain('confirm');
     }
     // The person chooses how much of a website is crawled: only scrape_url crawls, and it needs their choice.

package/test/sdk/campaigns.test.ts

@@ -1,14 +1,15 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { on, recordFetch } from '../helpers/fetch-recorder.js';
+import { on, recordFetch, type RecordedCall } from '../helpers/fetch-recorder.js';
 import { cleanEnv, useTempHome } from '../helpers/config-home.js';
 import { jwtExpiringIn } from '../helpers/jwt.js';
 import { IndemnClient } from '../../src/sdk/client.js';
 import { CampaignsSDK } from '../../src/sdk/campaigns.js';
 
 const ORG = 'aaaaaaaaaaaaaaaaaaaaaaaa';
+const base = `/api/organization/${ORG}/campaigns-service`;
+const seen = (calls: RecordedCall[]) => calls.map((c) => `${c.method} ${new URL(c.url).pathname.replace(base, '')}`);
 
-describe('campaigns are read-only', () => {
+describe('campaigns: reads, and writes to configuration only', () => {
   let home: ReturnType<typeof useTempHome>;
   beforeEach(() => {
     cleanEnv();
@@ -18,26 +19,83 @@ describe('campaigns are read-only', () => {
   });
   afterEach(() => home.cleanup());
 
-  it('has no write call in the campaigns module', () => {
-    const src = readFileSync(new URL('../../src/sdk/campaigns.ts', import.meta.url), 'utf8');
-    expect(src).not.toMatch(/copilot(Post|Put|Delete|RequestRaw|PostForm|Binary)/);
-  });
-
-  it('reads through the org proxy with GET only', async () => {
+  it('reads through the org proxy with GET, books included', async () => {
     const { calls } = recordFetch([on('GET', '/campaigns-service/', { json: { total: 0, limit: 50, skip: 0, items: [] } })]);
     const sdk = new CampaignsSDK(new IndemnClient());
-    await sdk.list(); await sdk.detail('c1', 'forecast', 30); await sdk.templates(); await sdk.template('t1', true);
-    expect(calls.map((c) => `${c.method} ${new URL(c.url).pathname}`)).toEqual([
-      `GET /api/organization/${ORG}/campaigns-service/campaigns`,
-      `GET /api/organization/${ORG}/campaigns-service/campaigns/c1/forecast`,
-      `GET /api/organization/${ORG}/campaigns-service/templates`,
-      `GET /api/organization/${ORG}/campaigns-service/templates/t1/versions`,
-    ]);
+    await sdk.list(); await sdk.detail('c1', 'forecast', 30); await sdk.templates(); await sdk.template('t1', true); await sdk.books(); await sdk.book('b1');
+    expect(seen(calls)).toEqual(['GET /campaigns', 'GET /campaigns/c1/forecast', 'GET /templates', 'GET /templates/t1/versions', 'GET /books', 'GET /books/b1']);
   });
 
-  it('refuses a path outside the readable list', async () => {
+  it('never sends, runs, uploads, ticks or deletes: those paths are refused before any call', async () => {
     const { calls } = recordFetch();
-    await expect(new CampaignsSDK(new IndemnClient()).get('c1/../../communications/x/send')).rejects.toThrow(/not readable/);
+    const sdk = new CampaignsSDK(new IndemnClient());
+    await expect(sdk.get('c1/../../communications/x/send')).rejects.toThrow(/not readable/);
+    const write = (sdk as unknown as { write: (m: string, p: string, b?: unknown) => Promise<unknown> }).write.bind(sdk);
+    for (const [method, path] of [['POST', '/communications/x/send'], ['POST', '/work-items/w/resolve'], ['POST', '/books/b/runs'], ['POST', '/books/b/uploads'],
+      ['POST', '/campaigns/c/test-tick'], ['POST', '/campaigns/c/candidates/evaluate'], ['POST', '/enrollments/e/close'], ['POST', '/activity'],
+      ['DELETE', '/campaigns/c'], ['PUT', '/campaigns/c'], ['POST', '/campaigns/c/../../communications/x/send']]) {
+      await expect(write(method, path, {})).rejects.toThrow(/not allowed from the CLI/);
+    }
     expect(calls).toHaveLength(0);
   });
+
+  it('a touchpoint is added, or merged into the one with its key; a template given without a version is pinned to its latest', async () => {
+    const draft = { audience: { field: 'status', op: 'eq', value: 'active' }, touchpoints: [{ key: 't1', channel: 'email', terminal_action: 'draft', when: { field: 'derived.days_out', op: 'lte', value: 60 } }], escalation_policy: { then: 'create_work_item' }, channel_policy: {} };
+    const { calls } = recordFetch([
+      on('GET', '/campaigns/c1', { json: { id: 'c1', name: 'Renewals', status: 'draft', draft } }),
+      on('GET', '/templates/tpl1/versions', { json: { total: 2, items: [{ version_n: 2, subject: 'S2', body: 'B2' }, { version_n: 1 }] } }),
+      on('PUT', '/campaigns/c1/draft', (c) => ({ json: c.body })),
+    ]);
+    const sdk = new CampaignsSDK(new IndemnClient());
+    await sdk.setTouchpoint('c1', { key: 't2', channel: 'email', when: { field: 'derived.days_out', op: 'lte', value: 30 }, template_id: 'tpl1' });
+    await sdk.setTouchpoint('c1', { key: 't1', when: { field: 'derived.days_out', op: 'lte', value: 45 } });
+    const puts = calls.filter((c) => c.method === 'PUT').map((c) => c.body as typeof draft);
+    expect(puts[0].touchpoints).toEqual([draft.touchpoints[0], { key: 't2', channel: 'email', terminal_action: 'draft', when: { field: 'derived.days_out', op: 'lte', value: 30 }, template_id: 'tpl1', template_version_n: 2 }]);
+    expect(puts[0].audience).toEqual(draft.audience);  // the rest of the draft is kept
+    expect(puts[1].touchpoints).toEqual([{ ...draft.touchpoints[0], when: { field: 'derived.days_out', op: 'lte', value: 45 } }]);
+  });
+
+  it('a draft change keeps its touchpoints; a template change starts from its latest version', async () => {
+    const draft = { audience: null, touchpoints: [{ key: 't1', channel: 'email' }], escalation_policy: {}, channel_policy: {} };
+    const { calls } = recordFetch([
+      on('GET', '/campaigns/c1', { json: { id: 'c1', draft } }),
+      on('PUT', '/campaigns/c1/draft', (c) => ({ json: c.body })),
+      on('GET', '/templates/tpl1/versions', { json: { items: [{ version_n: 3, subject: 'Hi {{ contact.first_name }}', body: 'Old body', html: '', uses_variables: [{ key: 'contact.first_name', required: true, example: 'Ana' }], selection_tags: {}, skills: {}, batch_row: '', published_by: 'u0' }] } }),
+      on('POST', '/templates/tpl1/versions', (c) => ({ json: { version_n: 4, ...(c.body as object) } })),
+    ]);
+    const sdk = new CampaignsSDK(new IndemnClient());
+    await sdk.updateDraft('c1', { audience: { field: 'status', op: 'eq', value: 'active' } });
+    await sdk.updateTemplate('tpl1', { body: 'New body {{ record.policy.number }}', uses_variables: ['contact.first_name', 'record.policy.number'], change_summary: 'shorter' });
+    expect(calls.find((c) => c.method === 'PUT')!.body).toEqual({ ...draft, audience: { field: 'status', op: 'eq', value: 'active' } });
+    // Variables given as keys: a key already declared keeps its entry, a new one is declared as {key}.
+    expect(calls.find((c) => c.method === 'POST')!.body).toEqual({ subject: 'Hi {{ contact.first_name }}', body: 'New body {{ record.policy.number }}', html: '', uses_variables: [{ key: 'contact.first_name', required: true, example: 'Ana' }, { key: 'record.policy.number' }], selection_tags: {}, skills: {}, batch_row: '', change_summary: 'shorter' });
+  });
+
+  it('writes each configuration call with its method, path and body', async () => {
+    const { calls } = recordFetch([
+      on('GET', '/template-skills/s1', { json: { id: 's1', name: 'Tone', instructions: 'Be brief.' } }),
+      on('GET', '/books/b1', { json: { id: 'b1', name: 'Book' } }),
+      (c) => (c.method === 'GET' ? undefined : { json: { id: 'x' } }),
+    ]);
+    const sdk = new CampaignsSDK(new IndemnClient());
+    await sdk.createCampaign({ solution_id: 's', book_id: 'b', name: 'N', campaign_type: 'renewal' });
+    await sdk.publish('c1', 'first');
+    await sdk.setStatus('c1', 'paused');
+    await sdk.createTemplate({ solution_id: 's', name: 'T', channel: 'email', subject: 'S', body: 'B {{ record.account.name }}', uses_variables: ['record.account.name'] });
+    await sdk.createTemplateSkill({ solution_id: 's', key: 'tone', name: 'Tone', instructions: 'Be brief.' });
+    await sdk.updateTemplateSkill('s1', { instructions: 'Be warm.' });
+    await sdk.createBook({ solution_id: 's', name: 'Book' });
+    await sdk.updateBook('b1', { source: { kind: 'upload' }, identity_keys: ['policy.number'], display: { primary: ['policy.number'], secondary: ['insured.name'] } });
+    const writes = calls.filter((c) => c.method !== 'GET');
+    expect(seen(writes)).toEqual([
+      'POST /campaigns', 'POST /campaigns/c1/publish', 'POST /campaigns/c1/status', 'POST /templates', 'POST /template-skills',
+      'PUT /template-skills/s1', 'POST /books', 'PATCH /books/b1/source', 'PUT /books/b1/identity-keys', 'PUT /books/b1/display',
+    ]);
+    expect(writes.map((c) => c.body)).toEqual([
+      { solution_id: 's', book_id: 'b', name: 'N', campaign_type: 'renewal' }, { change_summary: 'first' }, { status: 'paused' },
+      { solution_id: 's', name: 'T', channel: 'email', subject: 'S', body: 'B {{ record.account.name }}', uses_variables: [{ key: 'record.account.name' }] }, { solution_id: 's', key: 'tone', name: 'Tone', instructions: 'Be brief.' },
+      { name: 'Tone', instructions: 'Be warm.' }, { solution_id: 's', name: 'Book' }, { source: { kind: 'upload' } },  // the service reads body.source
+      { identity_keys: ['policy.number'] }, { display: { primary: ['policy.number'], secondary: ['insured.name'] } },
+    ]);
+  });
 });

package/test/sdk/orgs.test.ts

@@ -58,6 +58,37 @@ describe('OrgsSDK', () => {
     await expect(new OrgsSDK(new IndemnClient({ orgId: A })).listMembers()).resolves.toEqual([]);
   });
 
+  it('invites by email into the project, as the dashboard does', async () => {
+    const { calls } = recordFetch([on('POST', '/project_users/invite', { json: { msg: 'User not found, save invite in pending ', pendingInvitation: { _id: 'i1' } } })]);
+    await expect(new OrgsSDK(new IndemnClient({ orgId: A })).inviteMember('p1', ' Jane@Acme.test ', 'agent')).resolves.toEqual({
+      email: 'jane@acme.test', role: 'agent', outcome: 'invited',
+      message: 'Invitation sent to jane@acme.test. They join as agent once they sign up from the email.',
+    });
+    expect(new URL(calls[0].url).pathname).toBe('/api/p1/project_users/invite');
+    expect(calls[0].body).toEqual({ email: 'jane@acme.test', role: 'agent', user_available: false, id_organization: A });
+  });
+
+  it('says when an existing account joined at once', async () => {
+    recordFetch([on('POST', '/project_users/invite', { json: { _id: 'pu1', role: 'admin', id_project: 'p1' } })]);
+    await expect(new OrgsSDK(new IndemnClient({ orgId: A })).inviteMember('p1', 'jo@acme.test', 'admin')).resolves.toMatchObject({ outcome: 'added', role: 'admin' });
+  });
+
+  it('already invited or already a member: nothing sent, said plainly', async () => {
+    recordFetch([on('POST', '/project_users/invite', { json: { success: false, msg: 'Pending Invitation already exist.', invite: {} } })]);
+    await expect(new OrgsSDK(new IndemnClient({ orgId: A })).inviteMember('p1', 'jane@acme.test', 'agent')).resolves.toMatchObject({
+      outcome: 'already_invited', message: 'jane@acme.test already has a pending invitation. Nothing was sent again.',
+    });
+    recordFetch([on('POST', '/project_users/invite', { status: 500, json: { success: false, msg: 'Forbidden. User is already a member', code: 4001, alreadyCurrentProjectMember: true } })]);
+    await expect(new OrgsSDK(new IndemnClient({ orgId: A })).inviteMember('p1', 'jo@acme.test', 'member')).resolves.toMatchObject({ outcome: 'already_member' });
+  });
+
+  it('refuses inviting yourself and keeps copilot\'s other refusals', async () => {
+    recordFetch([on('POST', '/project_users/invite', { status: 403, json: { success: false, msg: 'Forbidden. It is not allowed to invite oneself', code: 4000 } })]);
+    await expect(new OrgsSDK(new IndemnClient({ orgId: A })).inviteMember('p1', 'pat@acme.test', 'agent')).rejects.toThrow('You can\'t invite yourself. Nothing was sent.');
+    recordFetch([on('POST', '/project_users/invite', { status: 403, json: { success: false, msg: 'You don\'t have the required role.' } })]);
+    await expect(new OrgsSDK(new IndemnClient({ orgId: A })).inviteMember('p1', 'jane@acme.test', 'agent')).rejects.toThrow('Not allowed: You don\'t have the required role.');
+  });
+
   it('creates a sandbox org with only its name and links to it', async () => {
     const { calls } = recordFetch([on('POST', '/organization/sandbox', { json: { success: true, id_organization: A, id_project: 'p1', id_plan: 'plan1' } })]);
     await expect(new OrgsSDK(new IndemnClient()).createSandbox('Acme Insurance')).resolves.toEqual({