sparkforge-aws

Use quando o job processa dados em lotes com for/while, collect de chaves, isin(list) gigante ou filtros por batch id, ou dispara action/write/count/merge dentro de loop, e você suspeita de recomputação do DAG, lineage crescente, múltiplos commits Iceberg ou OOM acumulado por iteração. Use também quando perguntarem "por que esse batch demora mais a cada lote", "por que tem tantos commits/snapshots" ou "o job cresce com o número de lotes", mesmo sem mencionar loop explicitamente. Se você está prestes a contar iterações e estimar custo acumulado de cabeça, rode `sparkforge analyze pyspark` e filtre por `pyspark.loop` em vez disso — cada ocorrência já vem marcada com se contém action, write e a profundidade de aninhamento.

Use quando for necessario estudar regras funcionais, contratos, estados, excecoes e criterios de aceite.

Use quando o job Glue chama uma biblioteca Python com múltiplos módulos, factories, decorators ou helpers, e você precisa saber onde estão leituras, actions, caches, loops, UDFs, mudanças de Spark config e writes que não aparecem ao olhar só o entrypoint — count() escondido em logger, persist sem unpersist, write dentro de helper três chamadas abaixo. Use também quando perguntarem "essa lib tem algum job escondido", "de onde vem essa action extra", "até onde essa função chega" ou "isso é seguro de chamar", mesmo sem mencionar grafo de chamadas. Se você está prestes a seguir import por import manualmente para responder isso, rode `sparkforge analyze pyspark` e depois `sparkforge analyze call-graph` em vez disso — ele devolve a profundidade mínima e o caminho até cada trabalho Spark alcançável, o que uma lista de arestas sozinha não responde.

Use quando houver um Spark event log, um job run id ou um Spark UI aberto de um job AWS Glue e for preciso achar stage dominante, skew de task, spill, GC, executor perdido ou subparalelismo. Use também quando a pergunta for "por que este stage demora", "por que uma task não termina", "o executor sumiu" ou "está com spill", mesmo que ninguém fale em event log. Se você está prestes a ler métrica de execução de Spark no olho, rode `sparkforge collect event-log` e `sparkforge analyze event-log` em vez disso — o extrator calcula p50/p95/max, spill e GC por stage, e o catálogo aplica os limiares versionados.

Use quando precisar escolher, comparar, recomendar, iniciar ou operar um banco de dados AWS — roteia para o servico correto entre Aurora, DSQL, RDS, DynamoDB, ElastiCache, MemoryDB, DocumentDB, Keyspaces, Timestream, Neptune. Aplica quando alguem descreve uma aplicacao que vai armazenar, recuperar ou gerenciar dados na AWS, mesmo sem mencionar "banco de dados" explicitamente. Cobre relacional (Aurora, DSQL, RDS PostgreSQL/MySQL/MariaDB/Oracle/SQL Server/Db2), key-value (DynamoDB), wide-column (Keyspaces), documento (DocumentDB), grafo (Neptune), serie temporal (Timestream) e em-memory/cache (ElastiCache, MemoryDB). NAO use para armazenamento de objeto/arquivo (S3, EFS, FSx — use aws-storage) nem para analytics query engines (Athena, Redshift).

Use quando precisar corrigir comportamentos de IAM que agentes frequentemente erram — avaliação de policy, trust policies, limites de STS, Organizations, SAML/MFA — ou for criar roles de serviço, gerar policies baseline a partir de código-fonte ou Terraform plan JSON, configurar confused deputy protection, ou escrever policies com condition operators (ForAnyValue/ForAllValues com Null checks). Aplica-se a criação de roles IAM, escrita de IAM/bucket policies, trabalho com STS, Organizations ou condition operators. NÃO use para autorização não-IAM (Cognito user-pool policies, RBAC app-level).

Use quando for raciocinar sobre padrões de mensageria e streaming na AWS — escolher entre SQS, SNS, EventBridge, Amazon MQ, Kinesis Data Streams, Data Firehose, Managed Service for Apache Flink e MSK, ou decidir qual padrão (mensageria vs. streaming) cabe a um workload. Use também para identificar qual serviço AWS possui cada canal de comunicação com cliente (e-mail via SES; WhatsApp, SMS, MMS, RCS, voice e mobile push via AWS End User Messaging) e rotear à skill especializada. NÃO use para perguntas detalhadas de MSK ou Managed Service for Apache Flink — prefira skills específicas. Não configura canais de comunicação com cliente; adia às skills especializadas.

