import { isRubyMuted, applyRubyToggle, RUBY_OFF_LABEL, RUBY_ON_LABEL } from '../whatsapp-assistant-state';

describe('ruby mute marker', () => {
  it('isRubyMuted true only when ruby-off present', () => {
    expect(isRubyMuted([])).toBe(false);
    expect(isRubyMuted([RUBY_ON_LABEL])).toBe(false);
    expect(isRubyMuted([RUBY_OFF_LABEL])).toBe(true);
  });

  it('applyRubyToggle(false) sets ruby-off and clears ruby-on', () => {
    expect(applyRubyToggle([RUBY_ON_LABEL], false)).toEqual([RUBY_OFF_LABEL]);
    expect(applyRubyToggle(['vip'], false)).toEqual(['vip', RUBY_OFF_LABEL]);
  });

  it('applyRubyToggle(true) clears ruby-off and adds ruby-on', () => {
    expect(applyRubyToggle([RUBY_OFF_LABEL], true)).toEqual([RUBY_ON_LABEL]);
    expect(applyRubyToggle(['vip', RUBY_OFF_LABEL], true)).toEqual(['vip', RUBY_ON_LABEL]);
  });

  it('applyRubyToggle is idempotent', () => {
    expect(applyRubyToggle(applyRubyToggle([], false), false)).toEqual([RUBY_OFF_LABEL]);
  });
});

export const RUBY_ON_LABEL = 'ruby-on';
export const RUBY_OFF_LABEL = 'ruby-off';

/** True when Ruby is explicitly turned on for this conversation. */
export function isRubyOn(labels: string[]): boolean {
  return labels.includes(RUBY_ON_LABEL);
}

/**
 * True when Ruby has been durably muted on this conversation — set when a human
 * takes over (model handoff via escalate(), or staff toggling Ruby off). In
 * autopilot mode Ruby engages every thread EXCEPT those carrying this marker.
 */
export function isRubyMuted(labels: string[]): boolean {
  return labels.includes(RUBY_OFF_LABEL);
}

/**
 * Pure label transition for a Ruby on/off toggle.
 *  on=true  → Ruby active: clear the mute, set the explicit on marker.
 *  on=false → Ruby muted (durable handoff): clear on marker, set the mute.
 */
export function applyRubyToggle(labels: string[], on: boolean): string[] {
  return on
    ? withLabel(withoutLabel(labels, RUBY_OFF_LABEL), RUBY_ON_LABEL)
    : withLabel(withoutLabel(labels, RUBY_ON_LABEL), RUBY_OFF_LABEL);
}

/** Add/remove the durable Ruby on/off markers on a conversation. */
export async function setRubyOn(conversationId: string, on: boolean): Promise<void> {
  const readDb = getReadDb();
  const [conv] = await readDb
    .select({ labels: conversations.labels })
    .from(conversations)
    .where(eq(conversations.id, conversationId));
  if (!conv) return;
  const updated = applyRubyToggle(conv.labels ?? [], on);
  const writeDb = getWriteDb();
  await writeDb.update(conversations).set({ labels: updated }).where(eq(conversations.id, conversationId));
}

git add server/src/lib/whatsapp-assistant-state.ts server/src/lib/__tests__/whatsapp-assistant-state.test.ts
git commit -m "feat(ruby): durable ruby-off mute marker + pure applyRubyToggle"

describe('shouldRubyAutoSend', () => {
  it('copilot mode never auto-sends', () => {
    expect(shouldRubyAutoSend('copilot', [])).toBe(false);
    expect(shouldRubyAutoSend('copilot', ['ruby-on'])).toBe(false);
  });
  it('autopilot engages a fresh (label-less) thread', () => {
    expect(shouldRubyAutoSend('autopilot', [])).toBe(true);
  });
  it('autopilot does NOT engage a muted (ruby-off) thread', () => {
    expect(shouldRubyAutoSend('autopilot', ['ruby-off'])).toBe(false);
  });
  it('off → never', () => {
    expect(shouldRubyAutoSend('off', [])).toBe(false);
  });
});

import { isRubyOn, setRubyOn } from './whatsapp-assistant-state';

import { isRubyMuted, setRubyOn } from './whatsapp-assistant-state';

/** Inline auto-send fires only in autopilot mode on an explicitly ruby-on thread. */
export function shouldRubyAutoSend(mode: AssistantMode, labels: string[]): boolean {
  return mode === 'autopilot' && isRubyOn(labels);
}

/**
 * Inline auto-send fires in autopilot mode on every thread EXCEPT those a human
 * has durably taken over (ruby-off marker). copilot/off never auto-send.
 */
