# AI Coding Pricing — Calculator Result Recommendation Card Spec

Date: 2026-05-26
Task: t_af5eeddc
Site: https://aicodingpricing.com
Repository: /mnt/HC_Volume_105300089/projects/aicodingpricing
Owner: 墨策
Downstream owner: mojie / moshu
Status: Implementation-ready product spec

## 0. Decision

Upgrade the calculator result from a cost display to a purchase recommendation card.

Current gap:
- The calculator shows estimated monthly cost, plan fit, limit risk, intensity score, and a generic pricing guide CTA.
- It does not answer the buyer question: "Which provider/plan should I buy, why, what tradeoff am I accepting, and what should I click next?"

Target behavior:
- Every calculator result renders one primary provider/plan recommendation.
- The card must include: provider, plan, monthly estimate, confidence, reason, tradeoff, verification caveat, and CTA.
- If data is incomplete, show `Unknown / verify manually`; do not infer prices or limits.

Non-goal:
- Do not claim official affiliation.
- Do not imply exact billing quote.
- Do not recommend plans without visible source freshness and caveat.
- Do not introduce payment, affiliate tracking, or provider-logo usage in this change.

## 1. Inputs used by the recommendation engine

Use the existing calculator fields first. Add optional fields only if mojie can implement without expanding scope.

| Input field | Existing? | Type | Required | Meaning | Recommendation use |
|---|---:|---|---:|---|---|
| `providerId` | yes | enum | yes | Selected provider/product | Restricts recommendation to selected provider unless `compare_all` mode is added later |
| `workflow` | yes | enum: `light`, `ide`, `cli`, `agentic` | yes | User work style | Multiplies weekly hours into intensity score |
| `teamSize` | yes | number >= 1 | yes | Seats/users | Multiplies seat/subscription price |
| `hours` | yes | number >= 1 | yes | AI coding hours per week | Core intensity input |
| `mode` | yes | enum: `subscription`, `api`, `hybrid` | yes | Buying mode | Determines subscription vs API/hybrid CTA and caveat |
| `budgetMaxUsdMonthly` | no | number | optional | Max monthly budget | If absent, recommend best fit regardless of budget and show price risk |
| `riskTolerance` | no | enum: `low`, `medium`, `high` | optional | Willingness to hit usage limits/overage | If absent, assume medium |
| `teamControlsNeeded` | no | boolean | optional | SSO/admin/shared billing/privacy controls | If true, prefer team/business plan when source supports it |

Keep P0 to existing fields. Optional inputs can be later UI chips.

## 2. Recommendation rule model

### 2.1 Core derived fields

Reuse existing calculator logic as the first pass:

```ts
const workflowMultiplier = { light: 0.65, ide: 1, cli: 1.6, agentic: 2.25 };
const intensityScore = Math.max(1, Math.round(hours * workflowMultiplier[workflow]));
const neededMultiplier = intensityScore >= 55 ? 15 : intensityScore >= 34 ? 5 : intensityScore >= 18 ? 1 : 0;
const limitRisk = neededMultiplier >= 15 ? "high" : neededMultiplier >= 5 ? "medium" : "low";
```

Add a card-level decision bucket:

| Bucket | Condition | User meaning | Recommendation bias |
|---|---|---|---|
| `trial` | `neededMultiplier === 0` | Light testing / occasional use | Free or lowest paid plan; avoid overbuying |
| `regular` | `neededMultiplier === 1` | Regular weekly coding | Entry paid plan |
| `heavy` | `neededMultiplier >= 5 && neededMultiplier < 15` | Daily or long sessions | Higher usage tier; warn about limits |
| `power` | `neededMultiplier >= 15` | Agentic repo work / high-intensity daily use | Highest public tier or manual review if source is custom/unknown |

### 2.2 Plan selection rule

For the selected provider:

1. Filter plans by buying mode:
   - `subscription`: plans with numeric `price_usd_monthly` or `price_usd_monthly_per_seat`.
   - `api`: plans with `billing_model === "usage_based"` or `api_pricing_basis`.
   - `hybrid`: recommend subscription first; append API fallback as secondary next step if API data exists.
2. Exclude custom/unknown-priced plans from numeric estimates.
3. Map usage multiplier fields in this order:
   - `usage_multiplier_vs_base`
   - `usage_multiplier_vs_plus`
   - `usage_multiplier_vs_pro`
   - fallback: `0` for free, `1` for numeric paid plan, `unknown` otherwise.