Use quando for configurar, depurar ou otimizar observabilidade AWS com CloudWatch (Log Insights, Metrics, Alarms, Dashboards, EMF), X-Ray, CloudTrail e ADOT (AWS Distro for OpenTelemetry), ou habilitar/onboardar um serviço em Application Signals via ADOT auto-instrumentation SDKs. Aplica-se a alarms (métrico, composto, anomalia), dashboards, custom metrics/EMF, tracing e sampling, config de ADOT collector, CloudTrail auditing, synthetics/canaries e Dynamic Instrumentation. NÃO use para logging de aplicação ou detecção de ameaças de segurança.

Use quando for escrever código Python que usa serviços AWS via boto3 ou botocore — criar service clients ou resources, configurar sessions e credenciais, tratar erros com ClientError, usar paginators e waiters, transferências S3 e presigned URLs, operações de tabela DynamoDB, ou qualquer configuração de client boto3/botocore. Use sempre que código Python importar boto3 ou botocore, ou quando o usuário perguntar sobre operações AWS em Python.

Use quando a pergunta envolver serviços AWS de segurança — Security Hub V2 (OCSF) findings, conectores, agregadores, automation rules e resumo de postura; Security Hub CSPM (V1/ASFF) controles e padrões de compliance; GuardDuty threat findings; Inspector vulnerability findings; Macie sensitive data findings; Detective investigation; e Security Lake. Use para postura de segurança, Exposure findings, controles CSPM falhados, threat findings, vulnerability findings, sensitive data findings, automation rules ou configuração cross-service de segurança em ambientes AWS. Procedimentos usam sintaxe AWS CLI padrão e funcionam com ou sem o AWS MCP server.

Use quando precisar construir, deployar, gerenciar, debugar, configurar ou otimizar aplicacoes serverless na AWS com Lambda, API Gateway, Step Functions, EventBridge e SAM/CDK. Cobre cold starts, CORS, event source mappings, troubleshooting, concorrencia, SnapStart, Powertools, Function URLs, EventBridge Scheduler, Lambda layers e production readiness. Aplica quando alguem menciona Lambda, API Gateway, Step Functions, SAM templates, CDK serverless stacks, triggers de DynamoDB Stream, SQS event sources, cold starts, timeouts, erros 502/504, throttling, concorrencia, CORS, Powertools ou qualquer arquitetura event-driven na AWS, mesmo sem a palavra "serverless". NAO use para EC2, containers ECS/Fargate ou Amplify hosting.

Use quando precisar escolher, comparar ou operar servicos de armazenamento AWS — S3 (General Purpose, Express One Zone, Tables, Vectors, Files), EFS, FSx (Lustre, ONTAP, OpenZFS, Windows), EBS, DataSync, Transfer Family, Storage Gateway, AWS Backup. Cobre selecao de servico por workload, custo, performance, configuracao, seguranca, troubleshooting e migracao de dados. Aplica quando alguem pergunta onde armazenar ou arquivar dados, qual servico de storage escolher, como comparar dois, como migrar de on-premises ou entre servicos AWS, como proteger/replicar/recuperar dados, como otimizar custo de storage, onde deployar NFS/SMB/POSIX compartilhado, onde guardar vector embeddings ou dados tabulares, ou como um servico de storage AWS funciona. NAO use para motores de consulta SQL (Athena, Spark, Redshift, EMR), ETL (Glue), streaming (Kafka, MSK, Kinesis) ou bancos gerenciados (RDS, Aurora, DynamoDB).

Use quando precisar comprovar — não estimar — o efeito de uma mudança de performance num job Glue, com comparação antes/depois de duração de stage, spill, GC e executor perdido, isolando uma variável por vez. Use também quando for escrever "X% mais rápido", "reduziu o shuffle pela metade", "resolveu o OOM" ou qualquer alegação quantificada de ganho. Se você está prestes a escrever um percentual de ganho sem rodar `sparkforge validate --findings`, pare — o schema rejeita `expected_effect` quantificado (%, x, vezes) sem `benchmark_ref`, e ganho previsto sem benchmark é invenção, não resultado.

Use quando for necessario desenhar arquiteturas de dados completas.

Use quando for necessario projetar S3, zonas, lifecycle e governanca de data lake.

