@vellumai/assistant 0.3.15 → 0.3.18

package/src/__tests__/guardian-verify-setup-skill-regression.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Regression tests for the guardian-verify-setup skill.
+ *
+ * Ensures the voice verification flow includes proactive auto-check polling
+ * so the user does not have to manually ask whether verification succeeded.
+ */
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+
+// ---------------------------------------------------------------------------
+// Locate the skill SKILL.md
+// ---------------------------------------------------------------------------
+
+const ASSISTANT_DIR = resolve(import.meta.dirname ?? __dirname, '..', '..');
+const SKILL_PATH = resolve(
+  ASSISTANT_DIR,
+  'src',
+  'config',
+  'vellum-skills',
+  'guardian-verify-setup',
+  'SKILL.md',
+);
+
+const skillContent = readFileSync(SKILL_PATH, 'utf-8');
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('guardian-verify-setup skill — voice auto-followup', () => {
+  test('voice path in Step 3 references the auto-check polling loop', () => {
+    // The voice success instruction in Step 3 must direct the assistant to
+    // begin the polling loop rather than waiting for the user to report back.
+    expect(skillContent).toContain(
+      'immediately begin the voice auto-check polling loop',
+    );
+  });
+
+  test('voice path in Step 4 (resend) references the auto-check polling loop', () => {
+    // After a voice resend, the same auto-check behavior must kick in.
+    const resendSection = skillContent.split('## Step 4')[1]?.split('## Step 5')[0] ?? '';
+    expect(resendSection).toContain(
+      'voice auto-check polling loop',
+    );
+  });
+
+  test('contains a Voice Auto-Check Polling section', () => {
+    expect(skillContent).toContain('## Voice Auto-Check Polling');
+  });
+
+  test('polling section specifies the correct status endpoint for voice', () => {
+    const pollingSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    expect(pollingSection).toContain(
+      '/v1/integrations/guardian/status?channel=voice',
+    );
+  });
+
+  test('polling section includes ~15 second interval', () => {
+    const pollingSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    expect(pollingSection).toContain('~15 seconds');
+  });
+
+  test('polling section includes 2-minute timeout', () => {
+    const pollingSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    expect(pollingSection).toContain('2 minutes');
+  });
+
+  test('polling section checks for bound: true', () => {
+    const pollingSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    expect(pollingSection).toContain('bound: true');
+  });
+
+  test('polling section includes proactive success confirmation', () => {
+    const pollingSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    expect(pollingSection).toContain('proactive success message');
+  });
+
+  test('polling section includes timeout fallback with resend/restart offer', () => {
+    const pollingSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    expect(pollingSection).toContain('timeout');
+    expect(pollingSection).toContain('resend');
+  });
+
+  test('polling section includes rebind guard against false-success from pre-existing binding', () => {
+    const pollingSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    // Must mention rebind guard concept
+    expect(pollingSection).toContain('Rebind guard');
+    // Must instruct not to trust the first bound: true in a rebind flow
+    expect(pollingSection).toContain(
+      'do NOT treat the first `bound: true` poll result as success',
+    );
+    // Must reference bound_at timestamp comparison as the primary mechanism
+    expect(pollingSection).toContain('bound_at');
+    // Must have a fallback for when bound_at is unavailable
+    expect(pollingSection).toContain('second poll onward');
+    // Must clarify non-rebind flows are unaffected
+    expect(pollingSection).toContain('Non-rebind flows');
+  });
+
+  test('polling is voice-only — does not apply to SMS or Telegram', () => {
+    const pollingSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    expect(pollingSection).toContain('voice-only');
+    expect(pollingSection).toContain('Do NOT poll for SMS or Telegram');
+  });
+
+  test('no instruction requires waiting for user to ask "did it work?"', () => {
+    // The skill should never instruct the assistant to wait for the user to
+    // confirm that voice verification worked. The auto-check polling loop
+    // makes this unnecessary.
+    const voiceAutoCheckSection =
+      skillContent.split('## Voice Auto-Check Polling')[1]?.split('## Step 6')[0] ?? '';
+    expect(voiceAutoCheckSection).toContain(
+      'Do NOT require the user to ask',
+    );
+    // The voice bullet in Step 3 should not instruct the assistant to wait
+    // for the user to confirm or ask if it worked. Narrow to just the voice
+    // bullet line to avoid false positives from Telegram's "wait for the
+    // user to confirm they clicked the link" which is unrelated to voice.
+    const step3Section = skillContent
+      .split('## Step 3')[1]
+      ?.split('## Step 4')[0] ?? '';
+    const voiceBullet = step3Section
+      .split('\n')
+      .filter((line) => /^\s*-\s+\*\*Voice\*\*/.test(line))
+      .join('\n');
+    expect(voiceBullet).not.toHaveLength(0);
+    expect(voiceBullet).not.toContain('wait for the user to confirm');
+    expect(voiceBullet).not.toContain('ask the user if it worked');
+  });
+});