4. Choose the lowest-priced plan whose multiplier >= `neededMultiplier`.
5. If no plan meets `neededMultiplier`, choose the highest known public plan and mark `fit = "manual_review_needed"`.
6. If selected plan is free and `bucket !== "trial"`, force upgrade recommendation to lowest paid plan.
7. Compute price:
   - `price_usd_monthly * teamSize` for individual subscription plans.
   - `price_usd_monthly_per_seat * teamSize` for seat plans.
   - `unknown` for usage-based/custom plans.

### 2.3 Recommendation card object

```ts
type RecommendationCard = {
  providerId: string;
  providerName: string;
  productName: string;
  recommendedPlanId: string | "unknown";
  recommendedPlanName: string | "Manual review" | "Unknown";
  estimatedMonthlyUsd: number | "unknown";
  decisionBucket: "trial" | "regular" | "heavy" | "power";
  limitRisk: "low" | "medium" | "high" | "unknown";
  confidence: "high" | "medium" | "low" | "unknown";
  fit: "good_fit" | "watch_limits" | "manual_review_needed" | "unknown";
  reason: string;
  tradeoff: string;
  caveat: string;
  sourceUrl?: string;
  lastChecked?: string;
  primaryCta: { label: string; href: string; event: "outbound_click" | "pricing_cta_click" };
  secondaryCta: { label: string; action: "copy_recommendation" | "open_comparison" };
};
```

## 3. Provider / plan recommendation rules

Source basis: current repository `src/data/providers-seed.json`, last checked rows mostly 2026-05-21. Where a product is not in the seed data, mark unknown.

### 3.1 Claude Code / Anthropic

Provider id: `anthropic`
Route: `/claude-code-pricing`
Source freshness in seed: 2026-05-21
Known public plans in seed: Free, Pro, Max 5x, Max 20x, Claude API

| User signal | Recommend | Reason | Tradeoff | CTA |
|---|---|---|---|---|
| `trial` / light exploration | Free or Pro if user selected paid intent | Good for trying Claude/Claude Code before paying | Free access and Claude Code availability can change; do not rely on it for production work | `Open Claude Code pricing guide` |
| `regular` / IDE-first or CLI under regular threshold | Pro ($20/mo; $200/yr in seed) | Lowest paid Claude plan with higher usage than Free and Claude Code access in seed | Usage limits still apply and vary by message length, tools, model choice, attachments, and conversation length | `Check Claude Pro details` |
| `heavy` / frequent CLI sessions | Max 5x ($100/mo in seed) | Seed says 5x more usage than Pro and includes Claude Code | Still has weekly/session/model limits; not unlimited | `Compare Claude Max 5x` |
| `power` / agentic repo work or large sessions | Max 20x ($200/mo in seed) | Highest known public Claude subscription tier in seed for heavy daily Claude Code use | Still limited; if team governance is needed, manual review may be better than individual Max | `Verify Claude Max 20x` |
| API or hybrid mode | Claude API as secondary / fallback | Programmatic automation may need API billing instead of subscription limits | API pricing is token-based and not equivalent to Claude subscription usage | `Open Claude API pricing` |

Recommendation copy template:
- Reason: `Your {workflowLabel} workflow and {hours}h/week input produce a {intensityScore} intensity score, so {planName} is the lowest known Claude Code plan in our source data that matches this usage bucket.`
- Tradeoff: `You pay more to reduce limit pressure, but Claude still applies usage/session/model limits. Verify the official source before buying.`

### 3.2 Cursor

Provider id: `cursor`
Route: `/cursor-pricing`
Source freshness in seed: 2026-05-21
Known public plans in seed: Hobby, Pro, Pro+, Ultra, Teams, Enterprise(custom)

