RevOps Pipeline

await kairn.souls.create({
  name: 'revops',
  label: 'Pipeline Assistant',
  soulMd: `
    You are a pipeline assistant for a B2B SaaS sales team.

    Your job:
    - Help sales reps update and track their deals
    - Surface stale deals that need attention
    - Summarise call notes and extract next actions
    - Flag deals at risk based on inactivity or signals

    Behaviour rules:
    - Always check memory before asking the rep for context you already have
    - Extract structured data from unstructured call notes (stage, next step, risk flags)
    - When updating a deal, confirm the change before writing to memory
    - Keep a rep-specific deal list in memory — update it after every interaction
    - Be direct and efficient — reps are busy, not looking for chat

    Deal stages: prospect → qualified → demo → proposal → negotiation → closed_won | closed_lost
  `,
  defaultModel: 'anthropic/claude-sonnet-4-6',
})

async function seedRepContext(repId: string) {
  const rep   = await crm.users.get(repId)
  const deals = await crm.deals.listByOwner(repId, { status: 'open' })

  const dealMemory: Record<string, string> = {
    rep_name:        rep.name,
    rep_quota:       String(rep.quotaUsd),
    rep_attainment:  String(rep.attainmentPct),
    open_deal_count: String(deals.length),
  }

  for (const deal of deals) {
    const p = `deal_${deal.id}`
    dealMemory[`${p}_name`]          = deal.companyName
    dealMemory[`${p}_stage`]         = deal.stage
    dealMemory[`${p}_value`]         = String(deal.valueUsd)
    dealMemory[`${p}_last_activity`] = deal.lastActivityDate
    dealMemory[`${p}_next_step`]     = deal.nextStep ?? ''
    dealMemory[`${p}_contact`]       = deal.primaryContactName ?? ''
  }

  await kairn.memory.set(repId, 'default', dealMemory)
}

// POST /api/revops/call-notes
export async function POST(req: Request) {
  const { repId, dealId, notes } = await req.json()

  const result = await kairn.invoke({
    agent: 'revops',
    userId: repId,
    input: `
      I just got off a call with ${dealId}.
      Here are my notes:

      ${notes}

      Extract:
      1. Current deal stage (if mentioned or implied)
      2. Next step and owner
      3. Risk signals (budget concern, competitor, delay, no decision)
      4. A one-line summary

      Then update memory with the extracted values under deal_${dealId}_*.
      Confirm what you updated.
    `,
  })

  // Optionally sync back to your CRM
  if (result.memoryDelta) {
    await syncDealMemoryToCRM(dealId, result.memoryDelta)
  }

  return Response.json({ summary: result.output, updated: result.memoryDelta })
}

await kairn.mandates.create({
  userId: repId,
  soul: 'revops',
  label: 'Morning pipeline review',
  taskPrompt: `
    Review the rep's open deals in memory.
    Identify deals with no activity in the last 7+ days.
    For each stale deal, write a nudge under "nudge_{deal_id}".
    Write a summary under "morning_brief" with:
    - Total open deals
    - Deals needing attention (stale or no next step)
    - Top 3 deals to focus on today (by value and stage)
  `,
  trigger: {
    type: 'cron',
    cron: '0 8 * * 1-5', // 8am Monday–Friday
  },
})

export async function getRepBrief(repId: string) {
  const memory  = await kairn.memory.get(repId, 'default')
  const dealIds = Object.keys(memory)
    .filter(k => k.match(/^deal_(.+)_name$/))
    .map(k => k.replace(/^deal_(.+)_name$/, '$1'))

  const deals = dealIds.map(id => ({
    id,
    name:         memory[`deal_${id}_name`],
    stage:        memory[`deal_${id}_stage`],
    value:        Number(memory[`deal_${id}_value`]),
    lastActivity: memory[`deal_${id}_last_activity`],
    nextStep:     memory[`deal_${id}_next_step`],
    nudge:        memory[`nudge_${id}`] ?? null,
  }))

  return {
    repName:      memory.rep_name,
    morningBrief: memory.morning_brief ?? null,
    deals:        deals.sort((a, b) => b.value - a.value),
  }
}