Use quando o judge já disparou SF-UI-001 (skew de duração de task) e for preciso decidir entre skew de dados e skew de computação, tratar hot key, null ou valor sentinela, ou desenhar o experimento de mitigação (broadcast, AQE skew join, salting). Use também quando a pergunta for "uma task não termina", "uma chave concentra tudo", "o job trava numa partição só" ou "uma partição ficou gigante", mesmo sem citar SF-UI-001. Se você está prestes a aplicar salting ou repartition por instinto, rode `sparkforge collect event-log`, `sparkforge analyze event-log` e `sparkforge judge --show-skipped` em vez disso — cruzar SF-UI-001 com SF-UI-002 diz se é skew de dados (tratável na chave) ou de computação (repartition não muda nada, e é o erro mais caro desta análise).

Use quando um job Glue lê tabela governada e falha ao escrever, ou quando alguém pergunta "por que a leitura passa e a escrita não?", "tomo AccessDenied e já dei SELECT", "troquei writeTo/insertInto/INSERT INTO e continua igual", "migrei de Glue 4.0 e nada funciona", ou quando é preciso descobrir QUAL permissão falta em vez de em qual plano a operação parou. É o procedimento que ORDENA os quatro coletores de governança de acesso; para a pergunta "esta configuração é suportada?" isolada, use `lakeformation-fgac-guard`.

Use quando investigar de ponta a ponta uma biblioteca PySpark no AWS Glue com fluxos full e incremental, latest-per-key sobre tabela Iceberg bilionária, batching por lote, OOM que só aparece depois de horas, ou carga que varia de dezenas a milhões de registros — e for preciso orquestrar as skills especializadas em vez de mexer isoladamente num sintoma. Use também quando a pergunta for "o job incremental tá tão lento quanto o full", "o job só morre de memória depois de um bom tempo rodando" ou "esse job tem dois jeitos de rodar e não sei qual tá causando o problema", mesmo que ninguém fale em full/incremental. Se você está prestes a mexer em workers, shuffle partitions ou cache antes de mapear a biblioteca inteira, pare — é exatamente isso que este documento existe para evitar. Leia `PROMPT_INICIAL_MESTRE.md` primeiro.

Use quando for proteger um bucket S3 — criar bucket novo já hardenado, auditar bucket existente contra controles de segurança, remediar finding de security hub/guardduty, configurar encriptação (SSE-S3 com Bucket Keys, SSE-KMS com chave gerenciada pelo cliente), ou habilitar logging/monitoramento (server access logging, CloudTrail data events, GuardDuty, Config rules). Use também quando a pergunta for "esse bucket está seguro", "por que o finding de bucket público", "qual a diferença entre SSE-S3 e SSE-KMS aqui" ou "como bloqueio SSE-C", mesmo sem citar "harden". NÃO use para operações de dado S3 (upload/download/list), setup de S3 Tables (use `provision-s3-tables-table`), descoberta de assets existentes, ou hardening de serviços que não S3. Se você está prestes a rodar `put-bucket-policy` sem back up da policy atual, pare — `put-bucket-policy` substitui a policy inteira e descarta statements existentes em silêncio.

Use quando alguém pergunta "posso subir essa tabela para Iceberg format v3?", "o Athena lê v3?", "vale a pena o VARIANT / os deletion vectors / o row lineage?" ou quando uma query em Athena passou a falhar com `Cannot read unsupported version 3` depois de uma migração de runtime. Use antes de qualquer recomendação de mudar `format-version`. Se você está prestes a responder de memória o que cada engine suporta, rode `sparkforge iceberg assess-upgrade <dir> --from 2 --to 3` — a matriz de suporte tem uma célula por par engine/feature, cada uma com fonte, e a maioria é `UNKNOWN`, que é o resultado honesto e não uma lacuna a preencher por inferência.

Use quando um job Glue declara `--enable-lakeformation-fine-grained-access` ou configuração de Full Table Access e alguém pergunta "posso passar um JAR extra?", "por que meu conector parou de funcionar sob FGAC?", "por que a leitura funciona e a escrita não?", "troquei `writeTo` por `INSERT INTO` e continua dando erro de Lake Formation", "dá para usar UDF Java / HiveUDF / data source customizado com controle de acesso fino?" ou quando é preciso decidir entre FGAC e Full Table Access, ou entre manter FGAC e manter uma dependência. Use antes de recomendar `--extra-jars` em qualquer job com FGAC ligado, e antes de trocar a API de escrita de um job que falha sob Lake Formation. Se você está prestes a ler o Terraform no olho procurando os argumentos, rode `sparkforge migrate glue <dir> --from 5.1 --to 6.0` — a área `SF-LF` correlaciona o que precisa ser correlacionado, e é isso que separa a regra de um gerador de acusação falsa.