| User signal | Recommend | Reason | Tradeoff | CTA |
|---|---|---|---|---|
| `trial` | Hobby / Free | Best for trying Cursor with limited Agent/Tab usage | Limited requests; not suitable for sustained agent work | `Open Cursor pricing guide` |
| `regular` | Pro ($20/mo in seed) | Lowest paid individual Cursor plan in seed for regular usage | Included usage pool can run out; on-demand usage can bill after included amount is consumed | `Check Cursor Pro` |
| `heavy` | Pro+ ($60/mo in seed) | Seed says 3x usage on OpenAI, Claude, and Gemini models vs Pro | 3x is a usage pool, not unlimited usage | `Compare Cursor Pro+` |
| `power` | Ultra ($200/mo in seed) | Seed says 20x usage and priority feature access | High price; still not unlimited and on-demand usage behavior must be visible | `Verify Cursor Ultra` |
| `teamSize > 1` and `teamControlsNeeded === true` | Teams ($40/user/mo in seed) | Adds shared chats/commands/rules, centralized billing, analytics, privacy controls, RBAC, SAML/OIDC SSO | Team plan adds governance; do not imply more individual usage unless source says so | `Review Cursor Teams` |
| Enterprise/security/admin beyond Teams | Enterprise | Custom pricing and enterprise controls | Unknown price; manual quote required | `Request manual review` |

Recommendation copy template:
- Reason: `Cursor is a fit when the user wants an IDE-first agent workflow. Your inputs place you in the {bucket} bucket, so {planName} is the lowest known Cursor tier matching that usage level.`
- Tradeoff: `Cursor has plan usage pools and possible on-demand usage. Show the source date and warn users to check included usage before upgrading.`

### 3.3 GitHub Copilot

Provider id: `github`
Route: `/github-copilot-pricing`
Source freshness in seed: 2026-05-21
Known public plans in seed: Free, Pro, Pro+, Max(upcoming/effective-date caveat)
Important caveat in seed: billing model changes on 2026-06-01; sign-ups/upgrades may be paused during transition.

| User signal | Recommend | Reason | Tradeoff | CTA |
|---|---|---|---|---|
| `trial` | Copilot Free | Good for light individual evaluation | Limited completions/chat/premium requests; billing model is changing | `Open Copilot pricing guide` |
| `regular` | Copilot Pro ($10/user/mo in seed) | Lowest known paid individual Copilot tier in seed; strong default for regular editor assistance | Premium request / AI credit limits apply; transition caveat must be shown | `Check Copilot Pro` |
| `heavy` | Copilot Pro+ ($39/user/mo in seed) | Larger premium request / AI credit allowance for agent/model-heavy use | Overage/current vs upcoming billing differs; display effective date | `Compare Copilot Pro+` |
| `power` | Copilot Max ($100/user/mo in seed, upcoming) or manual review | Highest known individual usage-credit tier in seed | Medium confidence / upcoming model; do not treat as stable current recommendation without date label | `Verify Copilot Max` |
| team governance needed | Unknown in current seed for Business/Enterprise | The current seed focuses on individual plans; team plan data is not complete enough for recommendation | Mark unknown; send user to official GitHub plans | `Verify GitHub team plans` |

Recommendation copy template:
- Reason: `Your input suggests {bucket} Copilot usage. {planName} is the lowest known Copilot tier in our source data for that usage level.`
- Tradeoff: `GitHub is changing Copilot billing around 2026-06-01. Treat this as planning guidance, not a final invoice estimate.`

### 3.4 Codex / OpenAI

Provider id: `openai`
Route: `/codex-pricing`
Source freshness in seed: 2026-05-21
Known public plans in seed: ChatGPT Free + Codex, Go + Codex, Plus + Codex, Pro 5x + Codex, Pro 20x + Codex, Codex with API key
Important caveat in seed: promo multipliers may expire 2026-05-31; API mode differs from ChatGPT subscription mode.

| User signal | Recommend | Reason | Tradeoff | CTA |
|---|---|---|---|---|
| `trial` | ChatGPT Free + Codex or Go + Codex if available in region | Low-cost way to test Codex | Go availability may vary by region; Free trial limits can change | `Open Codex pricing guide` |
| `regular` | ChatGPT Plus + Codex ($20/mo in seed) | Default paid Codex plan for a few focused coding sessions each week | Limits vary by model/local/cloud/code-review mode | `Check ChatGPT Plus + Codex` |
| `heavy` | ChatGPT Pro 5x + Codex (from $100/mo in seed) | Higher rate limits for longer, higher-intensity sessions | Promo multipliers are date-bound; avoid evergreen claims | `Compare Codex Pro 5x` |
| `power` | ChatGPT Pro 20x + Codex ($200/mo in seed) | Highest known public subscription tier in seed for very heavy Codex use | Exact limits depend on model and usage mode; promo through 2026-05-31 must be labeled | `Verify Codex Pro 20x` |
| `api` mode | Codex with API key | Better for CI/shared/programmatic usage when subscription limits are not the right model | API mode lacks some cloud/integration features and bills by token/API usage | `Open Codex API pricing` |
| `hybrid` mode | Plus/Pro plan + API key fallback | Subscription for interactive usage, API for automation | Requires clear separation of subscription cost and token/API cost | `Compare subscription vs API` |

