Agent sets mandate
once. Deals close automatically.

// Create autonomous mandate
POST /v1/mandates
Body:
  product_ref        string
  qty                number
  target_price       number
  max_price          number    ← hard ceiling, enforced server-side
  strategy           string    standard | aggressive
  auto_approve       boolean   true = autonomous mode
  max_orders_per_day number    default: 3
  max_daily_value    number    default: 500000
  expires_in_days    number    default: 30
  allowed_broker_ids string[]  optional whitelist
  allowed_countries  string[]  optional whitelist
Returns: {mandate_id, status:"active", auto_approve, expires_at}

// List mandates
GET /v1/mandates
GET /v1/mandates/{id}

// Cancel mandate (instant)
DELETE /v1/mandates/{id}

// Pause/resume
POST /v1/mandates/{id}/pause
POST /v1/mandates/{id}/resume

// Use mandate in negotiation
POST /v1/negotiate
Body: { mandate_id: "MND-001", ...other fields }
// auto_approve inherited from mandate

// Agent reputation
GET /v1/agents/{id}/reputation
Returns: {tier, deals_count, success_rate, floor_discount, on_chain_verified}

Body now accepts:
  mandate_id     string?   If set, inherits auto_approve + limits from mandate
  auto_approve   boolean?  Per-negotiation override (if no mandate)
  auto_approve_threshold  number?  Auto-approve if deal_price <= this value
                                   (must be <= max_price)

// Replaces AWAIT_HUMAN when auto_approve=true and conditions pass
AUTO_APPROVED
  deal_price      number
  total_value     number
  loi_ref         string    ← LOI already generated
  mandate_id      string
  conditions_met  string[]  list of checks that passed
  credits_used    number

// AWAIT_HUMAN still fires when:
// - auto_approve=false
// - deal_price > max_price (safety fallback)
// - compliance == "review" (not "cleared")
// - daily limits exceeded
// - mandate expired or paused

async function checkAutoApprove(negId, dealPrice, mandate, compliance) {
  // Condition 1: price within mandate ceiling
  if (dealPrice > mandate.max_price) return { approved: false, reason: 'price_exceeded' };

  // Condition 2: compliance cleared
  if (compliance.verdict !== 'cleared') return { approved: false, reason: 'compliance_' + compliance.verdict };

  // Condition 3: daily order cap
  const todayCount = await getTodayAutoApprovedCount(mandate.id);
  if (todayCount >= mandate.max_orders_per_day) return { approved: false, reason: 'daily_order_cap' };

  // Condition 4: daily value cap
  const todayValue = await getTodayAutoApprovedValue(mandate.id);
  if (todayValue + (dealPrice * mandate.qty) > mandate.max_daily_value)
    return { approved: false, reason: 'daily_value_cap' };

  // Condition 5: mandate still active
  if (!mandate.active || new Date() > new Date(mandate.expires_at))
    return { approved: false, reason: 'mandate_expired' };

  // All conditions met → auto-approve
  return {
    approved: true,
    conditions_met: ['price_ok', 'compliance_cleared', 'order_cap_ok', 'value_cap_ok', 'mandate_active']
  };
}

// In the negotiation loop, replace AWAIT_HUMAN logic:
if (agreed && mandate?.auto_approve) {
  const check = await checkAutoApprove(negId, dealPrice, mandate, complianceResult);

  if (check.approved) {
    // Skip AWAIT_HUMAN — generate LOI directly
    const loiRef = await generateLOI({ negId, dealPrice, mandate });
    await incrementMandateCounters(mandate.id, dealPrice * mandate.qty);
    emit('AUTO_APPROVED', { deal_price: dealPrice, loi_ref: loiRef, conditions_met: check.conditions_met });
    // Notify Boss AFTER (not before)
    notifyWhatsApp({ type: 'LOI_AUTO_GENERATED', data: { loiRef, dealPrice, mandate_id: mandate.id } });
  } else {
    // Fallback to manual
    emit('AWAIT_HUMAN', { deal_price: dealPrice, reason: check.reason });
  }
} else {
  // Standard manual mode
  emit('AWAIT_HUMAN', { deal_price: dealPrice });
}

CREATE TABLE mandates (
  id                  TEXT PRIMARY KEY,         -- MND-001
  user_id             UUID REFERENCES users(id),
  product_ref         TEXT REFERENCES products(ref),
  qty                 NUMERIC(12,2),
  unit                TEXT DEFAULT 'MT',
  target_price        NUMERIC(12,2),
  max_price           NUMERIC(12,2) NOT NULL,  ← hard ceiling
  strategy            TEXT DEFAULT 'standard',
  auto_approve        BOOLEAN DEFAULT false,
  max_orders_per_day  INT DEFAULT 3,
  max_daily_value     NUMERIC(14,2) DEFAULT 500000,
  allowed_broker_ids  TEXT[],
  allowed_countries   TEXT[],
  active              BOOLEAN DEFAULT true,
  expires_at          TIMESTAMPTZ,
  orders_today        INT DEFAULT 0,
  value_today         NUMERIC(14,2) DEFAULT 0,
  total_orders        INT DEFAULT 0,
  total_value         NUMERIC(14,2) DEFAULT 0,
  created_at          TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE agent_reputation (
  agent_id            UUID PRIMARY KEY REFERENCES users(id),
  tier                TEXT DEFAULT 'starter',
  deals_count         INT DEFAULT 0,
  success_rate        NUMERIC(5,2) DEFAULT 0,
  floor_discount      NUMERIC(4,3) DEFAULT 0,
  on_chain_verified   BOOLEAN DEFAULT false,
  wallet_address      TEXT,
  updated_at          TIMESTAMPTZ DEFAULT NOW()
);

-- Reset daily counters at midnight (cron)
UPDATE mandates SET orders_today=0, value_today=0
WHERE DATE(updated_at) < CURRENT_DATE;