Discover Preview

Route Detection

Before executing Steps 1–6, determine which route applies:

AI-only route executes Steps 1A–6A below. Infra route executes Steps 1–6 below (original behavior, unchanged).

AI-Only Route (Steps 1A–6A)

Used when only ai-workload-profile.json exists — no Terraform, no billing data. Infrastructure stays on GCP; only AI/LLM calls move to AWS Bedrock.

Step 1A: Compute AI complexity_signal

Read from ai-workload-profile.json:

Classify (first match wins, top to bottom):

Fast-path eligibility: Always false for AI-only route — AI profiles always route to full Clarify.

Step 2A: Build per-token price comparison

Purpose: Show the user what their models map to on Bedrock and whether the per-token price is higher, lower, or roughly equivalent. Do NOT compute a monthly dollar total — usage volume is unknown at Discover time and will be collected in Clarify (AI-only Q3 for spend, AI-only Q7 for usage volume).

For each model in models[] of ai-workload-profile.json, map to the closest Bedrock equivalent using the table below, then look up both source and Bedrock per-token prices from references/shared/pricing-cache.md (Source Provider Pricing + Bedrock Models sections).

Source model → Bedrock equivalent mapping:

Same-model rows first. OpenAI’s proprietary GPT models run on Bedrock, so these sources map to themselves and the comparison is a ~10% premium (Bedrock in-region is at OpenAI’s data-residency tier, 1.10x standard — see references/shared/openai-on-bedrock.md). Match these before falling through to the cross-family rows.

On the mantle endpoint these are in-region only (us-east-1, us-east-2; us-west-2 additionally for Terra, Luna, and GPT-5.4; AWS GovCloud us-gov-west-1 / us-gov-east-1 for Terra and Luna, us-gov-west-1 also for GPT-5.4). GPT-5.6 additionally reaches most commercial regions via bedrock-runtime CRIS ids; GPT-5.5 / GPT-5.4 have no CRIS. At Discover time the target region may not be known — record the same-model mapping and let Design apply the region gate. See references/shared/openai-on-bedrock.md.

Cross-family rows — for sources with no Bedrock equivalent:

For each mapped model pair, record source_model, bedrock_equivalent, both per-token prices, and cost_direction ("higher", "lower", or "comparable" — Bedrock relative to source) in the bedrock_targets[] entry (Step 5A schema).

Chat display rule: In the preview summary shown to the user, present each mapping with its direction only — e.g. “gpt-4o → Claude Sonnet 4.6 (slightly higher per token)” — do NOT show monthly dollar totals or computed spend figures. Full cost analysis belongs in the Estimate phase where usage volume context is available.

Step 3A: Build key_decisions_ahead

Generate 2-4 bullets based on what was detected in ai-workload-profile.json:

Cap at 4 bullets.

Step 4A: Build duration_hint string

No week counts — durations are uncalibrated at Discover time (and stay heuristic after; see shared/migration-complexity.md § Provenance). Describe the shape of the path instead:

Always append “confirm after Clarify” — full classification requires preferences.

Step 5A: Write migration-preview.json (AI-only)

Write $MIGRATION_DIR/migration-preview.json:

Field rules:

• route is "ai_only" for this path
• primary_resource_count is 0 for AI-only runs (no IaC)
• complexity_signal mirrors ai_complexity_signal for downstream consumers
• services_summary is [] for AI-only runs
• ai_summary.bedrock_targets lists one entry per distinct source model with actual per-token prices
• cost_preview.monthly_estimate is always null at Discover time — no invented token volumes
• eligible_for_clarify_fast_path is always false for AI-only route

Step 6A: Build preview chat message (AI-only)

Output this block as part of discover.md Step 3’s user message (chat only — not a file):

Do NOT write this to a file. Chat output only.

Infra Route (Steps 1–6)

Used when gcp-resource-inventory.json exists (infra-only, hybrid infra+AI, or billing-only). Original behavior — unchanged.

Step 1: Compute complexity_signal

Read from available discovery artifacts:

Classify (first match wins, top to bottom):

Fast-path eligibility:

ai_complexity_signal (compute when ai-workload-profile.json exists):

Step 2: Compute rough AWS cost range

Purpose: Give the user a ballpark before Estimate runs. Always label as rough. Never invent GCP spend if billing data is absent.

Service type -> dev-tier AWS line item mapping

For each PRIMARY resource in gcp-resource-inventory.json, map to a dev-tier AWS equivalent and look up its monthly cost from references/shared/pricing-cache.md:

Sum the dev-tier line items to get aws_monthly_range_usd.low. Multiply by 1.5 for high (accounts for NAT gateway, data transfer, CloudWatch, and sizing variance).

Authored-size gate (HARD — do not quote toy dollars)

The table above is a development-tier stub. Quoting that sum as “AWS cost” when Terraform authored production sizes is a trust failure (users compare it to their real bill and quit).

Before writing any dollar range, scan inventory config for every resource whose type is in the table below — including SECONDARY. google_compute_instance_template, google_compute_*_instance_group_manager, and google_dataflow_job are not Priority-1 PRIMARY types; if you only scan PRIMARY, those rows are dead letter.

Fire the gate if any row matches. Record every match, then keep at most 5 signals in this fixed type order (do not pick by “largest deviation” — units are not comparable): Cloud SQL → Redis → GKE / node pool → Cloud Run → Dataflow → instance template / MIG → others (GCE instance, Filestore, Spanner). Within a type, keep inventory order.

Normalize before comparing thresholds — a config field expressed in different units or forms must not let an equivalent size bypass the gate:

• Cloud Run min instances: google_cloud_run_v2_service sets the minimum on either the service-level scaling.min_instance_count or the revision-level template.scaling.min_instance_count (read whichever is present; also accept a top-level min_instance_count). google_cloud_run_service (v1) does not have that field at all — its minimum-instance setting is an annotation: template.metadata.annotations["autoscaling.knative.dev/minScale"] or the service-level metadata.annotations["run.googleapis.com/minScale"]. Read whichever is present and treat its integer value (annotation values are strings, e.g. "50") as min_instance_count for the threshold below.
• GKE node count: evaluate every node pool, whether declared as a standalone google_container_node_pool resource or as an inline node_pool { ... } block (or the default pool) inside google_container_cluster — inline blocks are not separate resources, so a per-resource scan misses them. A pool can size itself three ways — fixed node_count/initial_node_count (no autoscaling block), the autoscaling.min_node_count/max_node_count form, or the autoscaling.total_min_node_count/total_max_node_count form (mutually exclusive with the min/max form). All of these except the total_* fields are per-zone counts — the Google provider defines node_count per instance group and initial_node_count (including the cluster’s default pool) per zone, and min_node_count/max_node_count are per-zone limits. Only total_min_node_count/total_max_node_count are pool-wide totals. Before comparing, convert per-zone counts to totals: effective_total = per_zone_count × zone_count, where zone_count is the length of the pool’s effective node_locations (the pool’s own node_locations, else the cluster’s; default to 1 only when neither is authored). Apply this multiplier to node_count, initial_node_count, min_node_count, and max_node_count; use total_min_node_count/total_max_node_count unchanged. Compare the resulting total against the threshold, so a fixed node_count = 2 across three node_locations (= 6), a per-zone max_node_count = 2 across three node_locations (= 6), and a cluster-wide total_max_node_count = 6 are each judged on true node count rather than the author’s chosen form.
• Spanner capacity: google_spanner_instance accepts either num_nodes or processing_units, and 1 node = 1,000 processing units (Terraform rejects setting both). Convert processing_units to node-equivalent (processing_units / 1000) before comparing, so num_nodes = 1 and processing_units = 1000 evaluate identically.

Worked normalization cases (pin these so equivalent configs fire identically):

If the gate fires:

1. Do not compute or store the stub sum. A suppressed quote must never appear as aws_monthly_range_usd.low / .high.
2. Set cost_preview.aws_monthly_range_usd to null.
3. Set cost_preview.quote_suppressed to true, quote_suppressed_reason to "authored_sizes_exceed_preview_defaults", and authored_size_signals to the ordered list from above ("address: field value" format, max 5).
4. Set cost_preview.disclaimer to: "Discover does not quote a monthly AWS range when Terraform sizes exceed the preview's hardcoded development defaults. Estimate after Clarify prices the authored (or user-confirmed) sizes."
5. Still set gcp_monthly_usd from billing when present (that number is real). Never invent GCP spend.

If the gate does not fire, keep the existing stub-range behavior (quote_suppressed: false or omit the new fields).

If billing-profile.json exists: Set gcp_monthly_usd from summary.total_monthly_spend. Show GCP actual. Show the AWS range only when the authored-size gate did not fire.

If only IaC: Set gcp_monthly_usd: null. Show the AWS range only when the authored-size gate did not fire.

If neither IaC nor billing: Omit cost preview entirely (cost_preview: null).

Step 3: Build key_decisions_ahead

Generate 2-4 bullets based on what was detected. Use only signals present in discovery artifacts:

Always include “Target region” if any compute is present. Cap at 4 bullets.

Step 4: Build duration_hint string

No week counts — durations are uncalibrated at Discover time (and stay heuristic after; see shared/migration-complexity.md § Provenance). Describe the shape of the path instead:

Always append “confirm after Clarify” – full tier classification requires preferences.

Step 5: Write migration-preview.json

Write $MIGRATION_DIR/migration-preview.json:

Suppressed-quote example (authored-size gate fired — use this shape when quote_suppressed is true):

Field rules:

• cost_preview is null if neither IaC nor billing data was available
• cost_preview.gcp_monthly_usd is null if no billing data (IaC-only run)
• cost_preview.aws_monthly_range_usd is null when quote_suppressed is true (authored-size gate). Do not write a stub low/high “for later.”
• cost_preview.quote_suppressed / quote_suppressed_reason / authored_size_signals / disclaimer are required when the authored-size gate fired; omit the first three when it did not. When suppressed, disclaimer is the gate sentence in step 4 (not the stub “dev-tier ±30%” line). When not suppressed, disclaimer stays the existing stub sentence.
• ai_detected is true if ai-workload-profile.json exists
• services_summary lists only PRIMARY resources, deduplicated by gcp_type
• eligible_for_clarify_fast_path is false whenever ai_detected == true, regardless of infra complexity
• eligible_for_clarify_simple_path is true only when ai_detected == true, complexity_signal == "likely_simple", and ai_complexity_signal == "likely_simple" (non-agentic direct SDK, ≤2 models)
• ai_complexity_signal is null when no AI profile exists; otherwise "likely_simple" or "standard"

Step 6: Build preview chat message

Output this block as part of discover.md Step 3’s user message (chat only – not a file):

Do NOT write this to a file. Chat output only.

COST_ROW (HARD): Fill the AWS cost cell from cost_preview — do not improvise.

• If quote_suppressed is true: Not quoted at Discover — Terraform sizes are above the preview defaults (e.g. [first authored_size_signal]). Full AWS number in Estimate after you confirm sizing. If gcp_monthly_usd is set, append a second sentence: Your current GCP bill is ~$[gcp]/mo. Never print ~$[low]-$[high] or “dev-tier estimate” in this row when the quote is suppressed.
• Else: ~$[low]-$[high]/mo [vs GCP ~$[gcp]/mo if billing present] *(dev-tier estimate, +-30%)*