Recommendation copy template:
- Reason: `Your {workflowLabel} usage maps to {bucket}. {planName} is the lowest known Codex plan in the seed data for that level.`
- Tradeoff: `Codex subscription, cloud features, local CLI use, and API key mode are not interchangeable. Verify the official pricing source before buying.`

### 3.5 Gemini CLI / Google

Provider id: `google` / `gemini-cli` (not present in current seed)
Route: not present
Source freshness: unknown
Known public plans in repository: unknown

P0 handling:
- Do not recommend Gemini CLI as a primary plan until `providers-seed.json` contains official source rows, plan rows, last checked date, and caveats.
- If Gemini appears in UI as a comparison option through Cursor model usage text, show it only as part of Cursor usage pool copy, not as an independent provider recommendation.
- If user selects or searches for Gemini CLI, render an unknown-data card:

Unknown card copy:
- Title: `Gemini CLI pricing: manual verification needed`
- Reason: `This site does not yet have source-linked Gemini CLI plan data.`
- Tradeoff: `We can compare workflows once official pricing, usage limits, and source dates are added.`
- CTA: `Request Gemini CLI tracking` or `Check official Google pricing`
- Caveat: `Unknown in current AI Coding Pricing data. Do not infer from Cursor's Gemini model pool.`

Acceptance for adding later:
- Add provider row to `src/data/providers-seed.json`.
- Add route mapping in `providerPath`.
- Add at least one official source URL, `last_checked`, confidence, and caveat.
- Add plans with numeric or explicit custom/usage-based pricing.

## 4. Result page UI copy

### 4.1 Hero / above-the-fold short copy

Option A:
> Compare AI coding plans before you upgrade.
> Estimate your usage, see the likely provider/plan fit, and check the tradeoffs before paying for Claude Code, Cursor, Codex, or GitHub Copilot.

Option B:
> Find the AI coding plan that matches your workflow.
> Enter your team size, hours, and coding style. Get a source-linked plan recommendation, limit-risk warning, and next step.

Recommended H1 if changing homepage:
> AI Coding Pricing Calculator

Recommended subhead:
> Estimate AI coding tool costs and get a provider/plan recommendation before upgrading.

### 4.2 Recommendation card structure

Card title:
> Recommended plan

Primary line:
> {productName} — {planName}

Price line:
> Estimated cost: {estimatedMonthlyUsd}/mo for {teamSize} {seatLabel}

If unknown:
> Estimated cost: Unknown — verify official pricing

Reason block label:
> Why this plan

Reason copy template:
> Your {workflowLabel} workflow at {hours} hours/week gives an intensity score of {intensityScore}. That puts you in the {decisionBucket} usage bucket, so {planName} is the lowest known plan in our source data that matches this level.

Tradeoff block label:
> Tradeoff to check

Tradeoff copy templates:
- Claude: `Higher Claude tiers reduce limit pressure, but Claude still applies usage/session/model limits. Check the official source before buying.`
- Cursor: `Cursor plans use included usage pools. On-demand usage may add cost after the included amount is consumed.`
- Copilot: `Copilot billing is moving through a request/credit model transition. Check the effective date before upgrading.`
- Codex: `Codex subscription and API-key mode are different buying models. Do not treat subscription price as API cost.`
- Gemini CLI: `Independent source-linked data is not available in this site yet. Manual verification required.`

Confidence badge:
- `High confidence` when source row has official source, last checked, numeric price, and caveat.
- `Medium confidence` when source row is official but upcoming/transition/promo-sensitive.
- `Unknown` when price/plan/source is missing.

Source microcopy:
> Source checked: {lastChecked}. Pricing and limits can change by region, account, promotion, model, and provider policy.