export function shouldRubyAutoSend(mode: AssistantMode, labels: string[]): boolean {
  return mode === 'autopilot' && !isRubyMuted(labels);
}

    // 4. Per-thread gate — autopilot fires only on an explicitly ruby-on thread.
    if (!isRubyOn(ctx.labels)) { tag('skip', { reason: 'thread-off' }); return; }

    // 4. Per-thread mute — in autopilot Ruby engages EVERY thread except those a
    //    human has taken over (durable ruby-off marker set by escalate()).
    if (isRubyMuted(ctx.labels)) { tag('skip', { reason: 'thread-muted' }); return; }

git add server/src/lib/whatsapp-assistant-dispatch.ts server/src/lib/__tests__/whatsapp-assistant-dispatch.test.ts
git commit -m "feat(ruby): autopilot engages all threads unless durably muted"

import { describe, it, expect } from 'vitest';
import { PROMPTS } from '../prompts';

describe('whatsappAssistant prompt guardrails', () => {
  const p = PROMPTS.whatsappAssistant;
  it('keeps the clinical no-advice handoff rule', () => {
    expect(p).toContain('NEVER give any medical advice');
  });
  it('keeps the never-confirm-slot rule', () => {
    expect(p).toContain('NEVER picks or confirms the final appointment slot');
  });
  it('has a sensitive-data handoff rule', () => {
    expect(p.toLowerCase()).toContain('sensitive');
    expect(p).toContain('sensitive-data');
  });
  it('has a stay-on-topic rule', () => {
    expect(p).toContain('Stay On Topic');
  });
});

### Sensitive / Personal Data
→ If the patient sends sensitive personal data — national ID / CNIC, full card or bank details, or detailed medical history — do NOT process, store, or repeat it back to them. Acknowledge briefly and hand off: intent='escalate', action='handoff', escalate.reason='sensitive-data', reply="Thanks — for your security, a member of our team will follow up with you directly about this."

### Stay On Topic
→ You only handle dental-clinic reception topics: hours, location, services, pricing, appointments, and general clinic FAQ. For anything clearly off-topic, briefly steer back to how you can help with their dental visit. Do not engage with unrelated requests, opinions, or tasks.

git add server/src/lib/ai/prompts.ts server/src/lib/ai/__tests__/prompts.test.ts
git commit -m "feat(ruby): prompt guardrails for sensitive data + stay on topic"

const ALERT_SOUND_URL = '/sounds/notification_alert.mp3';
const ALERT_VOLUME = 0.5; // audible but not startling at a front desk

let alertAudio: HTMLAudioElement | null = null;

function getAlertAudio(): HTMLAudioElement | null {
  if (typeof window === 'undefined') return null;
  if (!alertAudio) {
    alertAudio = new Audio(ALERT_SOUND_URL);
    alertAudio.preload = 'auto';
    alertAudio.volume = ALERT_VOLUME;
  }
  return alertAudio;
}

/**
 * Warm the audio element on the first user gesture so the first real alert
 * plays without the browser autoplay delay. Safe to call repeatedly.
 */
export function primeNotificationSound(): void {
  const a = getAlertAudio();
  if (a) {
    try { a.load(); } catch { /* no-op */ }
  }
}

/**
 * Plays the single notification tone (notification_alert.mp3).
 *  - force:true → used for inbound WhatsApp messages; respects the per-inbox
 *    toggle (whatsappInboundSoundEnabled).
 *  - default    → used for escalation/system alerts; respects the global mute.
 */
export function playNotificationSound(options?: { force?: boolean }): void {
  if (options?.force) {
    if (!whatsappInboundSoundEnabled) return;
  } else if (muted) {
    return;
  }
  const a = getAlertAudio();
  if (!a) return;
  try {
    a.currentTime = 0;
    void a.play().catch(() => { /* autoplay blocked pre-gesture — ignore */ });
  } catch {
    /* best-effort; sound is never a correctness path */
  }
}

git add ui/src/lib/notification-sound.ts
git commit -m "feat(ui): use notification_alert.mp3 as the single notification tone"

import { playNotificationSound } from '@/lib/notification-sound';

                                if (isRubyEscalation) {
                                    notify.rubyEscalation(notification.message || 'A WhatsApp conversation needs a human.', {

                                if (isRubyEscalation) {
                                    // Mandatory audible alert so staff/doctor hear the handoff
                                    // anywhere in the app, not just the WhatsApp inbox.
                                    playNotificationSound();
                                    notify.rubyEscalation(notification.message || 'A WhatsApp conversation needs a human.', {

git add ui/src/components/providers/NotificationProvider.tsx
git commit -m "feat(ui): sound alert on Ruby WhatsApp escalation"