Use quando alguém pergunta "dá para subir esse job para o Glue 6.0?", "o que quebra se eu migrar de 4.0/5.0/5.1 para 6.0?", "vale a pena migrar por causa dos 30% mais barato?" ou precisa de um plano de migração entre versões de runtime do AWS Glue. Use também quando o job já foi migrado e passou a falhar com `NoSuchMethodError`, `NoSuchFieldError` ou erro de ANSI mode. Se você está prestes a ler o guia de migração da AWS e comparar com o código no olho, rode `sparkforge migrate glue <dir> --from X --to Y` em vez disso — o motor expande o par em degraus, julga cada um com o catálogo versionado e devolve os eixos que **não** foram avaliados em vez de deixá-los passar como aprovados.

Use quando tabelas Apache Iceberg no Glue Data Catalog degradam por excesso de data files pequenos, delete files acumulados, snapshots ou manifests crescendo sem parar, partition spec inadequado ou write.distribution-mode incoerente com particionamento — e for preciso decidir entre compaction, rewrite manifests e expire snapshots com evidência, não por rotina. Use também quando a pergunta for "essa tabela Iceberg tá lenta para consultar", "o Athena demora para planejar essa tabela" ou "quantos snapshots essa tabela já acumulou", mesmo que ninguém fale em metadata table. Se você está prestes a rodar `SELECT * FROM db.tabela.files` no olho para contar arquivo pequeno, rode `sparkforge collect iceberg-metadata` e `sparkforge analyze iceberg` em vez disso — o extrator resume files, delete files, snapshots, manifests e partições deterministicamente, e o catálogo aplica os limiares versionados.

Use quando datasets Parquet no S3 (fora do Iceberg) sofrem com small files, listing lento, milhares de objetos por prefixo, arquivo por chave na escrita, ou leitura que não faz partition/predicate pushdown. Use também quando a pergunta for "o S3 tá cheio de arquivinho", "a leitura desse dataset demora antes mesmo da primeira task rodar" ou "cada execução gera um arquivo por cliente", mesmo que ninguém fale em Parquet. Se você está prestes a contar arquivo com `aws s3 ls` no olho, salve `aws s3api list-objects-v2` num arquivo e rode `sparkforge analyze s3-listing` — ele emite `s3.prefix_summary` e o `judge` aplica `SF-PQ-001`, `SF-PQ-003` e `SF-PQ-005`. Para o lado da leitura, `sparkforge analyze plan` emite `plan.file_scan` e cobre `SF-PQ-002` e `SF-PQ-004`; `analyze pyspark` e `analyze catalog-schema` fecham escrita e cardinalidade.

Use quando revisar, refatorar ou otimizar código PySpark/Spark SQL para AWS Glue — script, função, módulo, PR ou trecho de DataFrame — suspeito de UDF Python evitável, collect/toPandas, join sem redução prévia, cache indevido, coalesce(1), repartition arbitrário, explode sem controle, sequência longa de withColumn, dropDuplicates sem chave explícita ou spark.conf.set em runtime. Use também quando a pergunta for "por que esse código está lento", "isso vai escalar", "tem algo errado nesse DataFrame" ou "como eu melhoro isso", mesmo que ninguém cite UDF, shuffle ou cardinalidade pelo nome. Use também quando o job constrói `GraphFrame` e chama `connectedComponents`, `pageRank`, `aggregateMessages` ou `pregel` — é o mesmo `.py`, lido por `sparkforge analyze graph`. Se você está prestes a ler o arquivo linha a linha procurando esses padrões, rode `sparkforge analyze pyspark` em vez disso — ele varre a árvore inteira, não uma amostra, e ancora cada achado em file:line:col.

Use quando o mesmo job Glue roda de dezenas de registros a centenas de milhões e um único perfil configurado para o pior caso fica caro em microcarga e ainda inadequado no full. Use também quando a pergunta for "por que a carga vazia demora 5 minutos", "o job de teste custa quase igual ao de produção" ou "ficou mais lento essa semana" num job cujo volume varia muito entre execuções. Se você está prestes a comparar runs de volumes diferentes só de cabeça, rode `sparkforge analyze event-log` em cada run e `sparkforge analyze pyspark` no código em vez disso — subparalelismo (SF-UI-006) que é esperado numa carga micro é sintoma real numa carga full, e o catálogo não distingue os dois perfis sozinho; quem separa é você.