Primary CTA labels:
- Claude: `Verify Claude pricing`
- Cursor: `Verify Cursor pricing`
- Copilot: `Verify Copilot pricing`
- Codex: `Verify Codex pricing`
- API mode: `Check API pricing`
- Unknown: `Request tracking / verify manually`

Secondary CTA:
> Copy recommendation

Copied text template:
> AI Coding Pricing recommendation: {productName} {planName}, estimated {estimatedMonthlyUsd}/mo for {teamSize} seat(s). Reason: {shortReason}. Tradeoff: {shortTradeoff}. Source checked: {lastChecked || "unknown"}. Not a billing quote.

### 4.3 Comparison explanation copy

Use under the recommendation card or near the comparison table:

> This recommendation uses your workflow intensity, weekly hours, team size, and the public plan data currently tracked by AI Coding Pricing. It chooses the lowest known plan that appears to fit the usage bucket. It does not know your private account limits, regional availability, promotions, enterprise contract, or actual token/request mix.

Short version:
> We recommend the lowest known plan that fits your usage bucket, then show the limit risk and source caveat.

### 4.4 Disclaimer copy

Footer or card-level disclaimer:

> AI Coding Pricing is independent and not affiliated with Anthropic, OpenAI, Cursor, GitHub, Google, or other providers. Brand names are used only to identify products. Calculator results are estimates based on public pricing assumptions and user inputs. They are not billing quotes and may not match your actual invoice, account-specific limits, region, promotion, or provider policy.

Card-specific disclaimer:

> Verify the official provider page before purchasing or upgrading.

## 5. Analytics / event tracking requirements

Existing events found in `Calculator.tsx`:
- `calculator_start`
- `tool_start`
- `tool_result`
- `pricing_cta_click`

Add required P0 events.

### 5.1 `recommendation_shown`

Fire when the recommendation card is rendered or materially changes after user input.

Properties:
```json
{
  "provider": "anthropic|openai|cursor|github|google|unknown",
  "product": "Claude Code|Codex|Cursor|GitHub Copilot|Gemini CLI|unknown",
  "recommended_plan_id": "string|unknown",
  "recommended_plan_name": "string|unknown",
  "decision_bucket": "trial|regular|heavy|power|unknown",
  "workflow": "light|ide|cli|agentic",
  "hours_per_week": 18,
  "team_size": 1,
  "mode": "subscription|api|hybrid",
  "intensity_score": 29,
  "limit_risk": "low|medium|high|unknown",
  "estimated_monthly_usd": 100,
  "confidence": "high|medium|low|unknown",
  "source_last_checked": "2026-05-21|unknown"
}
```

Implementation note:
- Debounce or only fire when `recommended_plan_id`, `provider`, `workflow`, `hours`, `teamSize`, or `mode` changes.
- Avoid duplicate fire on every render.

### 5.2 `provider_recommended`

Fire once per new recommendation decision, same payload as `recommendation_shown`, plus:
```json
{
  "recommendation_reason_code": "lowest_fit|manual_review_needed|api_mode|unknown_data|team_controls"
}
```

Use this for funnel analysis of which providers/plans the calculator pushes users toward.

### 5.3 `outbound_click`

Fire when user clicks a provider/source/official pricing CTA.

Properties:
```json
{
  "provider": "anthropic|openai|cursor|github|google|unknown",
  "product": "string",
  "recommended_plan_id": "string|unknown",
  "cta_label": "Verify Claude pricing",
  "destination_url": "https://...",
  "destination_type": "internal_pricing_page|official_provider_source|api_pricing|unknown_manual_verify",
  "source_last_checked": "2026-05-21|unknown"
}
```

### 5.4 `copy_recommendation`

Fire when the user copies the recommendation text.

Properties:
```json
{
  "provider": "anthropic|openai|cursor|github|google|unknown",
  "recommended_plan_id": "string|unknown",
  "decision_bucket": "trial|regular|heavy|power|unknown",
  "estimated_monthly_usd": 100,
  "confidence": "high|medium|low|unknown"
}
```

## 6. Implementation acceptance checklist for mojie

### Data / rules

- [ ] Recommendation logic is implemented as a pure helper, not hard-coded inside JSX.
- [ ] Existing inputs `providerId`, `workflow`, `teamSize`, `hours`, `mode` drive the recommendation.
- [ ] Plan selection chooses the lowest known plan matching usage bucket.
- [ ] API and hybrid modes do not pretend API billing equals subscription billing.
- [ ] Custom/unknown plans render `manual review` or `unknown`, not fabricated prices.
- [ ] Gemini CLI renders unknown/manual-verification state unless official seed data is added.
- [ ] Source URL, source type, last checked date, confidence, and caveat are surfaced when present.