package/src/__tests__/handlers-telegram-config.test.ts

@@ -785,7 +785,6 @@ describe('Telegram config handler', () => {
     expect((setCommandsBody as { commands: Array<{ command: string; description: string }> }).commands).toEqual([
       { command: 'new', description: 'Start a new conversation' },
       { command: 'help', description: 'Show available commands' },
-      { command: 'guardian_verify', description: 'Verify your guardian identity' },
     ]);
   });
 
@@ -865,7 +864,7 @@ describe('Telegram config handler', () => {
     expect(res.error).toContain('Failed to set bot commands');
   });
 
-  test('default command registration includes /new, /help, and /guardian_verify', async () => {
+  test('default command registration includes /new and /help', async () => {
     secureKeyStore['credential:telegram:bot_token'] = 'test-bot-token';
     secureKeyStore['credential:telegram:webhook_secret'] = 'test-webhook-secret';
 
@@ -893,11 +892,10 @@ describe('Telegram config handler', () => {
     expect(res.success).toBe(true);
 
     const commands = (setCommandsBody as { commands: Array<{ command: string; description: string }> }).commands;
-    expect(commands).toHaveLength(3);
+    expect(commands).toHaveLength(2);
     expect(commands).toEqual([
       { command: 'new', description: 'Start a new conversation' },
       { command: 'help', description: 'Show available commands' },
-      { command: 'guardian_verify', description: 'Verify your guardian identity' },
     ]);
   });
 });
@@ -950,7 +948,8 @@ describe('Guardian verification IPC actions', () => {
     expect(res.success).toBe(true);
     expect(res.secret).toBeDefined();
     expect(res.instruction).toBeDefined();
-    expect(res.instruction).toContain('/guardian_verify');
+    expect(res.instruction).toContain('send');
+    expect(res.instruction).toContain('code');
   });
 
   test('unknown action returns error', () => {
@@ -985,7 +984,8 @@ describe('Guardian verification IPC actions', () => {
     const res = sent[0] as { type: string; success: boolean; secret?: string; instruction?: string };
     expect(res.success).toBe(true);
     expect(res.secret).toBeDefined();
-    expect(res.instruction).toContain('/guardian_verify');
+    expect(res.instruction).toContain('send');
+    expect(res.instruction).toContain('code');
   });
 
   test('status action with explicit assistantId checks binding for that assistant', () => {

package/src/__tests__/hooks-runner.test.ts

@@ -135,10 +135,19 @@ describe('Hook Runner', () => {
     expect(wsDir).toStartWith(rootDir);
   });
 
-  // Skip: child.kill() + 'close' event is unreliable on macOS when the hook
-  // script is a bash process tree — SIGTERM/SIGKILL may not trigger 'close',
-  // causing the test to hang. The timeout logic works in production but is
-  // not deterministically testable in unit tests.
+  // SKIPPED: child.kill() + 'close' event is unreliable on macOS when the hook
+  // script is a bash process tree — SIGTERM/SIGKILL may not trigger the 'close'
+  // event, causing the test to hang indefinitely. The timeout logic in runner.ts
+  // (lines 90-102) works correctly in production, but the combination of
+  // `sleep 10` in a child bash process + kill + waiting for 'close' is not
+  // deterministically testable in unit tests on macOS.
+  //
+  // Re-enable when:
+  // - Bun's child_process reliably emits 'close' after SIGKILL on macOS, OR
+  // - The runner is refactored to use Bun.spawn() (which has different process
+  //   group semantics), OR
+  // - A test-only flag is added to use a more controllable timeout mechanism
+  //   (e.g., AbortController) instead of child.kill().
   test.skip('[experimental] times out after specified duration', async () => {
     const hook = createTestHook(hooksDir, 'slow-hook', '#!/bin/bash\nsleep 10');
     const eventData: HookEventData = { event: 'pre-tool-execute' };

package/src/__tests__/ingress-routes-http.test.ts

@@ -0,0 +1,443 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+
+const testDir = mkdtempSync(join(tmpdir(), 'ingress-routes-http-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+import { getSqlite, initializeDb, resetDb } from '../memory/db.js';
+import {
+  handleBlockMember,
+  handleCreateInvite,
+  handleListInvites,
+  handleListMembers,
+  handleRedeemInvite,
+  handleRevokeInvite,
+  handleRevokeMember,
+  handleUpsertMember,
+} from '../runtime/routes/ingress-routes.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
+
+function resetTables() {
+  getSqlite().run('DELETE FROM assistant_ingress_members');
+  getSqlite().run('DELETE FROM assistant_ingress_invites');
+}
+
+// ---------------------------------------------------------------------------
+// Member routes
+// ---------------------------------------------------------------------------
+
+describe('ingress member HTTP routes', () => {
+  beforeEach(resetTables);
+
+  test('POST /v1/ingress/members — upsert creates a member', async () => {
+    const req = new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'telegram',
+        externalUserId: 'user-1',
+        displayName: 'Test User',
+        policy: 'allow',
+        status: 'active',
+      }),
+    });
+
+    const res = await handleUpsertMember(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.member).toBeDefined();
+    const member = body.member as Record<string, unknown>;
+    expect(member.sourceChannel).toBe('telegram');
+    expect(member.externalUserId).toBe('user-1');
+    expect(member.displayName).toBe('Test User');
+    expect(member.policy).toBe('allow');
+    expect(member.status).toBe('active');
+  });
+
+  test('POST /v1/ingress/members — missing sourceChannel returns 400', async () => {
+    const req = new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        externalUserId: 'user-1',
+      }),
+    });
+
+    const res = await handleUpsertMember(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error).toContain('sourceChannel');
+  });
+
+  test('POST /v1/ingress/members — missing identity returns 400', async () => {
+    const req = new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'telegram',
+      }),
+    });
+
+    const res = await handleUpsertMember(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error).toContain('externalUserId');
+  });
+
+  test('GET /v1/ingress/members — lists members', async () => {
+    // Create two members
+    await handleUpsertMember(new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram', externalUserId: 'user-1', status: 'active' }),
+    }));
+    await handleUpsertMember(new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram', externalUserId: 'user-2', status: 'active' }),
+    }));
+
+    const url = new URL('http://localhost/v1/ingress/members');
+    const res = handleListMembers(url);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(Array.isArray(body.members)).toBe(true);
+    expect((body.members as unknown[]).length).toBe(2);
+  });
+
+  test('GET /v1/ingress/members — filters by sourceChannel', async () => {
+    await handleUpsertMember(new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram', externalUserId: 'user-1', status: 'active' }),
+    }));
+    await handleUpsertMember(new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'sms', externalUserId: 'user-2', status: 'active' }),
+    }));
+
+    const url = new URL('http://localhost/v1/ingress/members?sourceChannel=telegram');
+    const res = handleListMembers(url);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect((body.members as unknown[]).length).toBe(1);
+  });
+
+  test('DELETE /v1/ingress/members/:id — revokes a member', async () => {
+    const createRes = await handleUpsertMember(new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram', externalUserId: 'user-1', status: 'active' }),
+    }));
+    const created = await createRes.json() as { member: { id: string } };
+
+    const req = new Request('http://localhost/v1/ingress/members/' + created.member.id, {
+      method: 'DELETE',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ reason: 'test revoke' }),
+    });
+    const res = await handleRevokeMember(req, created.member.id);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body.ok).toBe(true);
+    const member = body.member as Record<string, unknown>;
+    expect(member.status).toBe('revoked');
+  });
+
+  test('DELETE /v1/ingress/members/:id — not found returns 404', async () => {
+    const req = new Request('http://localhost/v1/ingress/members/nonexistent', {
+      method: 'DELETE',
+    });
+    const res = await handleRevokeMember(req, 'nonexistent');
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(404);
+    expect(body.ok).toBe(false);
+  });
+
+  test('POST /v1/ingress/members/:id/block — blocks a member', async () => {
+    const createRes = await handleUpsertMember(new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram', externalUserId: 'user-1', status: 'active' }),
+    }));
+    const created = await createRes.json() as { member: { id: string } };
+
+    const req = new Request('http://localhost/v1/ingress/members/' + created.member.id + '/block', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ reason: 'spam' }),
+    });
+    const res = await handleBlockMember(req, created.member.id);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body.ok).toBe(true);
+    const member = body.member as Record<string, unknown>;
+    expect(member.status).toBe('blocked');
+  });
+
+  test('POST /v1/ingress/members/:id/block — already blocked returns 404', async () => {
+    const createRes = await handleUpsertMember(new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram', externalUserId: 'user-1', status: 'active' }),
+    }));
+    const created = await createRes.json() as { member: { id: string } };
+
+    // Block first time
+    await handleBlockMember(
+      new Request('http://localhost/block', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      }),
+      created.member.id,
+    );
+
+    // Block second time
+    const req = new Request('http://localhost/block', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+    const res = await handleBlockMember(req, created.member.id);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(404);
+    expect(body.ok).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Invite routes
+// ---------------------------------------------------------------------------
+
+describe('ingress invite HTTP routes', () => {
+  beforeEach(resetTables);
+
+  test('POST /v1/ingress/invites — creates an invite', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'telegram',
+        note: 'Test invite',
+        maxUses: 5,
+      }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(201);
+    expect(body.ok).toBe(true);
+    const invite = body.invite as Record<string, unknown>;
+    expect(invite.sourceChannel).toBe('telegram');
+    expect(invite.note).toBe('Test invite');
+    expect(invite.maxUses).toBe(5);
+    expect(invite.status).toBe('active');
+    // Raw token should be returned on create
+    expect(typeof invite.token).toBe('string');
+    expect((invite.token as string).length).toBeGreaterThan(0);
+  });
+
+  test('POST /v1/ingress/invites — missing sourceChannel returns 400', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ note: 'No channel' }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error).toContain('sourceChannel');
+  });
+
+  test('GET /v1/ingress/invites — lists invites', async () => {
+    // Create two invites
+    await handleCreateInvite(new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram' }),
+    }));
+    await handleCreateInvite(new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram' }),
+    }));
+
+    const url = new URL('http://localhost/v1/ingress/invites');
+    const res = handleListInvites(url);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(Array.isArray(body.invites)).toBe(true);
+    expect((body.invites as unknown[]).length).toBe(2);
+  });
+
+  test('DELETE /v1/ingress/invites/:id — revokes an invite', async () => {
+    const createRes = await handleCreateInvite(new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram' }),
+    }));
+    const created = await createRes.json() as { invite: { id: string } };
+
+    const res = handleRevokeInvite(created.invite.id);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body.ok).toBe(true);
+    const invite = body.invite as Record<string, unknown>;
+    expect(invite.status).toBe('revoked');
+  });
+
+  test('DELETE /v1/ingress/invites/:id — not found returns 404', () => {
+    const res = handleRevokeInvite('nonexistent-id');
+    expect(res.status).toBe(404);
+  });
+
+  test('POST /v1/ingress/invites/redeem — redeems an invite', async () => {
+    // Create an invite first
+    const createRes = await handleCreateInvite(new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram', maxUses: 1 }),
+    }));
+    const created = await createRes.json() as { invite: { token: string } };
+
+    const req = new Request('http://localhost/v1/ingress/invites/redeem', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        token: created.invite.token,
+        externalUserId: 'redeemer-1',
+        sourceChannel: 'telegram',
+      }),
+    });
+
+    const res = await handleRedeemInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body.ok).toBe(true);
+    const invite = body.invite as Record<string, unknown>;
+    expect(invite.useCount).toBe(1);
+    // Single-use invite should be fully redeemed
+    expect(invite.status).toBe('redeemed');
+  });
+
+  test('POST /v1/ingress/invites/redeem — missing token returns 400', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites/redeem', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ externalUserId: 'redeemer-1' }),
+    });
+
+    const res = await handleRedeemInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error).toContain('token');
+  });
+
+  test('POST /v1/ingress/invites/redeem — invalid token returns 400', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites/redeem', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ token: 'invalid-token' }),
+    });
+
+    const res = await handleRedeemInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// IPC backward compatibility — shared logic produces same results
+// ---------------------------------------------------------------------------
+
+describe('ingress service shared logic', () => {
+  beforeEach(resetTables);
+
+  test('member upsert + list round-trip through shared service', async () => {
+    const createRes = await handleUpsertMember(new Request('http://localhost/v1/ingress/members', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'telegram',
+        externalUserId: 'user-rt',
+        displayName: 'Round Trip',
+        policy: 'allow',
+        status: 'active',
+      }),
+    }));
+    const created = await createRes.json() as { member: { id: string; displayName: string } };
+    expect(created.member.displayName).toBe('Round Trip');
+
+    const listRes = handleListMembers(new URL('http://localhost/v1/ingress/members'));
+    const listed = await listRes.json() as { members: Array<{ id: string; displayName: string }> };
+    expect(listed.members.length).toBe(1);
+    expect(listed.members[0].id).toBe(created.member.id);
+  });
+
+  test('invite create + revoke round-trip through shared service', async () => {
+    const createRes = await handleCreateInvite(new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceChannel: 'telegram' }),
+    }));
+    const created = await createRes.json() as { invite: { id: string; status: string } };
+    expect(created.invite.status).toBe('active');
+
+    const revokeRes = handleRevokeInvite(created.invite.id);
+    const revoked = await revokeRes.json() as { invite: { id: string; status: string } };
+    expect(revoked.invite.status).toBe('revoked');
+    expect(revoked.invite.id).toBe(created.invite.id);
+  });
+});

package/src/__tests__/intent-routing.test.ts

@@ -312,4 +312,18 @@ describe('Guardian verification routing section in system prompt', () => {
     // Must advise not to re-ask channel if already specified
     expect(lower.includes('do not re-ask') || lower.includes('already specified')).toBe(true);
   });
+
+  test('routing section disambiguates "set myself up as your guardian" phrasing', () => {
+    const prompt = buildSystemPrompt();
+    const lower = prompt.toLowerCase();
+    expect(lower).toContain('help me set myself up as your guardian');
+    expect(lower).toContain('asking to verify themselves as guardian');
+  });
+
+  test('routing section discourages conceptual detours for direct setup requests', () => {
+    const prompt = buildSystemPrompt();
+    const lower = prompt.toLowerCase();
+    expect(lower).toContain('do not give conceptual');
+    expect(lower).toContain('unless the user explicitly asks');
+  });
 });