feat(crm): client-meeting batch — contact-pill cleanup, assignment toggle, receipt manual mode

CM-4: remove Email/Call/WhatsApp deep-link pills from the client + interest
  detail headers; relocate GDPR export into the client-header action cluster
  as a compact icon. Keeps the interest "Log contact" quick action.
CM-5: gate the interest assignment feature behind a per-port `assignment_enabled`
  setting (default OFF for single-rep ports). Hides the AssignedToChip +
  residential assigned-to row and skips tier-2/3 auto-assign on create; the
  column + data are preserved and reversible. Tests cover the auto-assign guard.
CM-6: add a per-port `manualEntry` receipt mode (skip all parsing → empty form).
  Threaded through ocr-config.service, the admin OCR form, the scan-receipt
  route, and the scanner shell (skips Tesseract + the server call). Tests cover
  the save/resolve round-trip.

Verified: tsc clean, lint 0 errors, 1631 vitest pass, prod build green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

tests/integration/interests-assignment-toggle.test.ts

@@ -0,0 +1,94 @@
+/**
+ * CM-5: interest assignment is gated behind the per-port `assignment_enabled`
+ * setting. When off (the default), createInterest must NOT auto-assign an owner
+ * even when a `default_new_interest_owner` is configured. When on, the existing
+ * tier-2 (port default-owner) auto-assign fires. An explicit `assignedTo` from
+ * the caller (tier 1) is always honored regardless of the toggle.
+ */
+import { describe, it, expect, beforeAll, afterEach } from 'vitest';
+import { eq } from 'drizzle-orm';
+
+import { db } from '@/lib/db';
+import { systemSettings } from '@/lib/db/schema/system';
+import { userProfiles } from '@/lib/db/schema/users';
+
+// interests.assigned_to FKs to user_profiles(user_id); the owner must exist.
+const OWNER = 'cm5-default-owner';
+
+describe('interests.service - assignment_enabled gate (CM-5)', () => {
+  let createInterest: typeof import('@/lib/services/interests.service').createInterest;
+  let makePort: typeof import('../helpers/factories').makePort;
+  let makeClient: typeof import('../helpers/factories').makeClient;
+  let makeAuditMeta: typeof import('../helpers/factories').makeAuditMeta;
+
+  beforeAll(async () => {
+    const svc = await import('@/lib/services/interests.service');
+    createInterest = svc.createInterest;
+    const factories = await import('../helpers/factories');
+    makePort = factories.makePort;
+    makeClient = factories.makeClient;
+    makeAuditMeta = factories.makeAuditMeta;
+    // Idempotent owner profile - left in place (created interests reference it,
+    // so we never delete it in teardown).
+    await db
+      .insert(userProfiles)
+      .values({ userId: OWNER, displayName: 'CM5 Default Owner' })
+      .onConflictDoNothing();
+  });
+
+  afterEach(async () => {
+    await db.delete(systemSettings).where(eq(systemSettings.key, 'assignment_enabled'));
+    await db.delete(systemSettings).where(eq(systemSettings.key, 'default_new_interest_owner'));
+  });
+
+  async function setSetting(portId: string, key: string, value: unknown) {
+    await db.insert(systemSettings).values({ key, portId, value: value as never });
+  }
+
+  it('does NOT auto-assign the port default owner when assignment is disabled (default)', async () => {
+    const port = await makePort();
+    const client = await makeClient({ portId: port.id });
+    // A default owner IS configured, but the feature is OFF - the guard must
+    // skip tier-2 entirely and leave the interest unassigned.
+    await setSetting(port.id, 'default_new_interest_owner', { userId: OWNER });
+
+    const interest = await createInterest(
+      port.id,
+      { clientId: client.id, pipelineStage: 'enquiry', tagIds: [], reminderEnabled: false },
+      makeAuditMeta({ portId: port.id }),
+    );
+    expect(interest.assignedTo).toBeNull();
+  });
+
+  it('auto-assigns the port default owner when assignment is enabled', async () => {
+    const port = await makePort();
+    const client = await makeClient({ portId: port.id });
+    await setSetting(port.id, 'assignment_enabled', true);
+    await setSetting(port.id, 'default_new_interest_owner', { userId: OWNER });
+
+    const interest = await createInterest(
+      port.id,
+      { clientId: client.id, pipelineStage: 'enquiry', tagIds: [], reminderEnabled: false },
+      makeAuditMeta({ portId: port.id }),
+    );
+    expect(interest.assignedTo).toBe(OWNER);
+  });
+
+  it('always honors an explicit assignedTo regardless of the toggle', async () => {
+    const port = await makePort();
+    const client = await makeClient({ portId: port.id });
+    // Feature off, but the caller explicitly picked an owner - tier 1 wins.
+    const interest = await createInterest(
+      port.id,
+      {
+        clientId: client.id,
+        assignedTo: OWNER,
+        pipelineStage: 'enquiry',
+        tagIds: [],
+        reminderEnabled: false,
+      },
+      makeAuditMeta({ portId: port.id }),
+    );
+    expect(interest.assignedTo).toBe(OWNER);
+  });
+});

tests/integration/ocr-config.test.ts

@@ -147,6 +147,60 @@ describe('OCR config', () => {
     expect(resolved.aiEnabled).toBe(false);
   });
 
+  // CM-6: manual-entry mode (skip all parsing) - mirrors the aiEnabled contract.
+  it('manualEntry defaults to false and round-trips when toggled', async () => {
+    const port = await makePort();
+    await saveOcrConfig(
+      port.id,
+      { provider: 'openai', model: 'gpt-4o-mini', apiKey: 'sk-y' },
+      'user-1',
+    );
+    let resolved = await getResolvedOcrConfig(port.id);
+    expect(resolved.manualEntry).toBe(false);
+
+    await saveOcrConfig(
+      port.id,
+      { provider: 'openai', model: 'gpt-4o-mini', manualEntry: true },
+      'user-1',
+    );
+    resolved = await getResolvedOcrConfig(port.id);
+    expect(resolved.manualEntry).toBe(true);
+    expect(resolved.apiKey).toBe('sk-y'); // toggling the mode never wipes the key
+  });
+
+  it('manualEntry is preserved when other fields change', async () => {
+    const port = await makePort();
+    await saveOcrConfig(
+      port.id,
+      { provider: 'openai', model: 'gpt-4o-mini', apiKey: 'sk-z', manualEntry: true },
+      'user-1',
+    );
+    // Update the model only - manualEntry must survive (mirrors aiEnabled).
+    await saveOcrConfig(port.id, { provider: 'openai', model: 'gpt-4o' }, 'user-1');
+    const resolved = await getResolvedOcrConfig(port.id);
+    expect(resolved.manualEntry).toBe(true);
+    expect(resolved.model).toBe('gpt-4o');
+  });
+
+  it('manualEntry shows on the public view and is forced false at global scope', async () => {
+    await saveOcrConfig(
+      null,
+      { provider: 'openai', model: 'gpt-4o-mini', apiKey: 'g', manualEntry: true },
+      'user-1',
+    );
+    const port = await makePort();
+    const resolved = await getResolvedOcrConfig(port.id);
+    expect(resolved.manualEntry).toBe(false); // per-port, never inherited from global
+
+    await saveOcrConfig(
+      port.id,
+      { provider: 'openai', model: 'gpt-4o-mini', manualEntry: true },
+      'user-1',
+    );
+    const pub = await getPublicOcrConfig(port.id);
+    expect(pub.manualEntry).toBe(true);
+  });
+
   it('global rows force useGlobal=false on save (not meaningful at global scope)', async () => {
     await saveOcrConfig(
       null,