### UI

- [ ] Calculator result card title changes from generic estimate to `Recommended plan`.
- [ ] Card shows provider/product, recommended plan, estimated monthly cost, reason, tradeoff, risk, source checked date, and caveat.
- [ ] CTA is provider-specific and clear: verify pricing / open guide / check API pricing.
- [ ] Secondary copy action exists and copies a complete recommendation sentence.
- [ ] Unknown states are useful and honest, not blank.
- [ ] Mobile layout keeps recommendation visible without excessive scroll.
- [ ] Disclaimer remains visible below the card.

### Analytics

- [ ] `recommendation_shown` fires when card appears or recommendation changes.
- [ ] `provider_recommended` fires with plan id, bucket, confidence, risk, and estimated cost.
- [ ] `outbound_click` fires on provider/source CTA click.
- [ ] `copy_recommendation` fires on copy action.
- [ ] Existing `tool_start` and `tool_result` remain intact.
- [ ] Event payloads contain no email, IP, account id, private usage dashboard data, or secrets.

### SEO / copy safety

- [ ] Page copy says estimate/recommendation, not quote/guarantee.
- [ ] Official affiliation is not implied.
- [ ] Provider logos are not introduced.
- [ ] Promo/upcoming billing rows show date caveats.
- [ ] Gemini CLI is not described with invented pricing.

### QA scenarios

- [ ] Claude Code, light workflow, 3h/week, 1 seat → Free/Pro-level low-risk recommendation depending final rule; no Max recommendation.
- [ ] Claude Code, CLI, 18h/week, 1 seat → Pro or Max depending intensity threshold; reason shows score.
- [ ] Claude Code, agentic, 30h/week, 1 seat → Max 20x or manual review with high risk.
- [ ] Cursor, heavy/agentic usage → Pro+ or Ultra; tradeoff mentions usage pool/on-demand.
- [ ] GitHub Copilot, regular use → Copilot Pro; caveat mentions 2026-06-01 transition.
- [ ] Codex, API mode → Codex with API key; cost shown as unknown/token-based, not subscription estimate.
- [ ] Gemini CLI option if added without seed → Unknown/manual verification card.

## 7. Suggested helper API for implementation

```ts
export function getRecommendation(input: {
  providerId: string;
  workflow: "light" | "ide" | "cli" | "agentic";
  teamSize: number;
  hours: number;
  mode: "subscription" | "api" | "hybrid";
  riskTolerance?: "low" | "medium" | "high";
  teamControlsNeeded?: boolean;
}, providers: Provider[]): RecommendationCard {
  // 1. derive intensityScore / neededMultiplier / decisionBucket / limitRisk
  // 2. find provider; if missing return unknown card
  // 3. filter by mode and known price/billing model
  // 4. select lowest known fit; if none, highest known + manual review
  // 5. build reason/tradeoff/caveat/CTA from provider-specific copy maps
  // 6. never fabricate price/source/confidence
}
```

## 8. Residual risks

- The parent synthesis report path referenced by the task was not present at read time, but parent task metadata and handoff summary were available from Kanban and used as source context.
- Provider data is only as fresh as `src/data/providers-seed.json` rows, mostly checked 2026-05-21. Mojie should not update facts silently without refreshing sources.
- GitHub Copilot and Codex have time-sensitive transition/promo caveats around 2026-06-01 / 2026-05-31. UI must render dates.
- Gemini CLI is explicitly unknown in the current repository and should not be inferred from Cursor's Gemini model usage wording.

## 9. Next inputs for downstream

For mojie:
- File to implement against: `src/components/Calculator.tsx`
- Seed data: `src/data/providers-seed.json`
- Current route map: `providerPath` in `Calculator.tsx`
- Add helper file if desired: `src/lib/recommendation.ts`
- Add tests or fixture checks for the QA scenarios above if project test setup allows.

For moshu / analytics:
- Confirm event names in GA4/Plausible/Clarity bridge if naming normalization exists.
- Preserve existing `tool_start`, `tool_result`, and `pricing_cta_click` events.