@dev-adoption/cli 0.1.8

package/src/index.mjs

@@ -0,0 +1,2753 @@
+// dai — Developer Adoption Intelligence CLI.
+//
+// Commands:
+//   dai login                         - OAuth device-code login
+//   dai logout                        - Clear credentials
+//   dai stack add <tool>              - Add a tool to your public stack
+//   dai stack remove <tool>           - Remove a tool from your stack
+//   dai stack sync                    - Sync local package.json into your stack
+//   dai submit <challenge> [--file]   - Submit a challenge entry
+//   dai proof <tool>                  - Print the public adoption proof JSON
+//   dai rank [tool]                   - Show live AI Adoption Score rankings
+//   dai notifications                 - List unread notifications
+//   dai digest                        - Fetch this week's personalized digest
+//   dai mcp serve                     - Start the MCP stdio server for Cursor/Codex
+//   dai project draft                 - Draft a project from the current repo
+//   dai project publish --yes         - Publish the current repo to tokens&
+//   dai whoami                        - Show the signed-in account
+//   dai version                       - Print CLI version
+//
+// The CLI keeps zero runtime dependencies so it works on a locked-down
+// developer box without pulling a tree on first use.
+
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, join } from 'node:path'
+
+const VERSION = '0.1.8'
+const CLI_PACKAGE_SPEC = `@dev-adoption/cli@${VERSION}`
+const ENTERPRISE_GROWTH_PROMISE = 'Create a tracked developer session, invite the right builders, onboard partner companies, and prove adoption.'
+const ENTERPRISE_ADOPTION_BOUNDARY =
+  'Tokens& creates tracking, partner intake, ICP preview, and proof. It does not create Luma/Zoom/Eventbrite pages or send external invites without approval.'
+const DEFAULT_API = process.env.DAI_API_URL || 'https://tokensand.com'
+const CONFIG_PATH = join(homedir(), '.dai', 'config.json')
+const TRACKING_TIMEOUT_MS = 900
+const MODE_VALUES = new Set(['auto', 'public', 'developer', 'enterprise'])
+
+const ENTERPRISE_PROFILE_PRESETS = {
+  redis: {
+    company: 'Redis',
+    segment: 'data infrastructure and backend platform teams',
+    sessionLabel: 'AI app performance workshop',
+    buyerProblem: 'Convert cache/search/vector interest into production workload proof.',
+    defaultBudgetUsd: 45000,
+    benchmark: { registrations: 180, attended: 102, builders: 54, activated: 31, retained: 14, proofCount: 9 },
+    events: ['workshop_registered', 'lab_completed', 'database_connected', 'production_workload_proof'],
+    icpSegments: [
+      {
+        name: 'AI app teams adding semantic cache or vector retrieval to a live backend',
+        score: 94,
+        why: 'They have an urgent latency/cost pain and can produce repo, demo, and workload proof quickly.',
+      },
+      {
+        name: 'Platform/data infrastructure teams modernizing cache, search, or queue layers',
+        score: 86,
+        why: 'They can expand across multiple workloads, but proof cycles need account-owner handoff.',
+      },
+      {
+        name: 'B2B SaaS teams shipping retrieval-heavy agent features',
+        score: 81,
+        why: 'They are easier to activate through Codex/Cursor but need a retained-usage reward to avoid one-off demos.',
+      },
+    ],
+    sessionFormats: [
+      {
+        format: 'hands-on performance lab',
+        cadence: '2 sessions in 10 days, then one retained-usage proof sprint',
+        why: 'Best match when proof rate is the bottleneck: every attendee leaves with a repo/demo and a measured Redis event.',
+      },
+      {
+        format: 'cache/vector schema clinic',
+        cadence: 'weekly office-hours queue for activated projects',
+        why: 'Best follow-up for builders who reached first success but have not retained production-like usage.',
+      },
+      {
+        format: 'partner proof sprint',
+        cadence: 'one focused challenge with 7-day submission window',
+        why: 'Best when the offer is credits plus featured proof, not broad awareness.',
+      },
+    ],
+    offers: [
+      'Redis Cloud credits tied to a working AI app demo',
+      '30-minute cache/vector schema review for projects that ship proof',
+      'Featured project badge for retained production usage',
+    ],
+  },
+  assemblyai: {
+    company: 'AssemblyAI',
+    segment: 'voice AI builders and product engineering teams',
+    sessionLabel: 'voice agent build session',
+    buyerProblem: 'Move transcript demos into retained voice/agent workflows.',
+    defaultBudgetUsd: 38000,
+    benchmark: { registrations: 140, attended: 84, builders: 46, activated: 29, retained: 13, proofCount: 8 },
+    events: ['session_attended', 'api_key_created', 'first_transcript_completed', 'voice_agent_demo_published'],
+    icpSegments: [
+      { name: 'Voice agent product teams', score: 93, why: 'They can turn a demo into retained transcript, streaming, or agent workflow evidence.' },
+      { name: 'Support automation teams', score: 84, why: 'They have measurable time-saved outcomes but need privacy-safe proof boundaries.' },
+      { name: 'Creator/audio app builders', score: 76, why: 'High activation rate, but lower enterprise expansion unless account use is instrumented.' },
+    ],
+    sessionFormats: [
+      { format: 'voice agent build lab', cadence: 'one build lab plus 48-hour review queue', why: 'Optimizes for first transcript and published demo proof.' },
+      { format: 'streaming API clinic', cadence: 'weekly retained-workflow office hours', why: 'Best after activation when quality, latency, and cost need tuning.' },
+      { format: 'customer-workflow challenge', cadence: '7-day proof sprint', why: 'Forces a real workflow instead of a toy audio demo.' },
+    ],
+    offers: [
+      'API credits for a published voice agent demo',
+      'Solution review for teams that process retained production audio',
+      'Founder office hours for proofs with customer evidence',
+    ],
+  },
+  clickhouse: {
+    company: 'ClickHouse',
+    segment: 'analytics engineering and data-intensive AI teams',
+    sessionLabel: 'real-time analytics build lab',
+    buyerProblem: 'Turn analytics curiosity into instrumented retained workloads.',
+    defaultBudgetUsd: 42000,
+    benchmark: { registrations: 165, attended: 91, builders: 48, activated: 27, retained: 16, proofCount: 10 },
+    events: ['event_pipeline_started', 'query_dashboard_created', 'latency_claim_verified', 'production_dataset_connected'],
+    icpSegments: [
+      { name: 'Analytics engineering teams with real-time workloads', score: 95, why: 'They can produce latency and retained-query proof that maps to account expansion.' },
+      { name: 'AI observability and event-pipeline builders', score: 87, why: 'They need fast analytical paths and can demonstrate production-like data volume.' },
+      { name: 'Data-intensive founder teams', score: 79, why: 'Fast to activate, but needs dataset and cost guardrails before procurement claims.' },
+    ],
+    sessionFormats: [
+      { format: 'real-time analytics build lab', cadence: 'two technical labs plus benchmark review', why: 'Best for showing latency and cost deltas with source-labeled evidence.' },
+      { format: 'dataset performance clinic', cadence: 'weekly review for projects with live datasets', why: 'Converts first query into retained production-like usage.' },
+      { format: 'benchmark proof sprint', cadence: 'one 7-day challenge', why: 'Best when public proof needs latency and dataset evidence.' },
+    ],
+    offers: [
+      'ClickHouse Cloud credits for a live analytics benchmark',
+      'Performance review for projects with public query latency proof',
+      'Co-marketing slot for retained analytics workloads',
+    ],
+  },
+  supabase: {
+    company: 'Supabase',
+    segment: 'full-stack builders and AI app teams',
+    sessionLabel: 'agent app shipping sprint',
+    buyerProblem: 'Move quickstarts into retained projects with auth, data, and usage proof.',
+    defaultBudgetUsd: 32000,
+    benchmark: { registrations: 220, attended: 132, builders: 82, activated: 54, retained: 28, proofCount: 18 },
+    events: ['project_created', 'auth_enabled', 'database_event_tracked', 'retained_app_usage'],
+    icpSegments: [
+      { name: 'Full-stack AI app founders', score: 92, why: 'They can ship quickly and publish repo/demo proof with auth, data, and usage events.' },
+      { name: 'Internal tool builders', score: 82, why: 'Strong retained usage potential, but public proof may need privacy-safe summaries.' },
+      { name: 'Hackathon and launch-week builders', score: 77, why: 'High attendance and activation, lower retention unless follow-up proof is rewarded.' },
+    ],
+    sessionFormats: [
+      { format: 'agent app shipping sprint', cadence: 'weekly build session plus 7-day retained-usage check', why: 'Best for converting quickstarts into working projects.' },
+      { format: 'auth/data production clinic', cadence: 'weekly after first success', why: 'Best when retention or security readiness blocks proof.' },
+      { format: 'launch proof challenge', cadence: 'one short challenge per cohort', why: 'Best for turning shipped demos into public proof.' },
+    ],
+    offers: [
+      'Startup credits for apps that ship proof',
+      'Launch review for projects with retained usage events',
+      'Featured builder directory placement for public proof',
+    ],
+  },
+  default: {
+    company: 'Enterprise workspace',
+    segment: 'developer-tool buyers and builder-facing GTM teams',
+    sessionLabel: 'builder activation session',
+    buyerProblem: 'Convert session attendance into shipped projects, retained usage, and account-qualified proof.',
+    defaultBudgetUsd: 25000,
+    benchmark: { registrations: 120, attended: 72, builders: 36, activated: 20, retained: 9, proofCount: 6 },
+    events: ['session_attended', 'perk_claimed', 'first_success', 'project_proof_published'],
+    icpSegments: [
+      { name: 'Builders with an urgent production workflow', score: 88, why: 'They can prove value through retained usage instead of attendance.' },
+      { name: 'Founder-led technical teams', score: 81, why: 'Fast shipping loop and visible proof, but smaller account expansion initially.' },
+      { name: 'Enterprise developer champions', score: 76, why: 'High contract value, slower proof path unless account workflow data is connected.' },
+    ],
+    sessionFormats: [
+      { format: 'builder activation lab', cadence: 'weekly session plus proof sprint', why: 'Best default format for first-success and proof conversion.' },
+      { format: 'technical office hours', cadence: 'twice weekly for active builders', why: 'Best when activation blockers are setup/debugging problems.' },
+      { format: 'proof challenge', cadence: '7-day submission window', why: 'Best when public proof and retained usage are the constraint.' },
+    ],
+    offers: [
+      'Credits that unlock only after a working build is submitted',
+      'Expert review for projects that reach first success',
+      'Featured placement for retained usage and public proof',
+    ],
+  },
+}
+
+async function loadConfig() {
+  try {
+    const raw = await readFile(CONFIG_PATH, 'utf8')
+    return JSON.parse(raw)
+  } catch {
+    return {}
+  }
+}
+
+async function api(path, { method = 'GET', body, token, baseUrl = DEFAULT_API } = {}) {
+  const headers = { accept: 'application/json' }
+  if (token) headers.authorization = `Bearer ${token}`
+  if (body) headers['content-type'] = 'application/json'
+  const res = await fetch(`${baseUrl}${path}`, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    throw new Error(`HTTP ${res.status}: ${text || res.statusText}`)
+  }
+  const ctype = res.headers.get('content-type') || ''
+  return ctype.includes('application/json') ? res.json() : res.text()
+}
+
+function parseGlobals(argv) {
+  const clean = []
+  let apiBase = DEFAULT_API
+  let json = false
+  let mode = ''
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--json') {
+      json = true
+      continue
+    }
+    if (arg === '--api') {
+      apiBase = argv[i + 1] || apiBase
+      i += 1
+      continue
+    }
+    if (arg === '--mode') {
+      mode = String(argv[i + 1] || '').trim().toLowerCase()
+      i += 1
+      continue
+    }
+    clean.push(arg)
+  }
+  return { clean, apiBase: apiBase.replace(/\/$/, ''), json, mode }
+}
+
+function formatAdoptionRow(row) {
+  const name = row?.tool?.name ?? row?.toolName ?? 'Unknown tool'
+  const score = row?.adoptionScore ?? row?.adoptionIndex ?? 'pending'
+  const rank = row?.categoryRank ? `#${row.categoryRank}` : '#?'
+  const trust = row?.trustState ?? row?.confidenceLabel ?? 'observed'
+  const verified = row?.verifiedAdoptions ?? 0
+  const cohort = row?.cohortSize ?? 0
+  const suppressed = row?.suppressed ? ' · suppressed' : ''
+  return `${name}: score ${score} · ${rank} · ${trust} · ${verified} verified · N=${cohort}${suppressed}`
+}
+
+function mcpText(text) {
+  return { content: [{ type: 'text', text: typeof text === 'string' ? text : JSON.stringify(text, null, 2) }] }
+}
+
+function authRequiredPayload(state, action) {
+  return {
+    authRequired: true,
+    action,
+    message:
+      'Tokens& is connected. Public tool search works without auth; private saved stack, Build Packet, and project proof context require a scoped workflow token.',
+    nextSteps: [
+      `Open ${state.baseUrl}/projects/new?source=agent_pack`,
+      'Create or select a project.',
+      'Generate a scoped workflow token.',
+      'Add it as DAI_TOKEN in your MCP config.',
+    ],
+  }
+}
+
+function enterpriseAuthRequiredPayload(state, action) {
+  return {
+    authRequired: true,
+    enterpriseAuthRequired: true,
+    action,
+    message:
+      'Private enterprise session, account, and tenant metrics require an enterprise-scoped MCP credential. Codex/Cursor do not automatically inherit a Tokens& browser login.',
+    currentMode: state.mode,
+    configuredContext: {
+      organizationId: state.organizationId || null,
+      enterpriseProfile: state.enterpriseProfile || null,
+      hasEnterpriseToken: Boolean(state.enterpriseToken),
+    },
+    nextSteps: [
+      `Open ${state.baseUrl}/dashboard?mode=enterprise`,
+      'Select the enterprise workspace and verify the session/adoption data there.',
+      'Use enterprise_session_brief with explicit session metrics now, or configure an enterprise-scoped MCP token when enabled.',
+      'Keep raw developer identity and account-level exports inside an authorized enterprise workspace.',
+    ],
+  }
+}
+
+function authRequiredContent(state, uri) {
+  const payload = authRequiredPayload(state, `read ${uri}`)
+  return {
+    uri,
+    mimeType: uri.endsWith('.md') ? 'text/markdown' : 'application/json',
+    text: uri.endsWith('.md')
+      ? [
+          '# Tokens& workflow token required',
+          '',
+          payload.message,
+          '',
+          ...payload.nextSteps.map((step, index) => `${index + 1}. ${step}`),
+        ].join('\n')
+      : JSON.stringify(payload, null, 2),
+  }
+}
+
+function envValue(...names) {
+  for (const name of names) {
+    const value = process.env[name]
+    if (typeof value === 'string' && value.trim()) return value.trim()
+  }
+  return ''
+}
+
+function normalizeMode(value = '') {
+  const mode = String(value || '').trim().toLowerCase()
+  return MODE_VALUES.has(mode) ? mode : 'auto'
+}
+
+function enterpriseToken(config = {}) {
+  return config.enterpriseToken || config.enterprise_token || envValue('DAI_ENTERPRISE_TOKEN', 'TOKENSAND_ENTERPRISE_TOKEN')
+}
+
+function enterpriseOrganizationId(config = {}) {
+  return config.organizationId || config.organization_id || envValue('DAI_ORGANIZATION_ID', 'TOKENSAND_ORGANIZATION_ID')
+}
+
+function enterpriseProfileKey(value = '') {
+  const normalized = String(value || '').trim().toLowerCase()
+  if (!normalized) return ''
+  if (ENTERPRISE_PROFILE_PRESETS[normalized]) return normalized
+  for (const [key, profile] of Object.entries(ENTERPRISE_PROFILE_PRESETS)) {
+    if (key === 'default') continue
+    const haystack = `${profile.company} ${profile.segment}`.toLowerCase()
+    if (haystack.includes(normalized) || normalized.includes(key)) return key
+  }
+  return 'default'
+}
+
+function resolveEnterpriseProfile(config = {}, args = {}) {
+  return enterpriseProfileKey(
+    args.profile ||
+      args.company ||
+      config.enterpriseProfile ||
+      config.enterprise_profile ||
+      envValue('DAI_ENTERPRISE_PROFILE', 'TOKENSAND_ENTERPRISE_PROFILE'),
+  )
+}
+
+function resolveMcpMode({ requestedMode, token, enterpriseToken: privateEnterpriseToken, organizationId, enterpriseProfile }) {
+  const normalized = normalizeMode(requestedMode || envValue('DAI_MODE', 'TOKENSAND_MODE'))
+  if (normalized !== 'auto') return normalized
+  if (privateEnterpriseToken || organizationId || enterpriseProfile) return 'enterprise'
+  if (token) return 'developer'
+  return 'public'
+}
+
+function accountModePayload(state) {
+  const developerPrivateTools = state.token
+    ? ['get_context', 'get_build_packet', 'draft_project', 'publish_project']
+    : []
+  const enterprisePrivateReady = Boolean(state.enterpriseToken)
+  return {
+    product: 'Tokens& MCP',
+    detectedMode: state.mode,
+    authBoundary:
+      'Codex/Cursor MCP servers are configured by env/config. A Tokens& browser login is not automatically visible inside the agent host.',
+    credentials: {
+      hasDeveloperWorkflowToken: Boolean(state.token),
+      developerTokenEnv: 'DAI_TOKEN or DAI_WORKFLOW_TOKEN',
+      hasEnterpriseToken: enterprisePrivateReady,
+      enterpriseTokenEnv: 'DAI_ENTERPRISE_TOKEN',
+      organizationId: state.organizationId || null,
+      enterpriseProfile: state.enterpriseProfile || null,
+    },
+    availableNow: {
+      builderPublic: ['search_tools', 'find_perks', 'get_adoption_rank', 'build_brief'],
+      builderPrivate: developerPrivateTools.length ? developerPrivateTools : 'locked until DAI_TOKEN is configured',
+      enterprisePublic: [
+        'enterprise_session_brief with pasted metrics, budget, ICP segments, or sample profile context',
+        'approval-only motion drafts: adoption session, ICP invite batch, Invite partner company, and adoption proof',
+      ],
+      enterprisePrivate: enterprisePrivateReady
+        ? 'enterprise credential configured; use only authorized organization data'
+        : 'locked until enterprise-scoped MCP credentials are issued/configured',
+    },
+    recommendedFirstCalls:
+      state.mode === 'enterprise'
+        ? ['enterprise_session_brief', 'find_perks', 'get_adoption_rank']
+        : ['build_brief', 'find_perks', 'get_adoption_rank'],
+    setup: {
+      builder: [
+        `Open ${state.baseUrl}/projects/new?source=agent_pack`,
+        'Generate a scoped workflow token.',
+        'Set DAI_TOKEN in the MCP config for private saved stack, Build Packet, and proof workflow context.',
+      ],
+      enterprise: [
+        `Open ${state.baseUrl}/dashboard?mode=enterprise`,
+        'Use enterprise_session_brief with explicit session metrics, budget, and ICP segment splits for immediate analysis.',
+        'Use draft_adoption_session, draft_icp_invite_batch, draft_partner_invite, and draft_adoption_proof_motion to prepare the motion for approval.',
+        'Set DAI_MODE=enterprise and DAI_ORGANIZATION_ID or DAI_ENTERPRISE_PROFILE so the agent uses enterprise language and offer strategy.',
+        'Add DAI_ENTERPRISE_TOKEN only when a scoped enterprise MCP credential is available.',
+      ],
+    },
+  }
+}
+
+function takeItems(value, key) {
+  return Array.isArray(value?.[key]) ? value[key] : []
+}
+
+function absoluteOrSiteUrl(value, baseUrl) {
+  if (!value) return undefined
+  const text = String(value)
+  if (/^https?:\/\//i.test(text)) return text
+  return `${baseUrl}${text.startsWith('/') ? text : `/${text}`}`
+}
+
+function compactToolResult(result, baseUrl) {
+  const tool = result?.tool ?? {}
+  return {
+    name: tool.name,
+    slug: tool.slug,
+    category: tool.categoryName ?? tool.categorySlug,
+    href: absoluteOrSiteUrl(tool.href, baseUrl),
+    docsUrl: tool.docsUrl,
+    websiteUrl: tool.websiteUrl,
+    pricingModel: tool.pricingModel,
+    openSource: Boolean(tool.openSource),
+    adoptionIndex: tool.adoptionIndex,
+    verifiedAdoptions: tool.verifiedAdoptions,
+    why: tool.why,
+    tradeoff: tool.tradeoff,
+    score: result?.score,
+    reasons: Array.isArray(result?.reasons) ? result.reasons.slice(0, 4) : [],
+  }
+}
+
+function compactPerk(perk, baseUrl) {
+  return {
+    name: perk?.name,
+    description: perk?.description,
+    type: perk?.perkType,
+    tool: perk?.tool?.name,
+    category: perk?.tool?.category?.name ?? perk?.tool?.category?.slug,
+    organization: perk?.organization?.name,
+    valueCents: perk?.unitValueCents ?? perk?.pricingSummary?.perkValueCents,
+    scarcity: perk?.scarcityText,
+    eligibility: perk?.eligibility?.reason,
+    claimUrl: perk?.externalClaimUrl ?? (perk?.id ? `${baseUrl}/perks?perk=${encodeURIComponent(perk.id)}` : undefined),
+    source: perk?.source,
+  }
+}
+
+function compactAdoptionRow(row, baseUrl) {
+  return {
+    tool: row?.tool?.name,
+    slug: row?.tool?.slug,
+    category: row?.tool?.category,
+    adoptionScore: row?.adoptionScore,
+    agentRankScore: row?.agentRankScore,
+    trustScore: row?.trustScore,
+    verifiedAdoptions: row?.verifiedAdoptions,
+    uniqueDevelopers: row?.uniqueDevelopers,
+    retentionRate: row?.retentionRate,
+    trustState: row?.trustState,
+    categoryRank: row?.categoryRank,
+    profileUrl: row?.badgeUrls?.profile ? `${baseUrl}${row.badgeUrls.profile}` : undefined,
+    methodologyUrl: row?.methodologyUrl ? `${baseUrl}${row.methodologyUrl}` : undefined,
+    rankingPolicy: row?.rankingPolicy,
+  }
+}
+
+function uniqueBySlug(items = []) {
+  const seen = new Set()
+  const unique = []
+  for (const item of items) {
+    const key = item.slug || item.name
+    if (!key || seen.has(key)) continue
+    seen.add(key)
+    unique.push(item)
+  }
+  return unique
+}
+
+function normalizedText(value = '') {
+  return String(value || '').trim().toLowerCase()
+}
+
+function matchesAny(text, patterns = []) {
+  const haystack = normalizedText(text)
+  return patterns.some((pattern) => haystack.includes(pattern))
+}
+
+function isCustomerAgentIntent(intent, useCase = '') {
+  return /customer|support|ticket|helpdesk|intercom|zendesk|agent|assistant|chatbot/i.test(`${intent || ''} ${useCase || ''}`)
+}
+
+function firstCandidate(candidates, patterns) {
+  for (const pattern of patterns) {
+    const candidate = candidates.find((item) => {
+      const haystack = `${item.name || ''} ${item.slug || ''} ${item.category || ''}`
+      return matchesAny(haystack, [pattern])
+    })
+    if (candidate) return candidate
+  }
+  return null
+}
+
+function compactApiChoice(role, candidate, fallback) {
+  const source = candidate ? 'tokensand_search' : 'playbook_fallback'
+  return {
+    role,
+    name: candidate?.name || fallback.name,
+    slug: candidate?.slug || fallback.slug,
+    category: candidate?.category || fallback.category,
+    pricingModel: candidate?.pricingModel || fallback.pricingModel,
+    docsUrl: candidate?.docsUrl || fallback.docsUrl,
+    why: candidate?.why || fallback.why,
+    tradeoff: candidate?.tradeoff || fallback.tradeoff,
+    source,
+  }
+}
+
+function buildApiPlan(intent, stackCandidates, useCase = '') {
+  const customerAgent = isCustomerAgentIntent(intent, useCase)
+  const supportSystem = firstCandidate(stackCandidates, ['intercom', 'zendesk', 'freshdesk'])
+  const channel = firstCandidate(stackCandidates, ['slack', 'discord', 'teams'])
+  const runtime = firstCandidate(stackCandidates, ['mastra', 'fastmcp', 'langchain', 'llamaindex', 'cline', 'openai'])
+  const memory = firstCandidate(stackCandidates, ['mem0', 'pinecone', 'redis', 'neon', 'postgres'])
+
+  const customerAgentChoices = [
+    compactApiChoice('support system of record', supportSystem, {
+      name: 'Intercom or Zendesk API',
+      slug: 'support-system-api',
+      category: 'Support Channels',
+      pricingModel: 'PAID',
+      docsUrl: 'Use the provider API docs for the support system already used by the customer.',
+      why: 'A customer agent needs tickets, conversations, contacts, and escalation state from the existing support system.',
+      tradeoff: 'Do not add a paid support-suite dependency unless it is already the system of record.',
+    }),
+    compactApiChoice('handoff and internal escalation channel', channel, {
+      name: 'Slack API',
+      slug: 'slack-api',
+      category: 'Support Channels',
+      pricingModel: 'FREE',
+      docsUrl: 'https://api.slack.com/docs',
+      why: 'Most B2B support agents need human handoff, triage, and account-team escalation.',
+      tradeoff: 'OAuth scopes and workspace permissions need review before production.',
+    }),
+    compactApiChoice('agent runtime and tool orchestration', runtime, {
+      name: 'Mastra or FastMCP',
+      slug: 'agent-runtime',
+      category: 'AI Agents',
+      pricingModel: 'OPEN_SOURCE',
+      docsUrl: 'Use the selected runtime docs.',
+      why: 'Keep the customer-agent loop, tools, memory, evals, and handoff logic explicit in code.',
+      tradeoff: 'Open-source runtimes reduce vendor cost but add deployment and maintenance ownership.',
+    }),
+    compactApiChoice('memory, retrieval, or customer context store', memory, {
+      name: 'Mem0, Redis, Pinecone, or Postgres',
+      slug: 'agent-memory-retrieval',
+      category: 'AI Agents / Databases',
+      pricingModel: 'FREEMIUM',
+      docsUrl: 'Use the selected provider docs.',
+      why: 'Customer agents need durable user/account context and retrieval over support knowledge.',
+      tradeoff: 'Keep PII boundaries explicit; do not store raw customer data without retention and deletion rules.',
+    }),
+  ]
+
+  const generalChoices = stackCandidates.slice(0, 4).map((candidate, index) => compactApiChoice(
+    index === 0 ? 'primary API' : `supporting API ${index + 1}`,
+    candidate,
+    {
+      name: candidate?.name || 'Selected API',
+      slug: candidate?.slug || 'selected-api',
+      category: candidate?.category || 'Developer tool',
+      pricingModel: candidate?.pricingModel || 'UNKNOWN',
+      docsUrl: candidate?.docsUrl,
+      why: candidate?.why || 'Selected from Tokens& stack search.',
+      tradeoff: candidate?.tradeoff || 'Validate cost, auth, and operational fit before implementation.',
+    },
+  ))
+
+  return {
+    useCase: customerAgent ? 'customer_agent' : 'general_builder',
+    bestApis: customerAgent ? customerAgentChoices : generalChoices,
+    implementationOrder: customerAgent
+      ? [
+          'Pick the support system of record first: Intercom/Zendesk only if the customer already lives there.',
+          'Add Slack or an internal handoff channel before autonomous resolution.',
+          'Choose the runtime/orchestration layer and define tools, auth scopes, and evals.',
+          'Add memory/retrieval only after PII, retention, and deletion boundaries are explicit.',
+        ]
+      : [
+          'Start with the primary API that owns the core workflow.',
+          'Add the cheapest support API needed for the first demo.',
+          'Defer extra integrations until the first user proof exists.',
+        ],
+    missingData:
+      customerAgent && !supportSystem
+        ? 'Tokens& did not find the customer support system in the top candidates; ask the user whether the target customer uses Intercom, Zendesk, HubSpot, Salesforce, or a custom inbox.'
+        : null,
+  }
+}
+
+function creditValueLabel(perk) {
+  if (perk.valueCents) return `$${Math.round(perk.valueCents / 100).toLocaleString()}`
+  return 'amount varies or not listed'
+}
+
+function buildCreditPlan(matchedPerks, intent, useCase = '') {
+  const creditLike = matchedPerks.filter((perk) => {
+    const haystack = `${perk.name || ''} ${perk.type || ''} ${perk.scarcity || ''}`.toLowerCase()
+    return /credit|free|quota|startup|starter|bundle|discount|perk/.test(haystack)
+  })
+  const customerAgent = isCustomerAgentIntent(intent, useCase)
+  const preferred = creditLike.filter((perk) => {
+    const haystack = `${perk.tool || ''} ${perk.category || ''} ${perk.name || ''}`.toLowerCase()
+    return customerAgent
+      ? /vercel|cloudflare|neon|pinecone|redis|tinyfish|mongodb|database|vector|agent|infrastructure|developer-platform/.test(haystack)
+      : true
+  })
+  const availableCredits = (preferred.length ? preferred : creditLike).slice(0, 6).map((perk) => ({
+    name: perk.name,
+    tool: perk.tool,
+    type: perk.type,
+    category: perk.category,
+    value: creditValueLabel(perk),
+    claimUrl: perk.claimUrl,
+    source: perk.source,
+    caveat: perk.scarcity || 'Verify current provider terms before relying on the offer.',
+  }))
+
+  return {
+    source: 'Tokens& public perks API',
+    availableCredits,
+    recommendation: availableCredits.length
+      ? `Claim or verify ${availableCredits[0].name} first; use credits to reduce hosting/database/vector or agent-runtime cost before paying for traffic.`
+      : 'No matching public credits were found in Tokens& for this intent; treat this as a supply gap to seed.',
+    caveat: 'Perks are opportunities, not guaranteed entitlements. Provider eligibility, terms, and current availability must be verified before budgeting.',
+  }
+}
+
+function buildCostPlan(intent, stackCandidates, creditPlan, useCase = '') {
+  const customerAgent = isCustomerAgentIntent(intent, useCase)
+  const paid = stackCandidates.filter((candidate) => /PAID|ENTERPRISE/i.test(String(candidate.pricingModel || '')))
+  const freeish = stackCandidates.filter((candidate) => /FREE|OPEN_SOURCE|FREEMIUM/i.test(String(candidate.pricingModel || '')))
+  return {
+    source: 'Tokens& pricing labels plus selected provider docs; live metered API pricing is not pulled into this public MCP call.',
+    costDrivers: customerAgent
+      ? [
+          'LLM/model calls per conversation and tool call.',
+          'Support-system seats or API access if using Intercom/Zendesk.',
+          'Vector/database storage and retrieval for knowledge/customer context.',
+          'Hosting, background jobs, observability, and human handoff volume.',
+        ]
+      : [
+          'Paid APIs in the selected stack.',
+          'Hosting, database, storage, and background jobs.',
+          'Usage-based model, search, or workflow execution costs.',
+        ],
+    lowCostPath: customerAgent
+      ? 'Start with an open-source runtime, Slack handoff, existing docs/FAQ data, and credits for hosting/database/vector storage. Add Intercom/Zendesk only when the customer already uses that system.'
+      : 'Start with the free/open-source or freemium candidates, claim credits, and defer paid APIs until the first proof path is working.',
+    paidSurfaces: paid.map((candidate) => ({
+      name: candidate.name,
+      pricingModel: candidate.pricingModel,
+      tradeoff: candidate.tradeoff,
+      docsUrl: candidate.docsUrl,
+    })),
+    freeOrCreditSurfaces: freeish.map((candidate) => ({
+      name: candidate.name,
+      pricingModel: candidate.pricingModel,
+      docsUrl: candidate.docsUrl,
+    })).slice(0, 6),
+    creditsAvailable: creditPlan.availableCredits.length,
+    budgetGuardrail:
+      'Before production, set per-user and per-account usage caps, log model/tool-call cost by workflow, and define a kill condition for cost per resolved ticket or completed task.',
+  }
+}
+
+function buildDeveloperDashboardSync(state) {
+  return {
+    persistedToDashboard: false,
+    reason:
+      'build_brief is public decision support. It does not create or update Tokens& project records by itself.',
+    currentMode: state.mode,
+    hasDeveloperWorkflowToken: Boolean(state.token),
+    productAppearsInDashboardWhen:
+      'A signed-in builder configures DAI_TOKEN, calls draft_project from the repo, reviews the inferred project, then calls publish_project with explicit confirmation.',
+    dashboardLinks: {
+      install: `${state.baseUrl}/agents/install`,
+      projects: `${state.baseUrl}/dashboard/projects`,
+      newProject: `${state.baseUrl}/projects/new?source=agent_pack`,
+      publicPerks: `${state.baseUrl}/perks?public=1`,
+    },
+    nextSyncAction: state.token
+      ? 'Run draft_project from the repo, review the draft, then run publish_project with confirm: true after human approval.'
+      : 'Generate a scoped workflow token from Tokens&, set DAI_TOKEN in Codex/Cursor, then run draft_project and publish_project after approval.',
+  }
+}
+
+async function publicBuildBrief(args, state) {
+  const intent = String(args.intent ?? args.query ?? '').trim()
+  if (!intent) throw new Error('build_brief requires intent')
+  const useCase = String(args.useCase ?? '').trim()
+  const customerAgentIntent = isCustomerAgentIntent(intent, useCase)
+  const searchIntent = customerAgentIntent && !/intercom|zendesk|slack|support channel|support api/i.test(intent)
+    ? `${intent} support channel api Intercom Zendesk Slack`
+    : intent
+  const limit = Math.max(1, Math.min(Number(args.limit ?? 5) || 5, 10))
+  const period = ['7d', '30d', '90d'].includes(args.period) ? args.period : '30d'
+
+  const searchParams = new URLSearchParams({ q: searchIntent, limit: String(limit) })
+  if (args.category || args.categorySlug) searchParams.set('category', String(args.category ?? args.categorySlug))
+  if (args.pricing) searchParams.set('pricing', String(args.pricing))
+  if (args.openSource != null) searchParams.set('openSource', String(Boolean(args.openSource)))
+  if (args.enterpriseReady != null) searchParams.set('enterpriseReady', String(Boolean(args.enterpriseReady)))
+
+  const perkLookupLimit = Math.max(limit, 10)
+  const perkParams = new URLSearchParams({ limit: String(perkLookupLimit) })
+  if (args.categorySlug) perkParams.set('categorySlug', String(args.categorySlug))
+
+  const rankParams = new URLSearchParams({ period, limit: String(limit) })
+  if (args.categorySlug) rankParams.set('category', String(args.categorySlug))
+
+  const supportSearchParams = new URLSearchParams({ q: 'customer support agent api', limit: String(limit) })
+  const [search, supportSearch, perks, adoption] = await Promise.all([
+    workflowApi(`/api/build/search?${searchParams.toString()}`, { baseUrl: state.baseUrl }),
+    customerAgentIntent
+      ? workflowApi(`/api/build/search?${supportSearchParams.toString()}`, { baseUrl: state.baseUrl }).catch(() => ({ results: [] }))
+      : Promise.resolve({ results: [] }),
+    workflowApi(`/api/perks?${perkParams.toString()}`, { baseUrl: state.baseUrl }).catch((error) => ({
+      error: error instanceof Error ? error.message : 'perk lookup failed',
+      perks: [],
+    })),
+    workflowApi(`/api/v1/adoption?${rankParams.toString()}`, { baseUrl: state.baseUrl }).catch((error) => ({
+      error: error instanceof Error ? error.message : 'adoption lookup failed',
+      rows: [],
+    })),
+  ])
+
+  const supportCandidates = takeItems(supportSearch, 'results').map((item) => compactToolResult(item, state.baseUrl))
+  const generalCandidates = takeItems(search, 'results').map((item) => compactToolResult(item, state.baseUrl))
+  const stackCandidates = uniqueBySlug([...supportCandidates, ...generalCandidates]).slice(0, limit)
+  const rawPerks = takeItems(perks, 'perks')
+  const requestedCategorySlug = args.categorySlug ? String(args.categorySlug) : ''
+  const categoryFilteredPerks = requestedCategorySlug
+    ? rawPerks.filter((perk) => {
+        const categorySlug = perk?.tool?.category?.slug
+        return categorySlug === requestedCategorySlug || categorySlug === 'developer-program'
+      })
+    : rawPerks
+  const matchedPerks = categoryFilteredPerks.slice(0, perkLookupLimit).map((item) => compactPerk(item, state.baseUrl))
+  const adoptionEvidence = takeItems(adoption, 'rows').slice(0, limit).map((item) => compactAdoptionRow(item, state.baseUrl))
+  const apiPlan = buildApiPlan(intent, stackCandidates, useCase)
+  const creditPlan = buildCreditPlan(matchedPerks, intent, useCase)
+  const costPlan = buildCostPlan(intent, stackCandidates, creditPlan, useCase)
+  const dashboardSync = buildDeveloperDashboardSync(state)
+
+  return {
+    intent,
+    useCase: useCase || apiPlan.useCase,
+    stackCandidates,
+    matchedPerks,
+    adoptionEvidence,
+    apiPlan,
+    creditPlan,
+    costPlan,
+    dashboardSync,
+    recommendation:
+      stackCandidates.length > 0
+        ? `Start with ${stackCandidates[0].name}; compare against ${stackCandidates.slice(1, 3).map((tool) => tool.name).filter(Boolean).join(' and ') || 'one focused alternative'} before implementation.`
+        : 'No stack candidate found yet. Ask a narrower build intent or use Tokens& workbench.',
+    nextActions: [
+      apiPlan.bestApis?.length ? `Use ${apiPlan.bestApis[0].name} for ${apiPlan.bestApis[0].role}; then follow the implementation order in apiPlan.` : 'Pick the smallest API set that reaches first user proof.',
+      creditPlan.availableCredits.length ? `Verify ${creditPlan.availableCredits[0].name} before spending cash.` : 'Seed or find a relevant credit/perk before scaling the build.',
+      costPlan.budgetGuardrail,
+      'Pick one stack candidate and ask the coding agent for the smallest shippable implementation plan.',
+      matchedPerks.length ? 'Claim or verify any matching perk before relying on the credit/value.' : 'No matching perk supply found; this is a supply gap for Tokens& to fill.',
+      'Use get_build_packet after adding DAI_TOKEN for private saved-stack context.',
+      'Use draft_project after shipping to prepare public proof; publish only after explicit human approval.',
+    ],
+    safety: {
+      publicOnly: !state.token,
+      privateContextRequires: 'DAI_TOKEN',
+      approvalBoundary: 'Public proof publishing, offer claims, and external writes remain human-approved.',
+    },
+  }
+}
+
+function numberValue(value) {
+  const number = Number(value)
+  return Number.isFinite(number) && number > 0 ? number : 0
+}
+
+function optionalNumber(value) {
+  const number = Number(value)
+  return Number.isFinite(number) && number > 0 ? number : null
+}
+
+function moneyPer(total, count) {
+  if (!total || !count) return null
+  return Math.round((total / count) * 100) / 100
+}
+
+function percentage(numerator, denominator) {
+  if (!denominator) return 0
+  return Math.round((numerator / denominator) * 100)
+}
+
+function compactSession(input = {}, fallbackName = 'session') {
+  const registrations = numberValue(input.registrations ?? input.signups ?? input.registered)
+  const attended = numberValue(input.attended ?? input.attendees ?? input.checkedIn)
+  const builders = numberValue(input.builders ?? input.builderCount ?? input.started)
+  const activated = numberValue(
+    input.activated ?? input.firstSuccess ?? input.firstSuccesses ?? input.first_success ?? input.first_successes,
+  )
+  const retained = numberValue(input.retained ?? input.retainedBuilders ?? input.returned ?? input.retainedUsage)
+  const proofCount = numberValue(
+    input.proofCount ?? input.proofProjects ?? input.proofProjectCount ?? input.proofs ?? input.projects,
+  )
+  return {
+    name: String(input.name || input.title || fallbackName),
+    date: input.date ? String(input.date) : undefined,
+    offer: input.offer ? String(input.offer) : undefined,
+    notes: input.notes ? String(input.notes) : undefined,
+    costUsd: optionalNumber(input.costUsd ?? input.budgetUsd ?? input.spendUsd ?? input.cost ?? input.spend),
+    icpSegment: input.icpSegment ? String(input.icpSegment) : undefined,
+    channel: input.channel ? String(input.channel) : undefined,
+    metrics: {
+      registrations,
+      attended,
+      builders,
+      activated,
+      retained,
+      proofCount,
+    },
+  }
+}
+
+function summarizeSessions(sessions = []) {
+  const totals = sessions.reduce(
+    (acc, session) => {
+      const metrics = session.metrics ?? {}
+      acc.registrations += numberValue(metrics.registrations)
+      acc.attended += numberValue(metrics.attended)
+      acc.builders += numberValue(metrics.builders)
+      acc.activated += numberValue(metrics.activated)
+      acc.retained += numberValue(metrics.retained)
+      acc.proofCount += numberValue(metrics.proofCount)
+      return acc
+    },
+    { registrations: 0, attended: 0, builders: 0, activated: 0, retained: 0, proofCount: 0 },
+  )
+  return {
+    totals,
+    rates: {
+      attendanceRate: percentage(totals.attended, totals.registrations),
+      builderStartRate: percentage(totals.builders, totals.attended),
+      activationRate: percentage(totals.activated, totals.builders),
+      retentionRate: percentage(totals.retained, totals.activated),
+      proofRate: percentage(totals.proofCount, totals.activated),
+    },
+  }
+}
+
+function sessionBottleneck(summary) {
+  const rates = summary.rates
+  const candidates = [
+    {
+      key: 'attendance',
+      rate: rates.attendanceRate,
+      threshold: 55,
+      label: 'registration to attendance',
+      action: 'Add calendar holds, reminder proof, and a concrete build outcome before the session starts.',
+    },
+    {
+      key: 'builder_start',
+      rate: rates.builderStartRate,
+      threshold: 45,
+      label: 'attendance to builder start',
+      action: 'Reduce setup friction: one command starter, visible API key path, and a 15-minute first-success script.',
+    },
+    {
+      key: 'activation',
+      rate: rates.activationRate,
+      threshold: 50,
+      label: 'builder start to first success',
+      action: 'Put agents on the happy path: Build Packet, working template, env checklist, and immediate debugging help.',
+    },
+    {
+      key: 'retention',
+      rate: rates.retentionRate,
+      threshold: 40,
+      label: 'first success to retained usage',
+      action: 'Turn the build into an operating workflow: follow-up challenge, production checklist, and account-owner handoff.',
+    },
+    {
+      key: 'proof',
+      rate: rates.proofRate,
+      threshold: 30,
+      label: 'first success to public proof',
+      action: 'Make proof publishing cheap: repo/demo checklist, prefilled project card, and approval-gated claim text.',
+    },
+  ]
+  return candidates
+    .filter((candidate) => candidate.rate < candidate.threshold)
+    .sort((a, b) => a.rate - b.rate)[0] || candidates.sort((a, b) => a.rate - b.rate)[0]
+}
+
+function resolveBudgetUsd(args, profile, sessions) {
+  const explicitBudget = optionalNumber(
+    args.budgetUsd ?? args.sessionBudgetUsd ?? args.campaignBudgetUsd ?? args.spendUsd ?? args.costUsd,
+  )
+  if (explicitBudget) {
+    return {
+      budgetUsd: explicitBudget,
+      source: 'user_supplied_budget',
+      boardReady: true,
+    }
+  }
+  const sessionCosts = sessions
+    .map((session) => optionalNumber(session.costUsd))
+    .filter((value) => value != null)
+  if (sessionCosts.length) {
+    return {
+      budgetUsd: sessionCosts.reduce((sum, value) => sum + value, 0),
+      source: 'user_supplied_session_costs',
+      boardReady: true,
+    }
+  }
+  return {
+    budgetUsd: optionalNumber(profile.defaultBudgetUsd) ?? ENTERPRISE_PROFILE_PRESETS.default.defaultBudgetUsd,
+    source: 'profile_modelled_budget',
+    boardReady: false,
+  }
+}
+
+function buildCostEconomics(args, profile, sessions, summary, bottleneck) {
+  const budget = resolveBudgetUsd(args, profile, sessions)
+  const totals = summary.totals
+  const costs = {
+    perRegistration: moneyPer(budget.budgetUsd, totals.registrations),
+    perAttendee: moneyPer(budget.budgetUsd, totals.attended),
+    perBuilderStart: moneyPer(budget.budgetUsd, totals.builders),
+    perActivation: moneyPer(budget.budgetUsd, totals.activated),
+    perRetainedBuilder: moneyPer(budget.budgetUsd, totals.retained),
+    perProofProject: moneyPer(budget.budgetUsd, totals.proofCount),
+  }
+  const spendAdviceByBottleneck = {
+    attendance: 'Spend less on broad registration volume; spend more on calendar commitment, pre-work, and reminders tied to a visible build outcome.',
+    builder_start: 'Shift budget from audience acquisition to one-command setup, starter repos, live debugging, and small credits unlocked at builder start.',
+    activation: 'Fund hands-on technical help, Build Packet templates, env setup, and first-success debugging before buying more traffic.',
+    retention: 'Fund follow-up clinics and retained-usage rewards; do not scale the event until a second qualifying usage event clears.',
+    proof: 'Fund proof packaging: repo/demo checklist, prefilled project cards, featured proof rewards, and account-owner handoff.',
+  }
+
+  return {
+    source: budget.source,
+    boardReady: budget.boardReady,
+    budgetUsd: budget.budgetUsd,
+    costs,
+    primaryCostMetric:
+      bottleneck.key === 'proof'
+        ? { label: 'cost per proof project', valueUsd: costs.perProofProject }
+        : bottleneck.key === 'retention'
+          ? { label: 'cost per retained builder', valueUsd: costs.perRetainedBuilder }
+          : bottleneck.key === 'activation'
+            ? { label: 'cost per activation', valueUsd: costs.perActivation }
+            : { label: 'cost per builder start', valueUsd: costs.perBuilderStart },
+    nextBudgetMove: spendAdviceByBottleneck[bottleneck.key] ?? spendAdviceByBottleneck.proof,
+    financeBoundary: budget.boardReady
+      ? 'Budget was supplied in the MCP request; still reconcile against finance-approved campaign spend before board or procurement claims.'
+      : 'Budget is modelled from the profile preset; connect finance-approved spend before calling ROI board-ready.',
+  }
+}
+
+function normalizeSegment(row = {}, index = 0) {
+  const name = String(row.name || row.label || row.segment || row.icp || row.icpSegment || `segment ${index + 1}`)
+  const builders = numberValue(row.builders ?? row.started)
+  const activated = numberValue(row.activated ?? row.firstSuccess ?? row.firstSuccesses ?? row.first_success)
+  const retained = numberValue(row.retained ?? row.retainedBuilders ?? row.returned)
+  const proofCount = numberValue(row.proofCount ?? row.proofProjects ?? row.proofProjectCount ?? row.proofs ?? row.projects)
+  const pipelineUsd = numberValue(row.pipelineUsd ?? row.pipeline ?? row.estimatedPipelineUsd)
+  const suppliedScore = optionalNumber(row.score)
+  const evidenceScore = suppliedScore ?? Math.min(99, Math.round(
+    builders * 0.5 +
+    activated * 1.5 +
+    retained * 3 +
+    proofCount * 4 +
+    (pipelineUsd ? Math.log10(pipelineUsd + 10) * 6 : 0),
+  ))
+  return {
+    name,
+    score: evidenceScore,
+    builders,
+    activated,
+    retained,
+    proofCount,
+    pipelineUsd: pipelineUsd || null,
+    reason: row.reason || row.why || `${retained} retained builder(s), ${proofCount} proof project(s), ${activated} activation(s).`,
+  }
+}
+
+function buildIcpAnalysis(args, profile, summary) {
+  const suppliedSegments = Array.isArray(args.segments) ? args.segments : Array.isArray(args.icpSegments) ? args.icpSegments : []
+  const rankedSegments = suppliedSegments.length
+    ? suppliedSegments.map(normalizeSegment).sort((a, b) => b.score - a.score).slice(0, 5)
+    : (profile.icpSegments ?? ENTERPRISE_PROFILE_PRESETS.default.icpSegments).map((segment) => ({
+        name: segment.name,
+        score: segment.score,
+        reason: segment.why,
+        builders: null,
+        activated: null,
+        retained: null,
+        proofCount: null,
+        pipelineUsd: null,
+      }))
+  const best = rankedSegments[0]
+  return {
+    source: suppliedSegments.length ? 'user_supplied_segment_metrics' : 'profile_modelled_icp',
+    bestSegment: best?.name ?? profile.segment,
+    rankedSegments,
+    test:
+      suppliedSegments.length
+        ? 'Double down only if this segment keeps the lead across the next 100 builders with retained usage or proof, not just registrations.'
+        : `Run the next ${profile.company} session with segment tags so the dashboard can compare retained usage and proof by ICP.`,
+    antiIcp:
+      summary.rates.builderStartRate < 45
+        ? 'Broad awareness attendees who do not start a build in-session.'
+        : 'Curiosity-only builders without repo/demo evidence or a second usage event.',
+  }
+}
+
+function buildSessionStrategy(profile, summary, bottleneck) {
+  const formats = profile.sessionFormats ?? ENTERPRISE_PROFILE_PRESETS.default.sessionFormats
+  const preferred = bottleneck.key === 'proof'
+    ? formats.find((item) => /proof|performance|build/i.test(item.format)) ?? formats[0]
+    : bottleneck.key === 'retention'
+      ? formats.find((item) => /clinic|office|retained/i.test(item.format)) ?? formats[1] ?? formats[0]
+      : formats[0]
+  return {
+    recommendedFormat: preferred.format,
+    cadence: preferred.cadence,
+    why: preferred.why,
+    agenda: [
+      '5 min: show the exact proof artifact builders will leave with.',
+      '15 min: one-command setup and API/key path.',
+      '25 min: build the core workflow with Codex/Cursor and Tokens& Build Packet context.',
+      '10 min: submit repo/demo evidence or schedule a follow-up proof review.',
+    ],
+    avoid:
+      summary.rates.proofRate < 30
+        ? 'Do not buy a bigger conference booth until proof publishing clears 30% of activations.'
+        : 'Do not optimize for attendance without retained-usage instrumentation.',
+  }
+}
+
+function buildDashboardHandoff(state, profileKey) {
+  const profileQuery = profileKey && profileKey !== 'default' ? `profile=${encodeURIComponent(profileKey)}&sample=1` : 'mode=enterprise'
+  const companyProfileQuery = profileKey && profileKey !== 'default'
+    ? `mode=company&profile=${encodeURIComponent(profileKey)}`
+    : 'mode=company'
+  const proofPilotQuery = profileKey && profileKey !== 'default'
+    ? `profile=${encodeURIComponent(profileKey)}`
+    : 'mode=company'
+  return {
+    syncStatus: {
+      persistedToDashboard: false,
+      reason:
+        'enterprise_session_brief is read-only decision support. It tracks aggregate MCP funnel events when telemetry is enabled, but it does not create projects, offers, exports, or public proof.',
+      projectAppearsInDashboardWhen:
+        'A signed-in builder configures DAI_TOKEN and calls draft_project, then publish_project with explicit confirmation; the project then appears in /dashboard/projects and public proof surfaces.',
+      enterpriseMetricsAppearWhen:
+        'The enterprise workspace connects tracking keys/events or a scoped enterprise MCP credential is configured; browser login is not inherited by Codex/Cursor.',
+    },
+    dashboardLinks: {
+      enterpriseCommandCenter: `${state.baseUrl}/dashboard/adoption?${profileQuery}`,
+      aiOperators: `${state.baseUrl}/dashboard/agents?${companyProfileQuery}`,
+      activationExchange: `${state.baseUrl}/dashboard/campaigns?${profileQuery}`,
+      proofPilot: `${state.baseUrl}/dashboard/proof-pilot?${proofPilotQuery}`,
+      trackingSetup: `${state.baseUrl}/dashboard/integrations/tracking?template=${encodeURIComponent(profileKey || 'default')}`,
+      builderProjects: `${state.baseUrl}/dashboard/projects`,
+      installPage: `${state.baseUrl}/agents/install`,
+    },
+    codexConfig: {
+      publicEnterprisePreview: `DAI_MODE=enterprise DAI_ENTERPRISE_PROFILE=${profileKey || 'default'} npx -y ${CLI_PACKAGE_SPEC} mcp serve --api ${state.baseUrl} --mode enterprise`,
+      privateBuilderSyncRequires: 'DAI_TOKEN from /api/workflow/mcp-config after sign-in.',
+      liveEnterpriseSyncRequires: 'DAI_ENTERPRISE_TOKEN plus an authorized organization scope when enterprise MCP credentials are enabled.',
+    },
+  }
+}
+
+function buildSampleSessions(profile, args = {}) {
+  const benchmark = profile.benchmark ?? ENTERPRISE_PROFILE_PRESETS.default.benchmark
+  return [
+    compactSession(
+      {
+        name: args.sessionName || profile.sessionLabel,
+        registrations: benchmark.registrations,
+        attended: benchmark.attended,
+        builders: benchmark.builders,
+        activated: benchmark.activated,
+        retained: benchmark.retained,
+        proofCount: benchmark.proofCount,
+        offer: profile.offers?.[0],
+        notes: profile.buyerProblem,
+      },
+      profile.sessionLabel,
+    ),
+  ]
+}
+
+function hasTopLevelSessionMetrics(args = {}) {
+  return [
+    'registrations',
+    'signups',
+    'registered',
+    'attended',
+    'attendees',
+    'checkedIn',
+    'builders',
+    'builderCount',
+    'started',
+    'activated',
+    'firstSuccess',
+    'firstSuccesses',
+    'first_success',
+    'retained',
+    'retainedBuilders',
+    'retainedUsage',
+    'proofCount',
+    'proofProjects',
+    'proofProjectCount',
+    'proofs',
+    'projects',
+  ].some((key) => args[key] != null)
+}
+
+function normalizeSuppliedSessions(args = {}, profile) {
+  if (Array.isArray(args.sessions) && args.sessions.length) {
+    return args.sessions.map((session, index) => compactSession(session, `session ${index + 1}`))
+  }
+  if (args.session && typeof args.session === 'object' && !Array.isArray(args.session)) {
+    return [compactSession(args.session, args.sessionName || profile.sessionLabel)]
+  }
+  if (hasTopLevelSessionMetrics(args)) {
+    return [compactSession(args, args.sessionName || profile.sessionLabel)]
+  }
+  return []
+}
+
+function enterpriseSessionBrief(args, state) {
+  const wantsLiveData = args.live === true || args.liveData === true
+  const organizationId = String(args.organizationId || state.organizationId || '').trim()
+  if (wantsLiveData && !state.enterpriseToken) return enterpriseAuthRequiredPayload(state, 'enterprise_session_brief')
+
+  const profileKey = resolveEnterpriseProfile({}, args) || state.enterpriseProfile || 'default'
+  const profile = ENTERPRISE_PROFILE_PRESETS[profileKey] ?? ENTERPRISE_PROFILE_PRESETS.default
+  const suppliedSessions = normalizeSuppliedSessions(args, profile)
+  const sessions = suppliedSessions.length ? suppliedSessions : buildSampleSessions(profile, args)
+  const summary = summarizeSessions(sessions)
+  const bottleneck = sessionBottleneck(summary)
+  const costEconomics = buildCostEconomics(args, profile, sessions, summary, bottleneck)
+  const icpAnalysis = buildIcpAnalysis(args, profile, summary)
+  const sessionStrategy = buildSessionStrategy(profile, summary, bottleneck)
+  const dashboardHandoff = buildDashboardHandoff(state, profileKey)
+  const dataSource = suppliedSessions.length ? 'user_supplied_session_metrics' : 'profile_sample_model'
+  const question = String(args.question || args.prompt || '').trim()
+  const targetBuilder = String(args.targetBuilder || args.audience || profile.segment).trim()
+
+  return {
+    mode: state.mode === 'enterprise' ? 'enterprise' : 'enterprise_preview',
+    dataSource,
+    liveData: state.enterpriseToken
+      ? 'enterprise credential configured; this local brief still uses supplied metrics unless a live endpoint is explicitly called'
+      : 'not connected; browser login is not available inside Codex/Cursor MCP',
+    organizationId: organizationId || null,
+    profile: {
+      key: profileKey,
+      company: profile.company,
+      segment: targetBuilder,
+      buyerProblem: profile.buyerProblem,
+    },
+    question: question || 'How should this enterprise convert builder sessions into retained usage and proof?',
+    sessionSummary: summary,
+    sessions,
+    primaryInsight: `${profile.company}: the current constraint is ${bottleneck.label} at ${bottleneck.rate}%. ${bottleneck.action}`,
+    costEconomics,
+    icpAnalysis,
+    sessionStrategy,
+    recommendedOffer: {
+      headline: profile.offers?.[0] || ENTERPRISE_PROFILE_PRESETS.default.offers[0],
+      whyItAttractsBuilders:
+        'It pays builders only when they create a working artifact, which aligns enterprise spend with proof instead of vanity attendance.',
+      claimMechanic:
+        'Gate the perk on a submitted repo/demo plus one first-success event; upgrade to retained-usage rewards after a second qualifying event.',
+      alternatives: (profile.offers ?? ENTERPRISE_PROFILE_PRESETS.default.offers).slice(1, 3),
+    },
+    eventPlan: {
+      minimumEvents: profile.events ?? ENTERPRISE_PROFILE_PRESETS.default.events,
+      proofDefinition:
+        'A project counts as proof only after repo/demo evidence and first-success evidence are source-labeled; public publication remains human-approved.',
+      accountHandoff:
+        'Export or route account-level actions only from an authorized enterprise workspace, not from unauthenticated MCP output.',
+    },
+    dashboardHandoff,
+    nextActions: [
+      bottleneck.action,
+      costEconomics.nextBudgetMove,
+      `Target ${icpAnalysis.bestSegment} first; run the next cohort with explicit segment tags.`,
+      `Run a ${sessionStrategy.recommendedFormat} next; cadence: ${sessionStrategy.cadence}.`,
+      'Seed one concrete builder offer before the next session; remove generic swag or non-build rewards.',
+      'Ask the agent to call find_perks and build_brief from the builder side so the offer appears where developers already work.',
+      'Use dashboardHandoff links to inspect the same profile in Tokens&; use DAI_TOKEN plus draft_project/publish_project when the built product should appear in the builder dashboard.',
+      'Track install page view -> config copied -> MCP first tool call -> Build Packet read -> perk shown -> project proof.',
+    ],
+    killConditions: [
+      'Under 55% registration-to-attendance after 100 registrations: positioning or reminder loop is weak.',
+      'Under 45% attendee-to-builder-start after 50 attendees: setup path is too slow.',
+      'Under 30% first-success-to-proof after 30 activations: proof workflow or reward is not compelling.',
+      'Under 40% retained usage after 20 activations: session attracted curiosity, not a real workflow.',
+    ],
+    safety: {
+      tenantDataBoundary:
+        'This response does not claim live private enterprise data unless explicit session metrics were supplied by the user or a scoped enterprise credential is used.',
+      approvalBoundary: 'Offer changes, account exports, and public proof publishing stay human-approved.',
+    },
+  }
+}
+
+function listValue(value, fallback = []) {
+  if (Array.isArray(value)) return value.map((item) => String(item).trim()).filter(Boolean)
+  if (typeof value === 'string' && value.trim()) {
+    return value.split(',').map((item) => item.trim()).filter(Boolean)
+  }
+  return fallback
+}
+
+function enterpriseMotionProfile(args, state) {
+  const profileKey = resolveEnterpriseProfile({}, args) || state.enterpriseProfile || 'default'
+  const profile = ENTERPRISE_PROFILE_PRESETS[profileKey] ?? ENTERPRISE_PROFILE_PRESETS.default
+  return { profileKey, profile }
+}
+
+function enterpriseMotionBase(kind, args, state) {
+  const { profileKey, profile } = enterpriseMotionProfile(args, state)
+  const dashboardHandoff = buildDashboardHandoff(state, profileKey)
+  const dashboardConfirmationUrl = enterpriseMotionConfirmationUrl(state, profileKey, kind)
+  return {
+    approvalRequired: true,
+    persisted: false,
+    externalWrites: [],
+    dashboardConfirmationUrl,
+    promise: ENTERPRISE_GROWTH_PROMISE,
+    motionType: kind,
+    detectedMode: state.mode,
+    profile: {
+      key: profileKey,
+      company: String(args.company || profile.company),
+      segment: String(args.icp || args.targetBuilder || args.audience || profile.segment),
+    },
+    dashboardHandoff,
+    boundary: ENTERPRISE_ADOPTION_BOUNDARY,
+    approvalBoundary: ENTERPRISE_ADOPTION_BOUNDARY,
+    nextApprovalActions: [
+      'Review the draft with the enterprise owner.',
+      'Confirm tracking events, ICP filters, partner terms, and proof definition.',
+      `Open ${dashboardConfirmationUrl} to confirm the action in Tokens& before any invite, partner, or proof workflow runs.`,
+    ],
+  }
+}
+
+function enterpriseMotionConfirmationUrl(state, profileKey, kind) {
+  const params = new URLSearchParams()
+  params.set('mode', 'enterprise')
+  if (profileKey && profileKey !== 'default') params.set('profile', profileKey)
+  const pathByKind = {
+    tracked_developer_session: '/dashboard/adoption',
+    adoption_session: '/dashboard/adoption',
+    right_builder_invites: '/dashboard/campaigns',
+    icp_invite_batch: '/dashboard/campaigns',
+    partner_company_onboarding: '/dashboard/campaigns',
+    partner_company_invite: '/dashboard/campaigns',
+    adoption_proof: '/dashboard/reports',
+  }
+  const intentByKind = {
+    tracked_developer_session: 'create-motion',
+    adoption_session: 'create-motion',
+    right_builder_invites: 'preview-icp-builders',
+    icp_invite_batch: 'preview-icp-builders',
+    partner_company_onboarding: 'invite-partner-company',
+    partner_company_invite: 'invite-partner-company',
+    adoption_proof: 'approve-proof-tracking',
+  }
+  params.set('intent', intentByKind[kind] ?? 'create-motion')
+  return `${state.baseUrl}${pathByKind[kind] ?? '/dashboard/adoption'}?${params.toString()}`
+}
+
+function draftEnterpriseSessionMotion(args, state) {
+  const base = enterpriseMotionBase('tracked_developer_session', args, state)
+  const { profile } = enterpriseMotionProfile(args, state)
+  const events = listValue(args.trackingEvents || args.events, profile.events ?? ENTERPRISE_PROFILE_PRESETS.default.events)
+  const sessionFormat = String(args.format || args.sessionFormat || profile.sessionFormats?.[0]?.format || 'builder activation lab')
+  const sessionName = String(args.sessionName || args.title || profile.sessionLabel)
+  const offer = String(args.offer || profile.offers?.[0] || ENTERPRISE_PROFILE_PRESETS.default.offers[0])
+  const sourceProvider = String(args.sourceProvider || args.externalSourceProvider || 'manual').toLowerCase()
+  const partnerCompany = String(args.partnerCompany || args.partner || '')
+  return {
+    ...base,
+    draft: {
+      sessionName,
+      format: sessionFormat,
+      audience: base.profile.segment,
+      offer,
+      externalSource: {
+        provider: ['luma', 'partiful', 'eventbrite', 'zoom', 'manual'].includes(sourceProvider) ? sourceProvider : 'manual',
+        sourceUrl: args.sourceUrl ? String(args.sourceUrl) : null,
+        noExternalEventPageCreated: true,
+        noExternalInvitesSent: true,
+      },
+      partnerIntake: {
+        label: 'Invite partner company',
+        partnerCompany: partnerCompany || null,
+        status: 'draft_link_only',
+      },
+      trackingPlan: events.map((eventName) => ({
+        eventName,
+        why: 'Required to connect attendance, first success, retention, and proof back to the motion.',
+      })),
+      successCriteria: {
+        attendanceRate: '>= 55% registration-to-attendance',
+        builderStartRate: '>= 45% attendee-to-builder-start',
+        proofRate: '>= 30% first-success-to-proof',
+        retainedUsageRate: '>= 40% retained usage after activation',
+      },
+      approvalChecklist: [
+        'Confirm the ICP and exclusion rules.',
+        'Confirm the offer can be fulfilled.',
+        'Confirm tracking links/events before invites go out.',
+        'Confirm proof publication stays opt-in.',
+      ],
+    },
+  }
+}
+
+function draftBuilderInviteMotion(args, state, motionType = 'right_builder_invites') {
+  const base = enterpriseMotionBase(motionType, args, state)
+  const { profile } = enterpriseMotionProfile(args, state)
+  const segments = listValue(
+    args.segments || args.icpSegments,
+    (profile.icpSegments ?? ENTERPRISE_PROFILE_PRESETS.default.icpSegments).slice(0, 3).map((segment) => segment.name),
+  )
+  const channels = listValue(args.channels, ['Tokens& builder graph', 'Codex/Cursor agent touchpoints', 'project proof history', 'partner/community lists approved by the customer'])
+  const offer = String(args.offer || profile.offers?.[0] || ENTERPRISE_PROFILE_PRESETS.default.offers[0])
+  return {
+    ...base,
+    draft: {
+      targetSegments: segments,
+      channels,
+      offer,
+      qualificationFilters: [
+        'Recent build, repo, docs, API, or project-proof signal.',
+        'ICP match based on product workflow, stack, company domain, or role.',
+        'No raw private developer identity export unless the enterprise workspace has lawful basis and approval.',
+      ],
+      inviteCopy: {
+        subject: `${base.profile.company}: build with ${offer}`,
+        body:
+          `Invite builders who can produce a working artifact. The ask is one concrete build, one tracked first-success event, and optional proof review.`,
+      },
+      approvalChecklist: [
+        'Approve the source list and suppression rules.',
+        'Approve the offer copy.',
+        'Approve send channel and rate limits.',
+        'Confirm tracking URLs before launch.',
+      ],
+    },
+  }
+}
+
+function draftPartnerOnboardingMotion(args, state) {
+  const base = enterpriseMotionBase('partner_company_onboarding', args, state)
+  const partnerCompany = String(args.partnerCompany || args.partner || 'partner company')
+  const sharedAudience = String(args.sharedAudience || args.audience || base.profile.segment)
+  const offer = String(args.offer || `co-build session for ${sharedAudience}`)
+  return {
+    ...base,
+    draft: {
+      label: 'Invite partner company',
+      partnerCompany,
+      sharedAudience,
+      partnerPromise:
+        `Co-run one tracked developer session with ${partnerCompany}, invite the overlapping builder segment, and prove which partner surface created activation.`,
+      offer,
+      inviteChecklist: [
+        'Confirm partner owner, logo/name usage, and approval contact.',
+        'Agree on shared ICP and excluded audiences.',
+        'Agree on source tags, UTM naming, and proof definition.',
+        'Queue partner-facing copy for human approval before publishing.',
+      ],
+      trackingPlan: [
+        'partner_invited',
+        'partner_session_registered',
+        'partner_session_attended',
+        'partner_tool_used',
+        'partner_proof_submitted',
+      ],
+      dataBoundary:
+        'Share aggregate-safe proof and approved account/company context only; do not expose raw private builder identities through MCP output.',
+    },
+  }
+}
+
+function draftAdoptionProofMotion(args, state) {
+  const base = enterpriseMotionBase('adoption_proof', args, state)
+  const evidenceSources = listValue(args.evidenceSources, ['tracked session events', 'repo/demo proof', 'first-success event', 'retained usage event', 'account-domain rollup'])
+  const proofDefinition = String(
+    args.proofDefinition ||
+      'A builder counts as proof after a repo/demo or product artifact is tied to one first-success event and one source-labeled product usage signal.',
+  )
+  return {
+    ...base,
+    draft: {
+      proofDefinition,
+      evidenceSources,
+      readoutAudience: String(args.readoutAudience || 'enterprise operator, product lead, revenue owner, and executive sponsor'),
+      metrics: [
+        'registrations',
+        'attended',
+        'builder starts',
+        'first successes',
+        'retained builders',
+        'proof projects',
+        'qualified accounts',
+        'cost per proof project',
+      ],
+      publicationBoundary:
+        'Private proof stays inside the enterprise workspace. Public proof requires builder/customer approval and a separate publish action.',
+      approvalChecklist: [
+        'Approve proof definition.',
+        'Approve evidence sources and privacy scope.',
+        'Approve readout audience.',
+        'Approve any public proof or account export separately.',
+      ],
+    },
+  }
+}
+
+function writeMcpMessage(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`)
+}
+
+function parseMcpBuffer(buffer, onMessage) {
+  let rest = buffer
+  while (rest.length > 0) {
+    if (rest.startsWith('Content-Length:')) {
+      const headerEnd = rest.indexOf('\r\n\r\n')
+      if (headerEnd === -1) break
+      const header = rest.slice(0, headerEnd)
+      const match = header.match(/Content-Length:\s*(\d+)/i)
+      if (!match) break
+      const length = Number(match[1])
+      const bodyStart = headerEnd + 4
+      const bodyEnd = bodyStart + length
+      if (rest.length < bodyEnd) break
+      onMessage(JSON.parse(rest.slice(bodyStart, bodyEnd)))
+      rest = rest.slice(bodyEnd)
+      continue
+    }
+
+    const newline = rest.indexOf('\n')
+    if (newline === -1) break
+    const line = rest.slice(0, newline).trim()
+    rest = rest.slice(newline + 1)
+    if (line) onMessage(JSON.parse(line))
+  }
+  return rest
+}
+
+async function workflowApi(path, { method = 'GET', body, token, baseUrl }) {
+  return api(path, { method, body, token, baseUrl })
+}
+
+async function trackAgentInstallEvent(state, event, metadata = {}) {
+  if (process.env.DAI_DISABLE_TELEMETRY === '1') return
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), TRACKING_TIMEOUT_MS)
+  try {
+    const headers = { 'content-type': 'application/json', accept: 'application/json' }
+    if (state.token) headers.authorization = `Bearer ${state.token}`
+    await fetch(`${state.baseUrl}/api/agent-install/events`, {
+      method: 'POST',
+      headers,
+      signal: controller.signal,
+      body: JSON.stringify({
+        event,
+        source: 'mcp',
+        metadata: {
+          ...metadata,
+          cliVersion: VERSION,
+          mcpServer: 'tokensand',
+          mcpMode: state.mode,
+          publicOnly: !state.token,
+          hasEnterpriseContext: Boolean(state.enterpriseToken || state.organizationId || state.enterpriseProfile),
+        },
+      }),
+    })
+  } catch {
+    // Telemetry must never block MCP utility.
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+async function trackMcpToolCall(state, toolName, args = {}) {
+  const metadata = {
+    tool: toolName,
+    hasToken: Boolean(state.token),
+    mcpMode: state.mode,
+    categorySlug: typeof args.categorySlug === 'string' ? args.categorySlug : undefined,
+    category: typeof args.category === 'string' ? args.category : undefined,
+    format: typeof args.format === 'string' ? args.format : undefined,
+    confirmed: Boolean(args.confirm),
+  }
+  if (!state.firstToolCallTracked) {
+    state.firstToolCallTracked = true
+    await trackAgentInstallEvent(state, 'agent_install_mcp_first_tool_call', metadata)
+  }
+  await trackAgentInstallEvent(state, 'agent_install_mcp_tool_call', metadata)
+}
+
+function workflowToken(config = {}) {
+  return config.token || process.env.DAI_TOKEN || process.env.DAI_WORKFLOW_TOKEN || ''
+}
+
+async function readText(path) {
+  return readFile(path, 'utf8').catch(() => '')
+}
+
+async function readFirstExisting(paths) {
+  for (const path of paths) {
+    const value = await readText(path)
+    if (value) return value
+  }
+  return ''
+}
+
+function safeJson(raw) {
+  if (!raw) return null
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return null
+  }
+}
+
+function dependencyNames(packageJson) {
+  if (!packageJson) return []
+  return Object.keys({
+    ...(packageJson.dependencies ?? {}),
+    ...(packageJson.devDependencies ?? {}),
+    ...(packageJson.peerDependencies ?? {}),
+    ...(packageJson.optionalDependencies ?? {}),
+  }).sort()
+}
+
+function gitRemoteFromConfig(configText) {
+  const lines = configText.split('\n')
+  let inOrigin = false
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (/^\[remote\s+"origin"\]/.test(trimmed)) {
+      inOrigin = true
+      continue
+    }
+    if (trimmed.startsWith('[')) inOrigin = false
+    if (inOrigin && trimmed.startsWith('url =')) return trimmed.replace(/^url =\s*/, '').trim()
+  }
+  return ''
+}
+
+function normalizeRemoteUrl(value = '') {
+  const trimmed = value.trim()
+  if (!trimmed) return ''
+  const ssh = trimmed.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/i)
+  if (ssh) return `https://github.com/${ssh[1]}/${ssh[2].replace(/\.git$/i, '')}`
+  const github = trimmed.match(/^https?:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?(?:\/)?$/i)
+  if (github) return `https://github.com/${github[1]}/${github[2].replace(/\.git$/i, '')}`
+  return trimmed
+}
+
+function parseProjectFlags(args = []) {
+  const flags = { yes: false }
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]
+    if (arg === '--yes' || arg === '-y') {
+      flags.yes = true
+      continue
+    }
+    if (arg === '--repo') {
+      flags.repoUrl = args[i + 1] || ''
+      i += 1
+      continue
+    }
+    if (arg === '--demo') {
+      flags.demoUrl = args[i + 1] || ''
+      i += 1
+      continue
+    }
+    if (arg === '--image') {
+      flags.imageUrl = args[i + 1] || ''
+      i += 1
+      continue
+    }
+    if (arg === '--title') {
+      flags.title = args[i + 1] || ''
+      i += 1
+      continue
+    }
+    if (arg === '--summary') {
+      flags.summary = args[i + 1] || ''
+      i += 1
+      continue
+    }
+  }
+  return flags
+}
+
+function projectArgsToFlags(args = {}) {
+  return {
+    repoUrl: args.repoUrl || args.repo,
+    demoUrl: args.demoUrl || args.demo,
+    imageUrl: args.imageUrl || args.image,
+    title: args.title,
+    summary: args.summary || args.localSummary,
+  }
+}
+
+async function localProjectPayload(flags = {}) {
+  const cwd = process.cwd()
+  const packageRaw = await readText('package.json')
+  const packageJson = safeJson(packageRaw)
+  const readme = await readFirstExisting(['README.md', 'readme.md', 'README.mdx', 'README'])
+  const gitConfig = await readText('.git/config')
+  const remoteUrl = normalizeRemoteUrl(flags.repoUrl || gitRemoteFromConfig(gitConfig))
+  const dependencies = dependencyNames(packageJson)
+  const demoUrl = flags.demoUrl || (typeof packageJson?.homepage === 'string' ? packageJson.homepage : '')
+
+  return {
+    repoUrl: remoteUrl,
+    readme,
+    packageJson: packageRaw || undefined,
+    demoUrl,
+    imageUrl: flags.imageUrl || '',
+    localMetadata: {
+      cwdName: basename(cwd),
+      packageName: typeof packageJson?.name === 'string' ? packageJson.name : '',
+      localSummary: flags.summary || (typeof packageJson?.description === 'string' ? packageJson.description : ''),
+      remoteUrl,
+      detectedDependencies: dependencies,
+    },
+  }
+}
+
+function projectBodyFromDraft(draftResponse, overrides = {}) {
+  const draft = draftResponse?.draft ?? {}
+  return {
+    title: overrides.title || draft.title,
+    summary: overrides.summary || draft.summary,
+    description: overrides.description || draft.description,
+    repoUrl: overrides.repoUrl || draft.repoUrl,
+    demoUrl: overrides.demoUrl || draft.demoUrl,
+    imageUrl: overrides.imageUrl || draft.imageUrl,
+    tools: overrides.tools || draft.tools || [],
+  }
+}
+
+function printDraft(draftResponse) {
+  const draft = draftResponse?.draft ?? {}
+  console.log(`Draft: ${draft.title ?? 'Untitled project'}`)
+  if (draft.repoUrl) console.log(`Repo: ${draft.repoUrl}`)
+  if (draft.demoUrl) console.log(`Demo: ${draft.demoUrl}`)
+  console.log(`Confidence: ${draftResponse?.confidence ?? 0}%`)
+  if (draftResponse?.duplicateProjectHref) {
+    console.log(`Already published: ${draftResponse.duplicateProjectHref}`)
+    return
+  }
+  const tools = draftResponse?.detectedTools ?? []
+  if (tools.length) {
+    console.log('Detected tools:')
+    for (const item of tools.slice(0, 8)) console.log(`- ${item.tool.name} (${item.role.toLowerCase()})`)
+  } else {
+    console.log('Detected tools: none yet')
+  }
+  const missing = draftResponse?.missingFields ?? []
+  if (missing.length) console.log(`Missing/recommended: ${missing.join(', ')}`)
+}
+
+async function handleMcpRequest(message, state) {
+  const { id, method, params } = message
+  if (!method || method.startsWith('notifications/')) return null
+
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: params?.protocolVersion ?? '2024-11-05',
+        capabilities: {
+          resources: {},
+          tools: {},
+        },
+        serverInfo: { name: 'directory-ai-tools', version: VERSION },
+      },
+    }
+  }
+
+  if (method === 'resources/list') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        resources: [
+          {
+            uri: 'dai://developer/context',
+            name: 'Developer context',
+            description: 'Profile, project, saved stack, recommendations, and tool metadata.',
+            mimeType: 'application/json',
+          },
+          {
+            uri: 'dai://developer/context.md',
+            name: 'Developer context markdown',
+            description: 'Markdown context pack for coding agents.',
+            mimeType: 'text/markdown',
+          },
+          {
+            uri: 'dai://developer/build-packet',
+            name: 'Latest Build Packet',
+            description: 'Latest Stack Advisor build packet with stack, costs, safety boundary, evals, env vars, and proof loop.',
+            mimeType: 'application/json',
+          },
+          {
+            uri: 'dai://developer/build-packet.md',
+            name: 'Latest Build Packet markdown',
+            description: 'Markdown build handoff packet for coding agents.',
+            mimeType: 'text/markdown',
+          },
+          {
+            uri: 'dai://account/mode',
+            name: 'Tokens& MCP account mode',
+            description: 'Explains whether this MCP server is running as public, developer, or enterprise context.',
+            mimeType: 'application/json',
+          },
+        ],
+      },
+    }
+  }
+
+  if (method === 'resources/read') {
+    const uri = params?.uri ?? 'dai://developer/context'
+    if (uri === 'dai://account/mode') {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          contents: [
+            {
+              uri,
+              mimeType: 'application/json',
+              text: JSON.stringify(accountModePayload(state), null, 2),
+            },
+          ],
+        },
+      }
+    }
+    if (!state.token) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          contents: [authRequiredContent(state, uri)],
+        },
+      }
+    }
+    const markdown = uri.endsWith('.md')
+    const isBuildPacket = uri.includes('/build-packet')
+    const path = isBuildPacket
+      ? `/api/workflow/build-packet${markdown ? '?format=markdown' : ''}`
+      : markdown ? '/api/workflow/context?format=markdown' : '/api/workflow/context'
+    const content = await workflowApi(path, { token: state.token, baseUrl: state.baseUrl })
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        contents: [
+          {
+            uri,
+            mimeType: markdown ? 'text/markdown' : 'application/json',
+            text: typeof content === 'string' ? content : JSON.stringify(content, null, 2),
+          },
+        ],
+      },
+    }
+  }
+
+  if (method === 'tools/list') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        tools: [
+          {
+            name: 'get_account_mode',
+            description: 'Explain whether Tokens& MCP is running in public, developer, or enterprise mode and which private surfaces are unlocked.',
+            inputSchema: {
+              type: 'object',
+              properties: {},
+            },
+          },
+          {
+            name: 'get_context',
+            description: 'Read developer profile, saved stack, latest recommendations, and active project context.',
+            inputSchema: {
+              type: 'object',
+              properties: { format: { type: 'string', enum: ['json', 'markdown'] } },
+            },
+          },
+          {
+            name: 'get_build_packet',
+            description: 'Read the latest Tokens& Build Packet for the selected Stack Advisor recommendation before coding.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                recommendationId: { type: 'string' },
+                variant: { type: 'string', enum: ['best', 'cheapest', 'fastest', 'open_source', 'enterprise'] },
+                format: { type: 'string', enum: ['json', 'markdown'] },
+              },
+            },
+          },
+          {
+            name: 'search_tools',
+            description: 'Search stack/tool recommendations by developer intent.',
+            inputSchema: {
+              type: 'object',
+              required: ['query'],
+              properties: {
+                query: { type: 'string' },
+                limit: { type: 'number', minimum: 1, maximum: 30 },
+              },
+            },
+          },
+          {
+            name: 'find_perks',
+            description: 'Find public builder credits, offers, startup programs, events, and Tokens& starter-kit perks.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                categorySlug: { type: 'string' },
+                toolId: { type: 'string' },
+                limit: { type: 'number', minimum: 1, maximum: 50 },
+              },
+            },
+          },
+          {
+            name: 'get_adoption_rank',
+            description: 'Read public AgentRank/adoption evidence for tools before choosing a stack.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                tool: { type: 'string' },
+                category: { type: 'string' },
+                period: { type: 'string', enum: ['7d', '30d', '90d'] },
+                limit: { type: 'number', minimum: 1, maximum: 200 },
+              },
+            },
+          },
+          {
+            name: 'build_brief',
+            description: 'Create a public Tokens& builder brief: best APIs, cost drivers, free credits/perks, stack suggestions, adoption evidence, dashboard sync path, and next agent actions.',
+            inputSchema: {
+              type: 'object',
+              required: ['intent'],
+              properties: {
+                intent: { type: 'string' },
+                query: { type: 'string' },
+                useCase: { type: 'string', description: 'Optional app type such as customer_agent, support_agent, rag_app, internal_tool, or api_integration.' },
+                category: { type: 'string' },
+                categorySlug: { type: 'string' },
+                pricing: { type: 'string' },
+                openSource: { type: 'boolean' },
+                enterpriseReady: { type: 'boolean' },
+                period: { type: 'string', enum: ['7d', '30d', '90d'] },
+                limit: { type: 'number', minimum: 1, maximum: 10 },
+              },
+            },
+          },
+          {
+            name: 'enterprise_session_brief',
+            description: 'Analyze enterprise builder-session metrics or a labeled sample profile to improve perks, activation, retention, and proof loops.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                question: { type: 'string' },
+                profile: { type: 'string', description: 'Company/profile key such as redis, assemblyai, clickhouse, or supabase.' },
+                company: { type: 'string' },
+                organizationId: { type: 'string' },
+                targetBuilder: { type: 'string' },
+                sessionName: { type: 'string' },
+                budgetUsd: { type: 'number', description: 'Campaign/session budget used for cost-per-activation/proof math.' },
+                campaignBudgetUsd: { type: 'number' },
+                sessionBudgetUsd: { type: 'number' },
+                registrations: { type: 'number' },
+                attended: { type: 'number' },
+                attendees: { type: 'number' },
+                builders: { type: 'number' },
+                activated: { type: 'number' },
+                firstSuccesses: { type: 'number' },
+                retained: { type: 'number' },
+                retainedBuilders: { type: 'number' },
+                proofCount: { type: 'number' },
+                proofProjects: { type: 'number' },
+                live: { type: 'boolean', description: 'Set true only when requesting live private enterprise data.' },
+                session: {
+                  type: 'object',
+                  description: 'Single session metrics. Use this when the agent is analyzing one event, lab, workshop, or proof sprint.',
+                  properties: {
+                    name: { type: 'string' },
+                    date: { type: 'string' },
+                    costUsd: { type: 'number' },
+                    budgetUsd: { type: 'number' },
+                    channel: { type: 'string' },
+                    icpSegment: { type: 'string' },
+                    registrations: { type: 'number' },
+                    attended: { type: 'number' },
+                    attendees: { type: 'number' },
+                    builders: { type: 'number' },
+                    activated: { type: 'number' },
+                    firstSuccesses: { type: 'number' },
+                    retained: { type: 'number' },
+                    retainedBuilders: { type: 'number' },
+                    proofCount: { type: 'number' },
+                    proofProjects: { type: 'number' },
+                    offer: { type: 'string' },
+                    notes: { type: 'string' },
+                  },
+                },
+                sessions: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string' },
+                      date: { type: 'string' },
+                      costUsd: { type: 'number' },
+                      budgetUsd: { type: 'number' },
+                      channel: { type: 'string' },
+                      icpSegment: { type: 'string' },
+                      registrations: { type: 'number' },
+                      attended: { type: 'number' },
+                      attendees: { type: 'number' },
+                      builders: { type: 'number' },
+                      activated: { type: 'number' },
+                      firstSuccesses: { type: 'number' },
+                      retained: { type: 'number' },
+                      retainedBuilders: { type: 'number' },
+                      proofCount: { type: 'number' },
+                      proofProjects: { type: 'number' },
+                      offer: { type: 'string' },
+                      notes: { type: 'string' },
+                    },
+                  },
+                },
+                segments: {
+                  type: 'array',
+                  description: 'Optional ICP segment metrics to rank instead of using profile defaults.',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string' },
+                      builders: { type: 'number' },
+                      activated: { type: 'number' },
+                      firstSuccesses: { type: 'number' },
+                      retained: { type: 'number' },
+                      retainedBuilders: { type: 'number' },
+                      proofCount: { type: 'number' },
+                      proofProjects: { type: 'number' },
+                      pipelineUsd: { type: 'number' },
+                      score: { type: 'number' },
+                      reason: { type: 'string' },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          {
+            name: 'draft_enterprise_session_motion',
+            description: `Approval-only draft for the enterprise promise: ${ENTERPRISE_GROWTH_PROMISE}`,
+            inputSchema: {
+              type: 'object',
+              properties: {
+                profile: { type: 'string', description: 'Company/profile key such as redis, assemblyai, clickhouse, or supabase.' },
+                company: { type: 'string' },
+                sessionName: { type: 'string' },
+                title: { type: 'string' },
+                icp: { type: 'string' },
+                audience: { type: 'string' },
+                targetBuilder: { type: 'string' },
+                format: { type: 'string' },
+                sessionFormat: { type: 'string' },
+                offer: { type: 'string' },
+                trackingEvents: { type: 'array', items: { type: 'string' } },
+                events: { type: 'array', items: { type: 'string' } },
+                budgetUsd: { type: 'number' },
+              },
+            },
+          },
+          {
+            name: 'draft_adoption_session',
+            description: `Alias for draft_enterprise_session_motion. Approval-only draft for creating a tracked Tokens& adoption session; external event pages are not created.`,
+            inputSchema: {
+              type: 'object',
+              properties: {
+                profile: { type: 'string', description: 'Company/profile key such as redis, assemblyai, clickhouse, or supabase.' },
+                company: { type: 'string' },
+                sessionName: { type: 'string' },
+                title: { type: 'string' },
+                icp: { type: 'string' },
+                audience: { type: 'string' },
+                targetBuilder: { type: 'string' },
+                format: { type: 'string' },
+                sessionFormat: { type: 'string' },
+                sourceProvider: { type: 'string', description: 'luma, partiful, eventbrite, zoom, or manual.' },
+                sourceUrl: { type: 'string' },
+                partnerCompany: { type: 'string' },
+                offer: { type: 'string' },
+                trackingEvents: { type: 'array', items: { type: 'string' } },
+                events: { type: 'array', items: { type: 'string' } },
+                budgetUsd: { type: 'number' },
+              },
+            },
+          },
+          {
+            name: 'draft_builder_invite_motion',
+            description: 'Approval-only draft for inviting the right builders into a tracked enterprise motion.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                profile: { type: 'string' },
+                company: { type: 'string' },
+                icp: { type: 'string' },
+                audience: { type: 'string' },
+                segments: { type: 'array', items: { type: 'string' } },
+                icpSegments: { type: 'array', items: { type: 'string' } },
+                channels: { type: 'array', items: { type: 'string' } },
+                offer: { type: 'string' },
+              },
+            },
+          },
+          {
+            name: 'draft_icp_invite_batch',
+            description: 'Approval-only draft for previewing and approving an aggregate ICP builder invite batch.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                profile: { type: 'string' },
+                company: { type: 'string' },
+                icp: { type: 'string' },
+                audience: { type: 'string' },
+                segments: { type: 'array', items: { type: 'string' } },
+                icpSegments: { type: 'array', items: { type: 'string' } },
+                channels: { type: 'array', items: { type: 'string' } },
+                offer: { type: 'string' },
+              },
+            },
+          },
+          {
+            name: 'draft_partner_onboarding_motion',
+            description: 'Approval-only draft for inviting a partner company into a tracked builder session or proof motion.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                profile: { type: 'string' },
+                company: { type: 'string' },
+                partnerCompany: { type: 'string' },
+                partner: { type: 'string' },
+                sharedAudience: { type: 'string' },
+                audience: { type: 'string' },
+                offer: { type: 'string' },
+              },
+            },
+          },
+          {
+            name: 'draft_partner_invite',
+            description: 'Alias for draft_partner_onboarding_motion. Approval-only draft for Invite partner company.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                profile: { type: 'string' },
+                company: { type: 'string' },
+                partnerCompany: { type: 'string' },
+                partner: { type: 'string' },
+                sharedAudience: { type: 'string' },
+                audience: { type: 'string' },
+                offer: { type: 'string' },
+              },
+            },
+          },
+          {
+            name: 'draft_adoption_proof_motion',
+            description: 'Approval-only draft for defining proof of adoption before publishing, exporting, or changing GTM actions.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                profile: { type: 'string' },
+                company: { type: 'string' },
+                icp: { type: 'string' },
+                proofDefinition: { type: 'string' },
+                evidenceSources: { type: 'array', items: { type: 'string' } },
+                readoutAudience: { type: 'string' },
+              },
+            },
+          },
+          {
+            name: 'draft_project',
+            description: 'Infer a tokens& project draft from the current local repo before publishing.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                autoDetect: { type: 'boolean' },
+                repoUrl: { type: 'string' },
+                demoUrl: { type: 'string' },
+                imageUrl: { type: 'string' },
+                readme: { type: 'string' },
+                packageJson: { type: 'string' },
+                localSummary: { type: 'string' },
+                detectedDependencies: { type: 'array', items: { type: 'string' } },
+              },
+            },
+          },
+          {
+            name: 'publish_project',
+            description: 'Publish a built project back to tokens&. Use autoDetect first, then confirm before creating the public project.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                autoDetect: { type: 'boolean' },
+                confirm: { type: 'boolean', description: 'Required for auto-detected publishing after reviewing the draft.' },
+                title: { type: 'string' },
+                summary: { type: 'string' },
+                description: { type: 'string' },
+                repoUrl: { type: 'string' },
+                demoUrl: { type: 'string' },
+                imageUrl: { type: 'string' },
+                localSummary: { type: 'string' },
+                detectedDependencies: { type: 'array', items: { type: 'string' } },
+                tools: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    required: ['toolId'],
+                    properties: {
+                      toolId: { type: 'string' },
+                      role: { type: 'string', enum: ['PRIMARY', 'USED', 'EVALUATED', 'REPLACED'] },
+                      note: { type: 'string' },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          {
+            name: 'update_build_progress',
+            description: 'Draft a build-progress update for human approval. V1 does not write externally.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                status: { type: 'string' },
+                summary: { type: 'string' },
+                evidenceUrl: { type: 'string' },
+              },
+            },
+          },
+          {
+            name: 'attach_repo',
+            description: 'Draft a repo attachment for human approval before publishing proof.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                repoUrl: { type: 'string' },
+                demoUrl: { type: 'string' },
+                confirm: { type: 'boolean' },
+              },
+            },
+          },
+          {
+            name: 'record_launch_event',
+            description: 'Draft a launch-event record for human approval before it affects public proof.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                source: { type: 'string' },
+                url: { type: 'string' },
+                summary: { type: 'string' },
+              },
+            },
+          },
+          {
+            name: 'submit_stack_feedback',
+            description: 'Draft stack feedback for human approval and future recommendation learning.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                rating: { type: 'string' },
+                feedback: { type: 'string' },
+                selectedTools: { type: 'array', items: { type: 'string' } },
+              },
+            },
+          },
+        ],
+      },
+    }
+  }
+
+  if (method === 'tools/call') {
+    const name = params?.name
+    const args = params?.arguments ?? {}
+    if (name) await trackMcpToolCall(state, name, args)
+    if (name === 'get_account_mode') {
+      return { jsonrpc: '2.0', id, result: mcpText(accountModePayload(state)) }
+    }
+    if (name === 'get_context') {
+      if (!state.token) return { jsonrpc: '2.0', id, result: mcpText(authRequiredPayload(state, name)) }
+      const markdown = args.format === 'markdown'
+      const content = await workflowApi(markdown ? '/api/workflow/context?format=markdown' : '/api/workflow/context', {
+        token: state.token,
+        baseUrl: state.baseUrl,
+      })
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (name === 'get_build_packet') {
+      if (!state.token) return { jsonrpc: '2.0', id, result: mcpText(authRequiredPayload(state, name)) }
+      const params = new URLSearchParams()
+      if (args.recommendationId) params.set('recommendationId', String(args.recommendationId))
+      if (args.variant) params.set('variant', String(args.variant))
+      if (args.format === 'markdown') params.set('format', 'markdown')
+      const suffix = params.toString() ? `?${params.toString()}` : ''
+      const content = await workflowApi(`/api/workflow/build-packet${suffix}`, {
+        token: state.token,
+        baseUrl: state.baseUrl,
+      })
+      await trackAgentInstallEvent(state, 'agent_install_build_packet_read', {
+        recommendationId: args.recommendationId,
+        variant: args.variant,
+        format: args.format,
+      })
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (name === 'search_tools') {
+      const query = String(args.query ?? '').trim()
+      if (!query) throw new Error('search_tools requires a query')
+      const params = new URLSearchParams({ q: query, limit: String(args.limit ?? 12) })
+      const content = await workflowApi(`/api/build/search?${params.toString()}`, { baseUrl: state.baseUrl })
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (name === 'find_perks') {
+      const params = new URLSearchParams({ limit: String(args.limit ?? 12) })
+      if (args.categorySlug) params.set('categorySlug', String(args.categorySlug))
+      if (args.toolId) params.set('toolId', String(args.toolId))
+      const content = await workflowApi(`/api/perks?${params.toString()}`, { baseUrl: state.baseUrl })
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (name === 'get_adoption_rank') {
+      const params = new URLSearchParams({ limit: String(args.limit ?? 10) })
+      if (args.tool) params.set('tool', String(args.tool))
+      if (args.category) params.set('category', String(args.category))
+      if (args.period) params.set('period', String(args.period))
+      const content = await workflowApi(`/api/v1/adoption?${params.toString()}`, { baseUrl: state.baseUrl })
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (name === 'build_brief') {
+      const content = await publicBuildBrief(args, state)
+      if (content.matchedPerks?.length) {
+        await trackAgentInstallEvent(state, 'agent_install_perk_shown', {
+          intent: content.intent,
+          categorySlug: args.categorySlug,
+          perkCount: content.matchedPerks.length,
+          toolCount: content.stackCandidates?.length ?? 0,
+        })
+      }
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (name === 'enterprise_session_brief') {
+      const content = enterpriseSessionBrief(args, state)
+      if (!content.authRequired) {
+        await trackAgentInstallEvent(state, 'agent_install_enterprise_session_brief', {
+          dataSource: content.dataSource,
+          profile: content.profile?.key,
+          organizationId: content.organizationId ? 'configured' : undefined,
+        })
+      }
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (name === 'draft_enterprise_session_motion' || name === 'draft_adoption_session') {
+      return { jsonrpc: '2.0', id, result: mcpText(draftEnterpriseSessionMotion(args, state)) }
+    }
+    if (name === 'draft_builder_invite_motion') {
+      return { jsonrpc: '2.0', id, result: mcpText(draftBuilderInviteMotion(args, state)) }
+    }
+    if (name === 'draft_icp_invite_batch') {
+      return { jsonrpc: '2.0', id, result: mcpText(draftBuilderInviteMotion(args, state, 'icp_invite_batch')) }
+    }
+    if (name === 'draft_partner_onboarding_motion' || name === 'draft_partner_invite') {
+      return { jsonrpc: '2.0', id, result: mcpText(draftPartnerOnboardingMotion(args, state)) }
+    }
+    if (name === 'draft_adoption_proof_motion') {
+      return { jsonrpc: '2.0', id, result: mcpText(draftAdoptionProofMotion(args, state)) }
+    }
+    if (name === 'draft_project') {
+      if (!state.token) return { jsonrpc: '2.0', id, result: mcpText(authRequiredPayload(state, name)) }
+      const localPayload = args.autoDetect === false ? {} : await localProjectPayload(projectArgsToFlags(args))
+      const body = {
+        ...localPayload,
+        repoUrl: args.repoUrl || localPayload.repoUrl,
+        readme: args.readme || localPayload.readme,
+        packageJson: args.packageJson || localPayload.packageJson,
+        demoUrl: args.demoUrl || localPayload.demoUrl,
+        imageUrl: args.imageUrl || localPayload.imageUrl,
+        localMetadata: {
+          ...(localPayload.localMetadata ?? {}),
+          localSummary: args.localSummary || localPayload.localMetadata?.localSummary,
+          detectedDependencies: args.detectedDependencies || localPayload.localMetadata?.detectedDependencies,
+        },
+      }
+      const content = await workflowApi('/api/workflow/projects/draft', {
+        method: 'POST',
+        body,
+        token: state.token,
+        baseUrl: state.baseUrl,
+      })
+      await trackAgentInstallEvent(state, 'agent_install_project_proof_drafted', {
+        autoDetect: args.autoDetect !== false,
+        detectedDependencies: body.localMetadata?.detectedDependencies?.length,
+      })
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (name === 'publish_project') {
+      if (!state.token) return { jsonrpc: '2.0', id, result: mcpText(authRequiredPayload(state, name)) }
+      if (args.autoDetect || !args.tools) {
+        const localPayload = await localProjectPayload(projectArgsToFlags(args))
+        const draft = await workflowApi('/api/workflow/projects/draft', {
+          method: 'POST',
+          body: {
+            ...localPayload,
+            repoUrl: args.repoUrl || localPayload.repoUrl,
+            readme: args.readme || localPayload.readme,
+            packageJson: args.packageJson || localPayload.packageJson,
+            demoUrl: args.demoUrl || localPayload.demoUrl,
+            imageUrl: args.imageUrl || localPayload.imageUrl,
+            localMetadata: {
+              ...(localPayload.localMetadata ?? {}),
+              localSummary: args.localSummary || localPayload.localMetadata?.localSummary,
+              detectedDependencies: args.detectedDependencies || localPayload.localMetadata?.detectedDependencies,
+            },
+          },
+          token: state.token,
+          baseUrl: state.baseUrl,
+        })
+        if (draft.duplicateProjectHref) {
+          return {
+            jsonrpc: '2.0',
+            id,
+            result: mcpText({
+              message: 'This repository is already published. Add an update instead of creating a duplicate.',
+              duplicateProjectHref: draft.duplicateProjectHref,
+              draft,
+            }),
+          }
+        }
+        if (!args.confirm) {
+          await trackAgentInstallEvent(state, 'agent_install_project_proof_drafted', {
+            autoDetect: true,
+            requiresConfirmation: true,
+            detectedTools: draft.detectedTools?.length,
+          })
+          return {
+            jsonrpc: '2.0',
+            id,
+            result: mcpText({
+              message: 'Review this draft with the user. Call publish_project again with confirm: true to publish.',
+              draft,
+            }),
+          }
+        }
+        if (!draft.draft?.tools?.length) {
+          return {
+            jsonrpc: '2.0',
+            id,
+            result: mcpText({
+              message: 'I could not infer approved tools from this repo yet. Ask the user to choose tools or pass tools explicitly.',
+              draft,
+            }),
+          }
+        }
+        const content = await workflowApi('/api/workflow/projects', {
+          method: 'POST',
+          body: projectBodyFromDraft(draft, args),
+          token: state.token,
+          baseUrl: state.baseUrl,
+        })
+        await trackAgentInstallEvent(state, 'agent_install_project_proof_published', {
+          autoDetect: true,
+          toolCount: draft.draft?.tools?.length ?? 0,
+        })
+        return { jsonrpc: '2.0', id, result: mcpText(content) }
+      }
+      const content = await workflowApi('/api/workflow/projects', {
+        method: 'POST',
+        body: args,
+        token: state.token,
+        baseUrl: state.baseUrl,
+      })
+      await trackAgentInstallEvent(state, 'agent_install_project_proof_published', {
+        autoDetect: false,
+        toolCount: Array.isArray(args.tools) ? args.tools.length : 0,
+      })
+      return { jsonrpc: '2.0', id, result: mcpText(content) }
+    }
+    if (['update_build_progress', 'attach_repo', 'record_launch_event', 'submit_stack_feedback'].includes(name)) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: mcpText({
+          approvalRequired: true,
+          persisted: false,
+          message: `${name} is an approval-gated V1 draft. Review this with the user before any Tokens& write, public proof update, repo action, or external post.`,
+          draft: args,
+          nextSteps: [
+            'Confirm the evidence with the user.',
+            'Use draft_project to inspect the repo when relevant.',
+            'Use publish_project only after explicit confirmation.',
+          ],
+        }),
+      }
+    }
+    throw new Error(`Unknown tool: ${name}`)
+  }
+
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: { code: -32601, message: `Unknown method: ${method}` },
+  }
+}
+
+async function serveMcp({ baseUrl, config = {}, mode }) {
+  const developerWorkflowToken = workflowToken(config)
+  const privateEnterpriseToken = enterpriseToken(config)
+  const organizationId = enterpriseOrganizationId(config)
+  const enterpriseProfile = resolveEnterpriseProfile(config)
+  const resolvedMode = resolveMcpMode({
+    requestedMode: mode || config.mode || config.mcpMode,
+    token: developerWorkflowToken,
+    enterpriseToken: privateEnterpriseToken,
+    organizationId,
+    enterpriseProfile,
+  })
+  let buffer = ''
+  const state = {
+    baseUrl,
+    token: developerWorkflowToken || '',
+    enterpriseToken: privateEnterpriseToken || '',
+    organizationId: organizationId || '',
+    enterpriseProfile: enterpriseProfile || '',
+    mode: resolvedMode,
+    firstToolCallTracked: false,
+  }
+  await new Promise((resolve) => {
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', (chunk) => {
+      buffer = parseMcpBuffer(buffer + chunk, async (message) => {
+        try {
+          const response = await handleMcpRequest(message, state)
+          if (response) writeMcpMessage(response)
+        } catch (error) {
+          if (message?.id != null) {
+            writeMcpMessage({
+              jsonrpc: '2.0',
+              id: message.id,
+              error: { code: -32000, message: error instanceof Error ? error.message : 'MCP server error' },
+            })
+          }
+        }
+      })
+    })
+    process.stdin.on('end', resolve)
+    process.stdin.resume()
+  })
+}
+
+function printHelp() {
+  console.log(`
+dai v${VERSION} — Developer Adoption Intelligence CLI
+
+Usage:
+  dai <command> [args] [flags]
+
+Common commands:
+  login                OAuth device-code login
+  logout               Clear saved credentials
+  whoami               Show the signed-in account
+  stack add <tool>     Add a tool to your public stack
+  stack remove <tool>  Remove a tool from your stack
+  stack sync           Sync local package.json into your stack
+  submit <id>          Submit to a challenge (use --file to attach)
+  proof <tool-slug>    Fetch public adoption proof from /api/v1/adoption
+  rank [tool-slug]     Show live AI Adoption Score rankings
+  notifications        List unread notifications
+  digest               Print this week's personalized digest
+  project draft        Draft a public project from the current repo
+  project publish      Publish the current repo after review (--yes)
+  mcp serve            Start MCP server for Cursor/Codex
+  version              Print the CLI version
+
+Global flags:
+  --json               Print raw JSON responses
+  --api <url>          Override the API base URL
+  --mode <mode>        MCP mode: auto, public, developer, or enterprise
+  --help               Show this help
+
+Docs: https://tokensand.com/docs/api
+`)
+}
+
+export async function run(argv) {
+  if (argv.length === 0 || argv.includes('--help') || argv[0] === 'help') {
+    printHelp()
+    return
+  }
+
+  const globals = parseGlobals(argv)
+  const jsonFlag = globals.json
+  const cleanArgs = globals.clean
+
+  const config = await loadConfig()
+
+  const [cmd, ...args] = cleanArgs
+  switch (cmd) {
+    case 'version':
+      console.log(VERSION)
+      return
+    case 'login':
+      console.log('Visit: ' + DEFAULT_API + '/login?cli=1')
+      console.log('Paste the device code shown there into this terminal.')
+      return
+    case 'logout':
+      console.log('Credentials cleared from ' + CONFIG_PATH)
+      return
+    case 'whoami':
+      if (!config.token) {
+        console.log('Not signed in. Run `dai login`.')
+        return
+      }
+      console.log(`Signed in as ${config.email ?? 'unknown'}`)
+      return
+    case 'stack': {
+      const sub = args[0]
+      if (sub === 'add' || sub === 'remove') {
+        console.log(`[stack ${sub}] queued for ${args[1] ?? '<tool>'}. Will sync on the next /api/stack push.`)
+        return
+      }
+      if (sub === 'sync') {
+        const pkg = await readFile('package.json', 'utf8').then(JSON.parse).catch(() => null)
+        if (!pkg) {
+          console.log('No package.json found in the current directory.')
+          return
+        }
+        const deps = {
+          ...(pkg.dependencies ?? {}),
+          ...(pkg.devDependencies ?? {}),
+        }
+        const names = Object.keys(deps).sort()
+        if (jsonFlag) {
+          console.log(JSON.stringify({ package: pkg.name ?? null, dependencies: names }, null, 2))
+          return
+        }
+        console.log(`Found ${names.length} package${names.length === 1 ? '' : 's'} for stack sync.`)
+        console.log(names.slice(0, 12).map((name) => `- ${name}`).join('\n'))
+        if (names.length > 12) console.log(`...and ${names.length - 12} more`)
+        console.log('Run from an authenticated workspace when /api/stack sync is enabled.')
+        return
+      }
+      console.log('Usage: dai stack <add|remove|sync> [args]')
+      return
+    }
+    case 'submit':
+      console.log(`Submitting to challenge ${args[0] ?? '<id>'}; attachments: ${args.includes('--file') ? 'yes' : 'no'}.`)
+      return
+    case 'proof': {
+      const slug = args[0]
+      if (!slug) {
+        console.log('Usage: dai proof <tool-slug>')
+        return
+      }
+      const data = await api(`/api/v1/adoption?tool=${encodeURIComponent(slug)}&limit=1`, { baseUrl: globals.apiBase })
+      if (jsonFlag) {
+        console.log(JSON.stringify(data, null, 2))
+      } else {
+        const row = data?.rows?.[0]
+        console.log(row ? formatAdoptionRow(row) : `${slug}: No public adoption proof available yet.`)
+      }
+      return
+    }
+    case 'rank': {
+      const liveArgs = args.filter((arg) => arg !== '--live')
+      const slug = liveArgs[0]
+      const path = slug
+        ? `/api/v1/adoption?tool=${encodeURIComponent(slug)}&limit=1`
+        : '/api/v1/adoption?limit=10'
+      const data = await api(path, { baseUrl: globals.apiBase })
+      if (jsonFlag) {
+        console.log(JSON.stringify(data, null, 2))
+        return
+      }
+      const rows = data?.rows ?? []
+      if (rows.length === 0) {
+        console.log(slug ? `${slug}: no public rank available yet.` : 'No public rankings available yet.')
+        return
+      }
+      for (const row of rows) console.log(formatAdoptionRow(row))
+      return
+    }
+    case 'notifications': {
+      const data = await api('/api/notifications', { baseUrl: globals.apiBase })
+      const items = data?.notifications ?? []
+      if (jsonFlag) {
+        console.log(JSON.stringify(items, null, 2))
+        return
+      }
+      if (items.length === 0) {
+        console.log('No notifications. You are caught up.')
+        return
+      }
+      for (const n of items) {
+        console.log(`- [${n.category}] ${n.title}`)
+      }
+      return
+    }
+    case 'digest': {
+      const data = await api('/api/digest/weekly', { baseUrl: globals.apiBase })
+      if (jsonFlag) {
+        console.log(JSON.stringify(data, null, 2))
+        return
+      }
+      const d = data?.digest
+      if (!d) {
+        console.log('No digest available.')
+        return
+      }
+      console.log(`\n${d.userLabel} · ${d.periodLabel}`)
+      console.log(`${d.rank.label}: #${d.rank.position} · top ${100 - d.rank.percentile}%`)
+      if (d.highlights.length) {
+        console.log('\nHighlights:')
+        for (const h of d.highlights) console.log(`  - ${h.title}`)
+      }
+      console.log(`\nOpen dashboard: ${DEFAULT_API}${d.callToAction.href}\n`)
+      return
+    }
+    case 'project': {
+      const sub = args[0]
+      if (sub !== 'draft' && sub !== 'publish') {
+        console.log('Usage: dai project <draft|publish> [--repo <url>] [--demo <url>] [--yes] [--json]')
+        return
+      }
+      const token = workflowToken(config)
+      if (!token) {
+        console.log('Missing workflow token. Generate config from /projects/new, set DAI_TOKEN, then run this again.')
+        process.exitCode = 1
+        return
+      }
+      const flags = parseProjectFlags(args.slice(1))
+      const payload = await localProjectPayload(flags)
+      const draft = await workflowApi('/api/workflow/projects/draft', {
+        method: 'POST',
+        body: payload,
+        token,
+        baseUrl: globals.apiBase,
+      })
+      if (sub === 'draft') {
+        if (jsonFlag) {
+          console.log(JSON.stringify(draft, null, 2))
+          return
+        }
+        printDraft(draft)
+        return
+      }
+
+      if (draft.duplicateProjectHref) {
+        const href = draft.duplicateProjectHref.startsWith('http')
+          ? draft.duplicateProjectHref
+          : `${globals.apiBase}${draft.duplicateProjectHref}`
+        if (jsonFlag) console.log(JSON.stringify({ duplicateProjectHref: href, draft }, null, 2))
+        else console.log(`Already published: ${href}`)
+        return
+      }
+
+      if (!flags.yes) {
+        if (jsonFlag) {
+          console.log(JSON.stringify({ readyToPublish: false, nextCommand: 'dai project publish --yes', draft }, null, 2))
+          return
+        }
+        printDraft(draft)
+        console.log('\nReview the draft, then publish with: dai project publish --yes')
+        return
+      }
+
+      if (!draft.draft?.tools?.length) {
+        console.log('Could not infer approved tools from this repo. Publish from /projects/new or pass explicit tools through the MCP tool.')
+        process.exitCode = 1
+        return
+      }
+
+      const result = await workflowApi('/api/workflow/projects', {
+        method: 'POST',
+        body: projectBodyFromDraft(draft, flags),
+        token,
+        baseUrl: globals.apiBase,
+      })
+      if (jsonFlag) {
+        console.log(JSON.stringify(result, null, 2))
+        return
+      }
+      const href = result.projectHref?.startsWith('http') ? result.projectHref : `${globals.apiBase}${result.projectHref ?? `/p/${result.project?.slug ?? ''}`}`
+      console.log(`Published: ${href}`)
+      if (result.profileHref) console.log(`Profile: ${globals.apiBase}${result.profileHref}`)
+      if (result.shareMoment?.platformUrls?.x) console.log(`Share on X: ${result.shareMoment.platformUrls.x}`)
+      return
+    }
+    case 'mcp': {
+      const sub = args[0]
+      if (sub !== 'serve') {
+        console.log('Usage: dai mcp serve [--api <url>] [--mode <auto|public|developer|enterprise>]')
+        return
+      }
+      await serveMcp({ baseUrl: globals.apiBase, config, mode: globals.mode })
+      return
+    }
+    default:
+      console.log(`Unknown command: ${cmd}\nRun \`dai --help\` for usage.`)
+      process.exitCode = 1
+  }
+}