Use quando o operador quiser levar ao repositório uma mudança de configuração que já passou pelo sandbox — "abre o PR dessa mudança", "propõe essa troca", "o sandbox passou, e agora?". A sessão monta o pacote com `sparkforge_change_propose` e roda os comandos git/gh do `commands.md` passo a passo, PARANDO para confirmação explícita antes de `git push` e de `gh pr create`. O pacote nunca roda git; quem roda é a sessão, com aprovação humana.

Use quando for criar uma tabela Iceberg gerenciada por Amazon S3 Tables (o produto `s3tables`, não o Glue Data Catalog tradicional) — table bucket, namespace, tabela, schema, particionamento, integração com o catálogo `s3tablescatalog` e IAM no namespace `s3tables:*`. Use também quando a pergunta for "como crio uma tabela Iceberg sem gerenciar compaction", "S3 Tables vale vs Glue Data Catalog" ou "por que `s3:*` não funciona no S3 Tables", mesmo sem citar o produto pelo nome. NÃO use para criar tabela no Glue Data Catalog tradicional (esse caminho não está aqui — use `design-s3-data-lake` para o design e `optimize-iceberg-table` para a manutenção), nem para ingerir dado (procedimento de carga é outro), nem para consultar tabela existente (agent `athena-query-optimizer`). Se você está prestes a rodar `aws s3tables create-table-bucket` sem checar tabelas existentes, pare — o passo 1 exige o inventário, e criar sobre nome existente é silencioso.

Use quando o job PySpark valida dado e a pergunta for onde a validação está, se ela tem consequência e quanto ela custa — check artesanal (`df.filter(...).count()`), `VerificationSuite` do PyDeequ ou Great Expectations por `batch_parameters`. Use também quando a pergunta for "esse job valida alguma coisa?", "por que o job termina verde com dado ruim?", "essa suíte protege alguém?" ou "por que validar dobrou o tempo do job?", mesmo que ninguém fale em regra. Se você está prestes a ler o `.py` no olho procurando `count()`, rode `sparkforge analyze data-quality` e `sparkforge judge` em vez disso — o extrator decide a posição relativa ao write, a persistência do alvo e quantos checks pesam sobre o mesmo DataFrame, e o catálogo aplica as regras SF-DQ sobre o que ele achou.

Use quando revisar a execução de um job Amazon EMR on EKS pelo par `describe-virtual-cluster` + `describe-job-run` do `emr-containers` (segredo em texto claro nas duas superfícies de configuração, destino de log ausente, `persistentAppUI` desligado, alocação dinâmica sem `shuffleTracking` no Kubernetes). Use também quando a pergunta for "cadê os logs desse job run", "por que não tem Spark UI", "esse job rodou com qual configuração" ou "quem submeteu isso com senha na linha de submit", mesmo que ninguém fale em regra. Se você está prestes a ler `describe-job-run` no olho, rode `sparkforge analyze emr-eks` e `sparkforge judge` em vez disso. Esta skill NÃO julga capacidade de nó, pod pendente nem pod template — nada disso está no `emr-containers`, e supor que está é inventar. Para EMR on EC2 e EMR Serverless a skill é `review-emr-cluster`.

Use quando revisar o Terraform/IaC de jobs Glue (worker type, max_capacity junto com worker_type/number_of_workers, execution class, timeout, max_concurrent_runs com bookmarks, max_retries com escrita não idempotente, default arguments, Spark UI/event logs, segredo em argumento) em busca de configuração contraditória, observabilidade ausente ou incompatível com o runtime. Use também quando a pergunta for "esse .tf tá certo", "por que a config que eu mudei no Terraform não fez efeito" ou "tem credencial exposta nesse job", mesmo que ninguém fale em regra. Se você está prestes a ler o .tf linha por linha comparando contra a doc do Glue, rode `sparkforge analyze terraform` e `sparkforge judge` em vez disso — o extrator lê os blocos aws_glue_job deterministicamente e o catálogo aplica as regras SF-GLUE por recurso.

Use quando revisar um Pull Request PySpark/AWS Glue e precisar classificar risco de regressão de performance, custo e escala antes de aprovar — novas actions, shuffles, joins com cardinalidade, UDFs, collect, loops de DataFrame, mudança de write mode, particionamento ou operações Iceberg/Parquet introduzidas pelo diff. Use também quando pedirem "dá uma olhada nesse PR", "isso é seguro de mergear", "o que mudou de performance aqui" ou "aprova esse diff", mesmo sem falar em code review formal. Se você está prestes a ler o diff e apontar problema de cabeça, rode `sparkforge analyze pyspark` nos arquivos alterados e compare contra a versão base em vez de confiar em leitura visual — e valide sua própria recomendação com `sparkforge validate` antes de postar, porque um ganho quantificado sem `benchmark_ref` é rejeitado pelo schema.

Use quando for necessario revisar Terraform de plataformas de dados, IAM, providers, plans e drift.

Use quando `sparkforge arbitrate` devolver `debate.unresolved` com um `debate_plan` para um par de regras e o operador quiser conduzir o debate na sessão — "roda o debate entre SF-X e SF-Y", "qual das duas ações fica?", "o arbitrate parou em debate, e agora?". A sessão faz o papel de cada lado, pede o brief ao executor com `sparkforge_debate_next`, escreve a submissão e a entrega com `sparkforge_debate_submit`, até o executor devolver `done`. O fechamento é sempre do `referee`, nunca da sessão.

Use quando o plan.md da feature está ready e é hora de construir — "executa o plano", "implementa a feature", "fase build" — no SparkForge (perfil dev) ou num job do operador (perfil operator, sempre por change sandbox).

Use quando a abordagem já está escolhida, ou o pedido já é claro, e falta fixar o que significa pronto — "define os requisitos", "quais os critérios de aceite?", "fase define" — para uma mudança no SparkForge ou num job do operador.

Use quando o define.md da feature está ready e falta decidir como construir — "desenha a solução", "quais arquivos mudam?", "como desfazer?", "fase design" — no SparkForge ou num job do operador.

Use quando uma ideia ainda sem forma vai virar mudança no SparkForge ou num job Glue/PySpark do operador — "quero fazer X", "uso A ou B?", "como você atacaria isso?" — e ainda não há define, design nem código. Requisito já claro vai direto para sdd-define.

Use quando o design.md da feature está ready e falta quebrar a construção em tarefas pequenas, com teste e código, que outra sessão execute sem contexto — "escreve o plano", "quebra em tarefas", "fase plan".

Use quando o build_report.md da feature está pronto e é hora de entregar — "entrega a feature", "fecha o ciclo", "fase ship", "posso abrir o PR?", "posso fazer merge?" — no SparkForge ou num job do operador.

Use quando o código PySpark ou o `.jar` precisa rodar sob Apache Spark 4 e alguém pergunta "o que quebra no Spark 4?", "essa config mudou de nome?", "ANSI mode vai estourar meu cast?" ou "meu JAR de Scala 2.12 funciona?". Use também quando o job falha com `NoSuchMethodError`, `ClassNotFoundException` ou uma exceção de overflow que antes devolvia NULL. Se você está prestes a comparar o código com o guia de migração do Apache no olho, rode `sparkforge migrate glue <dir> --from 5.1 --to 6.0` e `sparkforge glue dependency-audit <dir> --glue 6.0` — a área `SF-SPARK4` guarda cada regra pela versão de **Spark**, não de Glue, e por isso vale igual num EMR.

Use quando for necessario escolher, validar ou autorizar ferramentas por especializacao, risco e contrato.

Use quando for ajustar workers, worker type, Auto Scaling, execution class ou argumentos de um job Glue depois de já ter um gargalo comprovado — não para descobri-lo. Use também quando a pergunta for "aumenta os workers?", "põe mais DPU", "troca pra worker maior" ou "liga Auto Scaling", mesmo sem esse vocabulário. Se você está prestes a recomendar mais workers a partir só do código ou de instinto, rode `sparkforge analyze terraform`, `sparkforge collect glue-job` e `sparkforge judge` em vez disso — o catálogo SF-GLUE-* aponta contradição de max_capacity com worker_type/number_of_workers, observabilidade ausente e retry sobre escrita não idempotente antes de qualquer decisão de capacidade, e a tabela de decisão em knowledge/glue/workers-and-capacity.md tem capacidade como resposta errada em metade dos casos.