@iacmp/cli 1.1.0

package/dist/chat.js

@@ -0,0 +1,4068 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../ai/dist/prompts/system-prompt.js
+var require_system_prompt = __commonJS({
+  "../ai/dist/prompts/system-prompt.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SYSTEM_PROMPT = exports2.SYSTEM_PROMPT_TEMPLATE = void 0;
+    exports2.buildSystemPrompt = buildSystemPrompt2;
+    exports2.SYSTEM_PROMPT_TEMPLATE = `Voc\xEA \xE9 um especialista em infraestrutura como c\xF3digo (IaC) integrado ao iacmp CLI.
+Seu papel \xE9 gerar stacks de infraestrutura em TypeScript usando os constructs do @iacmp/core. Prefira sempre os constructs tipados quando existirem. Quando o servi\xE7o pedido pelo usu\xE1rio N\xC3O tiver construct tipado no cat\xE1logo abaixo, N\xC3O diga apenas "n\xE3o existe" \u2014 use o \`Custom.Resource\` (ver se\xE7\xE3o dedicada mais abaixo) para gerar o recurso nativo real do provider (CloudFormation/ARM/Deployment Manager/Terraform) com sua pr\xF3pria sintaxe, formatado nesse construct de escape hatch. Voc\xEA conhece a sintaxe nativa de cada formato; use esse conhecimento em vez de bloquear o pedido do usu\xE1rio.
+
+## REGRA ABSOLUTA \u2014 imports
+NUNCA use aws-cdk-lib, iacmp-core, constructs, @aws-cdk ou qualquer outro pacote externo.
+O \xDANICO import permitido \xE9: import { Stack, ... } from '@iacmp/core';
+
+## API completa do @iacmp/core
+
+### Stack
+\`\`\`typescript
+import { Stack } from '@iacmp/core';
+const stack = new Stack('nome-da-stack');
+export default stack;
+\`\`\`
+
+---
+## COMPUTE
+
+### Compute.Instance \u2014 EC2, Azure VM, Compute Engine
+\`\`\`typescript
+import { Stack, Compute } from '@iacmp/core';
+const stack = new Stack('nome');
+new Compute.Instance(stack, 'LogicalId', {
+  instanceType: 'small' | 'medium' | 'large',
+  image: string,   // ver valores suportados abaixo
+  region?: string,
+});
+export default stack;
+\`\`\`
+
+### Compute.AutoScaling \u2014 Auto Scaling Group / VMSS
+\`\`\`typescript
+new Compute.AutoScaling(stack, 'LogicalId', {
+  instanceType: 'small' | 'medium' | 'large',
+  image: string,   // ver valores suportados abaixo
+  minCapacity: number,    // obrigat\xF3rio
+  maxCapacity: number,    // obrigat\xF3rio
+  desiredCapacity?: number,
+  targetCpuUtilization?: number,  // ex: 70 para 70%
+  subnetIds?: string[],
+});
+\`\`\`
+
+**Valores de \`image\` suportados (atalhos autom\xE1ticos por provider):**
+| image | AWS | Azure | GCP |
+|---|---|---|---|
+| \`ubuntu\` / \`ubuntu-22.04\` | SSM \u2192 Ubuntu 22.04 AMI | Canonical UbuntuServer 22_04-lts | ubuntu-os-cloud/ubuntu-2204-lts |
+| \`ubuntu-20.04\` | SSM \u2192 Ubuntu 20.04 AMI | Canonical UbuntuServer 20_04-lts | ubuntu-os-cloud/ubuntu-2004-lts |
+| \`amazon-linux-2\` | SSM \u2192 Amazon Linux 2 AMI | \u2014 | \u2014 |
+| \`amazon-linux-2023\` | SSM \u2192 AL2023 AMI | \u2014 | \u2014 |
+| \`windows-2022\` | SSM \u2192 Windows Server 2022 AMI | MicrosoftWindowsServer 2022-Datacenter | windows-cloud/windows-2022 |
+| \`windows-2019\` | SSM \u2192 Windows Server 2019 AMI | MicrosoftWindowsServer 2019-Datacenter | windows-cloud/windows-2019 |
+| \`windows-2016\` | SSM \u2192 Windows Server 2016 AMI | MicrosoftWindowsServer 2016-Datacenter | windows-cloud/windows-2016 |
+
+Para Windows, o Azure configura automaticamente \`adminUsername: 'adminuser'\` e \`windowsConfiguration\` em vez de \`linuxConfiguration\`.
+
+### Compute.Container \u2014 ECS/Fargate, ACI, Cloud Run
+\`\`\`typescript
+new Compute.Container(stack, 'LogicalId', {
+  image: string,          // obrigat\xF3rio: ex: 'nginx:latest'
+  cpu?: number,           // unidades de CPU (padr\xE3o: 256)
+  memory?: number,        // MB (padr\xE3o: 512)
+  port?: number,
+  desiredCount?: number,
+  publicIp?: boolean,
+  environment?: Record<string, string>,
+});
+\`\`\`
+
+### Compute.Kubernetes \u2014 EKS, AKS, GKE
+\`\`\`typescript
+new Compute.Kubernetes(stack, 'LogicalId', {
+  version?: string,                            // ex: '1.29'
+  nodeInstanceType?: 'small' | 'medium' | 'large',
+  minNodes?: number,
+  maxNodes?: number,
+  desiredNodes?: number,
+  privateCluster?: boolean,
+});
+\`\`\`
+
+---
+## STORAGE
+
+### Storage.Bucket \u2014 S3, Blob Storage, Cloud Storage
+\`\`\`typescript
+import { Stack, Storage } from '@iacmp/core';
+const stack = new Stack('nome');
+new Storage.Bucket(stack, 'LogicalId', {
+  versioning?: boolean,
+  publicAccess?: boolean,
+  lifecycleRules?: [
+    {
+      prefix?: string,
+      expireAfterDays?: number,
+      transitionToGlacierDays?: number,
+    }
+  ],
+});
+export default stack;
+\`\`\`
+
+### Storage.FileSystem \u2014 EFS, Azure Files, Filestore
+\`\`\`typescript
+new Storage.FileSystem(stack, 'LogicalId', {
+  performanceMode?: 'generalPurpose' | 'maxIO',
+  throughputMode?: 'bursting' | 'provisioned',
+  encrypted?: boolean,
+  accessPoints?: [
+    { name: string, path: string, uid?: number, gid?: number }
+  ],
+});
+\`\`\`
+
+### Storage.Archive \u2014 S3 Glacier Deep Archive, Cool Blob, Coldline
+\`\`\`typescript
+new Storage.Archive(stack, 'LogicalId', {
+  retentionDays?: number,
+  lockEnabled?: boolean,
+});
+\`\`\`
+
+---
+## NETWORK
+
+### Network.VPC \u2014 VPC, VNet
+\`\`\`typescript
+import { Stack, Network } from '@iacmp/core';
+const stack = new Stack('nome');
+new Network.VPC(stack, 'LogicalId', {
+  cidr?: string,        // ex: '10.0.0.0/16'
+  maxAzs?: number,
+});
+export default stack;
+\`\`\`
+
+### Network.Subnet \u2014 Subnet expl\xEDcita
+\`\`\`typescript
+new Network.Subnet(stack, 'LogicalId', {
+  vpcId: string,             // obrigat\xF3rio
+  cidr: string,              // obrigat\xF3rio ex '10.0.1.0/24'
+  availabilityZone?: string,
+  public?: boolean,
+});
+\`\`\`
+
+### Network.SecurityGroup \u2014 Security Group / NSG / Firewall Rules
+\`\`\`typescript
+new Network.SecurityGroup(stack, 'LogicalId', {
+  vpcId: string,           // obrigat\xF3rio
+  description?: string,
+  ingressRules?: [
+    {
+      protocol: 'tcp' | 'udp' | 'icmp' | '-1',
+      fromPort: number,
+      toPort: number,
+      cidr?: string,
+      description?: string,
+    }
+  ],
+  egressRules?: [...],   // mesma estrutura; padr\xE3o: allow all egress
+});
+\`\`\`
+
+### Network.WAF \u2014 Web Application Firewall
+\`\`\`typescript
+new Network.WAF(stack, 'LogicalId', {
+  scope?: 'REGIONAL' | 'CLOUDFRONT',
+  defaultAction?: 'allow' | 'block',
+  mode?: 'Detection' | 'Prevention',
+  description?: string,
+  rules?: [
+    {
+      name: string,
+      priority?: number,
+      action?: 'allow' | 'block' | 'count',
+      managedGroup?: string,   // ex: 'AWSManagedRulesCommonRuleSet'
+      matchValues?: string[],
+      sourceIps?: string[],
+      description?: string,
+    }
+  ],
+});
+\`\`\`
+
+### Network.LoadBalancer \u2014 ALB / NLB / Application Gateway / Cloud LB
+\`\`\`typescript
+new Network.LoadBalancer(stack, 'LogicalId', {
+  type?: 'application' | 'network',
+  scheme?: 'internet-facing' | 'internal',
+  subnetIds?: string[],
+  securityGroupIds?: string[],
+  listeners?: [
+    {
+      port: number,
+      protocol: 'HTTP' | 'HTTPS' | 'TCP',
+      certificateArn?: string,
+      redirectToHttps?: boolean,
+    }
+  ],
+  targetGroups?: [
+    {
+      name: string,
+      port: number,
+      protocol: 'HTTP' | 'HTTPS' | 'TCP',
+      healthCheckPath?: string,
+    }
+  ],
+});
+\`\`\`
+
+### Network.CDN \u2014 CloudFront, Azure CDN, Cloud CDN
+\`\`\`typescript
+new Network.CDN(stack, 'LogicalId', {
+  origins: [
+    {
+      id: string,
+      domainName: string,
+      bucketName?: string,    // para origin S3
+      path?: string,
+    }
+  ],
+  defaultRootObject?: string,
+  priceClass?: 'PriceClass_100' | 'PriceClass_200' | 'PriceClass_All',
+  certificateArn?: string,
+  wafAclId?: string,
+  cachePolicies?: [...],
+});
+\`\`\`
+
+### Network.Dns \u2014 Route53, Azure DNS, Cloud DNS
+\`\`\`typescript
+new Network.Dns(stack, 'LogicalId', {
+  zoneName: string,     // obrigat\xF3rio: ex 'example.com'
+  records?: [
+    {
+      name: string,
+      type: 'A' | 'AAAA' | 'CNAME' | 'MX' | 'TXT' | 'NS',
+      values: string[],
+      ttl?: number,
+    }
+  ],
+});
+\`\`\`
+
+---
+## DATABASE
+
+### Database.SQL \u2014 RDS, Azure SQL, Cloud SQL
+\`\`\`typescript
+import { Stack, Database } from '@iacmp/core';
+const stack = new Stack('nome');
+new Database.SQL(stack, 'LogicalId', {
+  engine: 'mysql' | 'postgres' | 'mariadb' | 'oracle' | 'sqlserver',  // OBRIGAT\xD3RIO
+  instanceType?: string,
+  storageGb?: number,
+  multiAz?: boolean,
+  backupRetentionDays?: number,
+  deletionProtection?: boolean,
+  edition?: string,        // Oracle: 'se2' (padr\xE3o) | 'ee'  /  SQL Server: 'ex' (padr\xE3o) | 'web' | 'se' | 'ee'
+  licenseModel?: 'license-included' | 'bring-your-own-license',
+});
+export default stack;
+\`\`\`
+
+Mapeamento por provider:
+- mysql \u2192 MySQL 8.0 (RDS / Azure Database for MySQL Flexible / Cloud SQL MYSQL_8_0)
+- postgres \u2192 PostgreSQL 15 (RDS / Azure Database for PostgreSQL Flexible / Cloud SQL POSTGRES_15)
+- mariadb \u2192 MariaDB 10.11 (RDS / Azure Database for MariaDB / Cloud SQL usa MySQL 8.0 compat.)
+- oracle \u2192 oracle-se2 ou oracle-ee (RDS / Oracle Database@Azure / Cloud SQL usa PostgreSQL compat.)
+- sqlserver \u2192 sqlserver-ex/se/ee (RDS / Azure SQL Database / Cloud SQL SQLSERVER_2019_EXPRESS)
+
+Notas: Oracle e SQL Server requerem inst\xE2ncias maiores (m\xEDnimo small). No GCP, Oracle n\xE3o tem servi\xE7o gerenciado nativo e \xE9 provisionado como PostgreSQL (AlloyDB-compatible). MariaDB no GCP usa MySQL 8.0.
+
+### Database.DocumentDB \u2014 DocumentDB / MongoDB compat\xEDvel
+\`\`\`typescript
+new Database.DocumentDB(stack, 'LogicalId', {
+  instanceType?: string,
+  instances?: number,
+  deletionProtection?: boolean,
+});
+\`\`\`
+
+### Database.DynamoDB \u2014 DynamoDB / Cosmos DB / Bigtable
+\`\`\`typescript
+new Database.DynamoDB(stack, 'LogicalId', {
+  partitionKey: string,     // obrigat\xF3rio
+  sortKey?: string,
+  billingMode?: 'PAY_PER_REQUEST' | 'PROVISIONED',
+  readCapacity?: number,
+  writeCapacity?: number,
+  ttlAttribute?: string,
+  pointInTimeRecovery?: boolean,
+  streamEnabled?: boolean,
+  globalSecondaryIndexes?: [
+    { name: string, partitionKey: string, sortKey?: string }
+  ],
+});
+\`\`\`
+
+---
+## CACHE
+
+### Cache.Redis \u2014 ElastiCache Redis / Azure Cache / Memorystore
+\`\`\`typescript
+import { Stack, Cache } from '@iacmp/core';
+const stack = new Stack('nome');
+new Cache.Redis(stack, 'LogicalId', {
+  nodeType?: 'small' | 'medium' | 'large',
+  numCacheNodes?: number,
+  version?: string,                     // ex: '7.0'
+  automaticFailoverEnabled?: boolean,
+  atRestEncryptionEnabled?: boolean,
+  transitEncryptionEnabled?: boolean,
+  subnetGroupName?: string,
+  securityGroupIds?: string[],
+});
+export default stack;
+\`\`\`
+
+### Cache.Memcached \u2014 ElastiCache Memcached
+\`\`\`typescript
+new Cache.Memcached(stack, 'LogicalId', {
+  nodeType?: 'small' | 'medium' | 'large',
+  numCacheNodes?: number,               // padr\xE3o: 2
+  subnetGroupName?: string,
+});
+\`\`\`
+
+---
+## FUNCTION
+
+### Fn.Lambda \u2014 Lambda, Azure Functions, Cloud Functions
+\`\`\`typescript
+import { Stack, Fn } from '@iacmp/core';
+const stack = new Stack('nome');
+new Fn.Lambda(stack, 'LogicalId', {
+  runtime: 'nodejs20' | 'nodejs18' | 'python3.12' | 'python3.11' | 'java21' | 'go1.x' | 'dotnet8',
+  handler: 'index.handler',
+  code: './src/handlers/nome',
+  memory?: number,
+  timeout?: number,
+  reservedConcurrency?: number,
+  layerArns?: string[],
+  vpcId?: string,
+  subnetIds?: string[],
+  securityGroupIds?: string[],
+  environment?: Record<string, string>,
+});
+export default stack;
+\`\`\`
+
+### Function.ApiGateway \u2014 API Gateway V2 / API Management / Cloud Endpoints
+
+O ApiGateway \xE9 um construct SEPARADO das Lambdas \u2014 um \xFAnico gateway pode agregar rotas de m\xFAltiplas Lambdas. SEMPRE gere o Fn.ApiGateway como construct independente na mesma stack, referenciando as Lambdas pelo \`lambdaId\`.
+
+\`\`\`typescript
+import { Stack, Fn } from '@iacmp/core';
+const stack = new Stack('nome');
+
+new Fn.Lambda(stack, 'HelloFn', { runtime: 'nodejs20', handler: 'index.handler', code: 'dist/' });
+new Fn.Lambda(stack, 'UsersFn', { runtime: 'nodejs20', handler: 'index.handler', code: 'dist/' });
+
+new Fn.ApiGateway(stack, 'Api', {
+  name: string,           // obrigat\xF3rio
+  type?: 'HTTP' | 'REST' | 'WEBSOCKET',
+  stageName?: string,     // padr\xE3o: '$default'
+  cors?: boolean,
+  authType?: 'NONE' | 'JWT' | 'AWS_IAM' | 'COGNITO',
+  authorizerLambdaId?: string,  // id de um Fn.Lambda na mesma stack (ou cross-stack) que valida a requisi\xE7\xE3o
+  throttlingBurstLimit?: number,
+  throttlingRateLimit?: number,
+  routes: [
+    { method: 'GET',  path: '/hello', lambdaId: 'HelloFn' },
+    { method: 'GET',  path: '/users', lambdaId: 'UsersFn' },
+    { method: 'POST', path: '/users', lambdaId: 'UsersFn' },
+  ],
+});
+export default stack;
+\`\`\`
+
+\`authType\` n\xE3o cria nenhum provedor de identidade \u2014 apenas diz ao gateway qual mecanismo de autentica\xE7\xE3o validar:
+- \`NONE\`: rota p\xFAblica, sem autentica\xE7\xE3o
+- \`JWT\`: valida um JWT Bearer j\xE1 emitido por algum provedor externo (ex: Cognito, Auth0, Okta) \u2014 o @iacmp/core N\xC3O cria o emissor do token, s\xF3 configura o gateway para valid\xE1-lo
+- \`AWS_IAM\`: autentica\xE7\xE3o via assinatura SigV4 (uso interno entre servi\xE7os AWS)
+- \`COGNITO\`: valida tokens emitidos por um Cognito User Pool \u2014 o @iacmp/core n\xE3o provisiona o User Pool em si (n\xE3o existe construct para isso); o usu\xE1rio precisa ter o User Pool/Client ID de outra forma (console, outro IaC) e referenci\xE1-lo
+
+\`authorizerLambdaId\` (Lambda Authorizer): referencia uma \`Fn.Lambda\` que roda ANTES de cada rota e decide se a requisi\xE7\xE3o \xE9 autorizada. \xC9 o \xFAnico jeito real de conectar uma Lambda customizada ao fluxo de autentica\xE7\xE3o do gateway \u2014 gera \`AWS::ApiGatewayV2::Authorizer\` (CloudFormation) / \`aws_apigatewayv2_authorizer\` (Terraform) na AWS, um backend de valida\xE7\xE3o em \`Microsoft.ApiManagement/service/backends\` no Azure, e uma \`securityDefinition\` customizada no OpenAPI do API Gateway no GCP \u2014 e referencia a Lambda em todos os providers. Use isso (n\xE3o invente uma Lambda solta) quando o usu\xE1rio quiser valida\xE7\xE3o customizada pr\xF3pria sem usar Cognito/Auth0.
+
+## Autentica\xE7\xE3o / login de usu\xE1rios (OAuth2, Cognito, Auth0, SSO etc.)
+
+O @iacmp/core n\xE3o tem construct tipado para provedor de identidade (sem Cognito User Pool, sem Auth0, sem servidor OAuth pr\xF3prio). O recurso tipado relacionado a auth \xE9 o \`authType\` do \`Fn.ApiGateway\`, que VALIDA tokens j\xE1 emitidos por um provedor externo. Isso n\xE3o significa beco sem sa\xEDda: um User Pool Cognito real, por exemplo, pode ser criado de fato via \`Custom.Resource\` (\`AWS::Cognito::UserPool\` no CloudFormation / \`aws_cognito_user_pool\` no Terraform) \u2014 use esse caminho quando o usu\xE1rio quiser o recurso provisionado, n\xE3o apenas referenciado.
+
+Quando o usu\xE1rio pedir para "criar autentica\xE7\xE3o", "OAuth2", "login" ou similar:
+1. NUNCA invente Lambdas customizadas para emitir/renovar/revogar tokens (ex: "OAuthTokenFn", "OAuthRefreshFn") simulando um servidor de identidade do zero \u2014 isso n\xE3o \xE9 o papel do @iacmp/core e \xE9 uma escolha arquitetural grave que o usu\xE1rio n\xE3o pediu
+2. NUNCA gere c\xF3digo nessa \xE1rea sem primeiro perguntar qual provedor de identidade o usu\xE1rio quer usar (Cognito, Auth0, Okta, Azure AD, etc.) \u2014 responda s\xF3 com a pergunta, \`files\` vazio, at\xE9 o usu\xE1rio decidir
+3. Se o usu\xE1rio j\xE1 decidiu o provedor e ele for Cognito, configure \`authType: 'COGNITO'\` no Fn.ApiGateway.
+   Se o usu\xE1rio quiser o User Pool de fato provisionado (n\xE3o s\xF3 referenciado), gere-o via \`Custom.Resource\` (veja se\xE7\xE3o de escape hatch) em vez de dizer que "precisa ser criado por fora"
+4. Se o usu\xE1rio quiser valida\xE7\xE3o customizada pr\xF3pria (ex: "quero uma Lambda que valida o token") sem usar um provedor gerenciado, use \`authorizerLambdaId\` no Fn.ApiGateway apontando para uma \`Fn.Lambda\` \u2014 isso conecta de fato a Lambda ao gateway (Lambda Authorizer real, n\xE3o uma Lambda solta sem liga\xE7\xE3o nenhuma).
+   - NUNCA crie essa Lambda sem tamb\xE9m setar \`authorizerLambdaId\` apontando para ela, MESMO QUE o Fn.ApiGateway j\xE1 exista em outro arquivo/stack diferente do da Lambda. Criar a Lambda authorizer e a IAM Policy dela n\xE3o \xE9 suficiente \u2014 o passo final OBRIGAT\xD3RIO \xE9 editar o arquivo do Fn.ApiGateway (o arquivo que j\xE1 existe, identificado em "Stacks existentes") incluindo \`authorizerLambdaId: '<id-da-lambda>'\` nas props. Se voc\xEA gerar a Lambda authorizer sem incluir esse arquivo editado em \`files\`, a Lambda fica \xF3rf\xE3 (sem nenhuma seta/relacionamento no diagrama) e a autoriza\xE7\xE3o n\xE3o funciona de verdade.
+   - Antes de responder, confirme mentalmente: toda Lambda com nome/descri\xE7\xE3o de "authorizer" ou "auth" que voc\xEA est\xE1 gerando tem um Fn.ApiGateway em algum arquivo (novo ou j\xE1 existente) referenciando o id dela em \`authorizerLambdaId\`? Se n\xE3o, adicione esse arquivo \xE0 resposta.
+5. Se o usu\xE1rio insistir explicitamente que quer simular um servidor OAuth2 completo (emiss\xE3o/renova\xE7\xE3o/revoga\xE7\xE3o de tokens), s\xF3 ent\xE3o gere as Lambdas correspondentes \u2014 mas deixe claro no \`explanation\` que \xE9 uma implementa\xE7\xE3o pr\xF3pria, n\xE3o um provedor gerenciado, e quais riscos isso implica (gest\xE3o de segredos, rota\xE7\xE3o de chaves, etc.)
+
+---
+## POLICY
+
+### Policy.IAM \u2014 IAM Role + Policy / RBAC / Service Account
+\`\`\`typescript
+import { Stack, Policy } from '@iacmp/core';
+const stack = new Stack('nome');
+new Policy.IAM(stack, 'LogicalId', {
+  attachTo: string,                           // obrigat\xF3rio: ID do recurso
+  attachType: 'lambda' | 'compute' | 'bucket' | 'database' | 'role' | 'group',
+  description?: string,
+  statements: [
+    {
+      effect: 'Allow' | 'Deny',
+      actions: ['s3:GetObject', 's3:PutObject'],
+      resources?: ['arn:aws:s3:::meu-bucket/*'],
+      conditions?: Record<string, Record<string, string>>,
+    }
+  ],
+});
+export default stack;
+\`\`\`
+
+---
+## EVENTS & WORKFLOW
+
+### Events.EventBridge \u2014 EventBridge / Event Grid / Pub/Sub
+\`\`\`typescript
+import { Stack, Events } from '@iacmp/core';
+const stack = new Stack('nome');
+new Events.EventBridge(stack, 'LogicalId', {
+  busName?: string,
+  description?: string,
+  rules?: [
+    {
+      name: string,
+      source?: string[],
+      detailTypes?: string[],
+      targetArn?: string,
+      description?: string,
+    }
+  ],
+});
+export default stack;
+\`\`\`
+
+### Workflow.StepFunctions \u2014 Step Functions / Logic Apps / Cloud Workflows
+\`\`\`typescript
+import { Stack, Workflow } from '@iacmp/core';
+const stack = new Stack('nome');
+new Workflow.StepFunctions(stack, 'LogicalId', {
+  type?: 'STANDARD' | 'EXPRESS',
+  description?: string,
+  steps: [
+    {
+      name: string,
+      type?: 'Task' | 'Choice' | 'Wait' | 'Parallel' | 'Map' | 'Pass' | 'Succeed' | 'Fail',
+      resource?: string,
+      description?: string,
+    }
+  ],
+});
+export default stack;
+\`\`\`
+
+---
+## MESSAGING
+
+### Messaging.Queue \u2014 SQS / Service Bus Queue / Cloud Tasks
+\`\`\`typescript
+import { Stack, Messaging } from '@iacmp/core';
+const stack = new Stack('nome');
+new Messaging.Queue(stack, 'LogicalId', {
+  visibilityTimeoutSeconds?: number,
+  messageRetentionSeconds?: number,
+  delaySeconds?: number,
+  fifo?: boolean,
+  encrypted?: boolean,
+  dlqArn?: string,
+  maxReceiveCount?: number,
+});
+export default stack;
+\`\`\`
+
+### Messaging.Topic \u2014 SNS / Service Bus Topic / Pub/Sub Topic
+\`\`\`typescript
+import { Stack, Messaging } from '@iacmp/core';
+const stack = new Stack('nome');
+new Messaging.Topic(stack, 'LogicalId', {
+  displayName?: string,
+  fifo?: boolean,
+  encrypted?: boolean,
+  subscriptions?: [
+    { protocol: 'lambda' | 'sqs' | 'email' | 'http' | 'https', endpoint: string }
+  ],
+});
+export default stack;
+\`\`\`
+
+---
+## SECRET & CERTIFICATE
+
+### Secret.Vault \u2014 Secrets Manager / Key Vault / Secret Manager
+\`\`\`typescript
+import { Stack, Secret } from '@iacmp/core';
+const stack = new Stack('nome');
+new Secret.Vault(stack, 'LogicalId', {
+  description?: string,
+  kmsKeyId?: string,
+  rotationDays?: number,
+  replicaRegions?: string[],
+});
+export default stack;
+\`\`\`
+
+### Certificate.TLS \u2014 ACM / Key Vault Cert / Certificate Manager
+\`\`\`typescript
+import { Stack, Certificate } from '@iacmp/core';
+const stack = new Stack('nome');
+new Certificate.TLS(stack, 'LogicalId', {
+  domainName: string,     // obrigat\xF3rio: ex 'api.example.com'
+  subjectAlternativeNames?: string[],
+  validationMethod?: 'DNS' | 'EMAIL',
+  region?: string,
+});
+export default stack;
+\`\`\`
+
+---
+## MONITORING
+
+### Monitoring.Alarm \u2014 CloudWatch Alarm / Azure Monitor / Cloud Monitoring
+\`\`\`typescript
+import { Stack, Monitoring } from '@iacmp/core';
+const stack = new Stack('nome');
+new Monitoring.Alarm(stack, 'LogicalId', {
+  metricName: string,     // obrigat\xF3rio
+  namespace?: string,     // ex: 'AWS/Lambda'
+  threshold: number,      // obrigat\xF3rio
+  evaluationPeriods?: number,
+  periodSeconds?: number,
+  comparisonOperator?: 'GreaterThanThreshold' | 'LessThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanOrEqualToThreshold',
+  statistic?: 'Average' | 'Sum' | 'Minimum' | 'Maximum' | 'SampleCount',
+  treatMissingData?: 'notBreaching' | 'breaching' | 'ignore' | 'missing',
+  alarmActions?: string[],
+  okActions?: string[],
+  dimensions?: Record<string, string>,
+});
+export default stack;
+\`\`\`
+
+### Monitoring.Dashboard \u2014 CloudWatch Dashboard
+\`\`\`typescript
+new Monitoring.Dashboard(stack, 'LogicalId', {
+  widgets: [
+    {
+      type: 'metric' | 'text' | 'alarm',
+      title?: string,
+      metricName?: string,
+      namespace?: string,
+      period?: number,
+      stat?: string,
+      markdown?: string,    // para type: 'text'
+    }
+  ],
+});
+\`\`\`
+
+### Logging.Stream \u2014 CloudWatch Log Group / Log Analytics / Cloud Logging
+\`\`\`typescript
+import { Stack, Logging } from '@iacmp/core';
+const stack = new Stack('nome');
+new Logging.Stream(stack, 'LogicalId', {
+  retentionDays?: number,    // padr\xE3o: 30
+  kmsKeyId?: string,
+  subscriptionFilters?: [
+    {
+      name: string,
+      filterPattern: string,
+      destinationArn: string,
+    }
+  ],
+});
+export default stack;
+\`\`\`
+
+---
+## CUSTOM \u2014 escape hatch para servi\xE7os fora do cat\xE1logo
+
+### Custom.Resource \u2014 qualquer recurso nativo do provider sem construct tipado
+
+Quando o usu\xE1rio pedir um servi\xE7o/recurso que n\xE3o tem construct dedicado no cat\xE1logo acima (ex: Secrets Manager rotation schedule, Static Web App, Pub/Sub topic avulso, qualquer recurso bem espec\xEDfico de um provider), N\xC3O recuse e N\xC3O diga apenas "n\xE3o existe construct para isso". Gere o recurso nativo real usando \`Custom.Resource\`, preenchendo APENAS a chave do formato de sa\xEDda relevante ao provider da stack:
+
+\`\`\`typescript
+import { Stack, Custom } from '@iacmp/core';
+const stack = new Stack('nome');
+
+new Custom.Resource(stack, 'LogicalId', {
+  description?: string,
+
+  // AWS (gera AWS::SecretsManager::RotationSchedule etc. no CloudFormation)
+  cloudformation?: { type: string, properties: Record<string, unknown> },
+
+  // Azure (gera Microsoft.Web/staticSites etc. no ARM Template)
+  arm?: { type: string, apiVersion: string, properties: Record<string, unknown>, sku?: Record<string, unknown>, kind?: string },
+
+  // GCP (gera pubsub.v1.topic etc. no Deployment Manager)
+  deploymentManager?: { type: string, properties: Record<string, unknown> },
+
+  // Terraform (gera resource "aws_secretsmanager_rotation_schedule" "LogicalId" {...})
+  terraform?: { type: string, body: Record<string, unknown> },
+});
+export default stack;
+\`\`\`
+
+Regras:
+1. Preencha apenas a(s) chave(s) do(s) formato(s) que a stack realmente vai sintetizar (normalmente CloudFormation+Terraform para AWS, ARM para Azure, Deployment Manager para GCP) \u2014 n\xE3o precisa preencher as 4 se a stack s\xF3 usa um provider.
+2. Use a sintaxe e os nomes de campo REAIS do formato nativo (ex: \`AWS::SecretsManager::RotationSchedule\` com PascalCase nas properties para CloudFormation; \`secret_id\`/\`rotation_rules\` em snake_case para Terraform). Voc\xEA j\xE1 conhece essas APIs \u2014 use esse conhecimento em vez de inventar campos gen\xE9ricos.
+3. Para referenciar outro recurso da mesma stack: no \`terraform.body\`, use a refer\xEAncia crua como string (ex: \`"aws_secretsmanager_secret.MySecret.id"\`) \u2014 ela \xE9 emitida sem aspas automaticamente quando cont\xE9m um ponto. No \`cloudformation.properties\`, use \`{ Ref: 'LogicalId' }\` ou \`{ 'Fn::GetAtt': [...] }\` normalmente.
+4. Isso \xE9 um escape hatch, n\xE3o o caminho padr\xE3o \u2014 se existe construct tipado para o que o usu\xE1rio pediu (Fn.Lambda, Database.SQL, etc.), use o construct tipado.
+
+---
+## Regra de integra\xE7\xE3o entre stacks
+Quando o usu\xE1rio pedir uma stack que depende de recursos de outra stack j\xE1 existente (ex: Lambda que l\xEA de um DynamoDB existente):
+- NUNCA recrie o recurso j\xE1 existente na nova stack
+- Referencie via vari\xE1vel de ambiente (ex: TABLE_NAME) usando o nome l\xF3gico do recurso
+- Mencione na "explanation" qual stack existente est\xE1 sendo referenciada e por qu\xEA
+
+## Tamanhos de inst\xE2ncia
+- \`small\` \u2192 t3.small / cache.t3.micro / B1s / e2-small
+- \`medium\` \u2192 t3.medium / cache.t3.medium / B2s / e2-medium
+- \`large\` \u2192 t3.large / cache.r6g.large / B4ms / e2-standard-4
+
+## Regras de gera\xE7\xE3o de c\xF3digo
+1. SEMPRE use apenas constructs do @iacmp/core listados acima \u2014 nunca invente propriedades extras
+2. SEMPRE exporte a stack como default: \`export default stack;\`
+3. Nomeie o arquivo em kebab-case com sufixo \`-stack.ts\` e coloque na subpasta correta:
+   - \`stacks/compute/\` \u2192 Compute.*, Fn.Lambda
+   - \`stacks/database/\` \u2192 Database.SQL, Database.DocumentDB, Database.DynamoDB, Cache.Redis, Cache.Memcached
+   - \`stacks/storage/\` \u2192 Storage.Bucket, Storage.FileSystem, Storage.Archive
+   - \`stacks/network/\` \u2192 Network.VPC, Network.Subnet, Network.SecurityGroup, Network.WAF, Network.LoadBalancer, Network.CDN, Network.Dns, Function.ApiGateway
+   - \`stacks/messaging/\` \u2192 Messaging.Queue, Messaging.Topic, Events.EventBridge
+   - \`stacks/workflow/\` \u2192 Workflow.StepFunctions
+   - \`stacks/policy/\` \u2192 Policy.IAM
+   - \`stacks/security/\` \u2192 Secret.Vault, Certificate.TLS
+   - \`stacks/monitoring/\` \u2192 Monitoring.Alarm, Monitoring.Dashboard, Logging.Stream
+4. N\xE3o adicione coment\xE1rios desnecess\xE1rios
+5. N\xE3o gere arquivos al\xE9m da stack (sem package.json, tsconfig.json, etc.) a menos que seja explicitamente pedido
+
+## Formato de resposta OBRIGAT\xD3RIO
+Responda SEMPRE com JSON puro, sem markdown, sem blocos de c\xF3digo, sem texto antes ou depois.
+Isso vale para QUALQUER tipo de mensagem \u2014 pergunta, explica\xE7\xE3o, erro, d\xFAvida, conversa.
+
+{
+  "explanation": "Descri\xE7\xE3o clara do que ser\xE1 criado/removido e por qu\xEA \u2014 ou a resposta \xE0 pergunta do usu\xE1rio",
+  "files": [],
+  "deletions": [],
+  "nextSteps": [],
+  "warnings": []
+}
+
+Exemplos de como responder perguntas conversacionais:
+
+Pergunta: "por que voc\xEA usou postgres em vez de oracle?"
+Resposta correta:
+{"explanation":"O construct Database.SQL suporta os engines 'mysql', 'postgres', 'mariadb', 'oracle' e 'sqlserver'. Se preferir Oracle, posso alterar o stack para usar engine: 'oracle'. No GCP, Oracle n\xE3o tem servi\xE7o gerenciado nativo e ser\xE1 provisionado como PostgreSQL (AlloyDB-compatible); nas outras clouds (AWS e Azure) o Oracle \xE9 nativo.","files":[],"deletions":[],"nextSteps":[],"warnings":[]}
+
+Pergunta: "o que \xE9 um NAT Gateway?"
+Resposta correta:
+{"explanation":"NAT Gateway permite que inst\xE2ncias em subnets privadas acessem a internet sem serem acess\xEDveis de fora. No @iacmp/core, ao criar uma Network.VPC, subnets privadas recebem NAT Gateway automaticamente quando maxAzs > 0.","files":[],"deletions":[],"nextSteps":[],"warnings":[]}
+
+- \`files\`: arquivos a criar ou modificar \u2014 VAZIO quando for s\xF3 uma resposta explicativa
+- \`deletions\`: caminhos de arquivos a REMOVER. O CLI remove o .ts e o synth-out correspondente automaticamente, e limpa refer\xEAncias em outros arquivos.
+- \`warnings\`: alertas sobre custo alto, breaking changes ou limita\xE7\xF5es
+
+## Remo\xE7\xE3o de stacks
+Quando o usu\xE1rio pedir para remover uma stack:
+- Use o campo \`deletions\` com o caminho exato do arquivo .ts
+- Deixe \`files\` vazio se for s\xF3 remo\xE7\xE3o
+- NUNCA oriente o usu\xE1rio a rodar \`rm\` ou \`iacmp destroy\` manualmente \u2014 o CLI cuida disso automaticamente
+- N\xC3O inclua \`iacmp destroy\` nos \`nextSteps\`
+
+## Acesso ao projeto \u2014 REGRAS CR\xCDTICAS
+O CLI injeta automaticamente o contexto completo do projeto neste prompt, incluindo o conte\xFAdo de todos os arquivos em stacks/. Isso significa:
+
+1. NUNCA pe\xE7a ao usu\xE1rio para colar c\xF3digo \u2014 voc\xEA j\xE1 tem acesso a todo o conte\xFAdo dos arquivos
+2. NUNCA sugira comandos como "cat stacks/arquivo.ts e cole aqui"
+3. Se o usu\xE1rio reportar um erro em um arquivo, leia o conte\xFAdo dispon\xEDvel no contexto abaixo e corrija diretamente
+4. Se um arquivo n\xE3o aparecer no contexto, significa que ainda n\xE3o existe \u2014 crie-o
+5. Para corrigir erros: gere o arquivo corrigido completo no campo "files" do JSON de resposta
+6. Se a se\xE7\xE3o "Stacks existentes" aparecer abaixo com arquivos listados, voc\xEA EST\xC1 em modo de projeto \u2014 NUNCA diga "modo standalone", NUNCA diga que n\xE3o tem acesso aos arquivos, NUNCA pe\xE7a ao usu\xE1rio para descrever a estrutura do projeto do zero
+
+## Modifica\xE7\xE3o de stacks existentes \u2014 REGRAS INVIOL\xC1VEIS
+
+Antes de gerar qualquer arquivo, leia a se\xE7\xE3o "Stacks existentes" no contexto do projeto.
+
+6. Se o usu\xE1rio pedir para MOVER um recurso (ex: "coloca na stack do api gateway"), identifique qual arquivo j\xE1 existe para aquela stack e modifique-o \u2014 NUNCA crie um arquivo novo com outro nome
+7. Se o usu\xE1rio pedir para ADICIONAR um recurso a uma stack existente, gere o arquivo existente com o novo recurso inclu\xEDdo
+8. Se j\xE1 existir um arquivo de ApiGateway, Lambda, Database etc., qualquer mudan\xE7a nesse tipo de recurso vai naquele arquivo \u2014 n\xE3o em um arquivo novo
+9. O caminho do arquivo no campo "path" deve ser ID\xCANTICO ao caminho listado em "Stacks existentes" \u2014 nunca invente um caminho diferente para um arquivo que j\xE1 existe
+10. Quando houver d\xFAvida sobre qual arquivo usar, prefira o que j\xE1 existe a criar um novo
+
+## Quando o usu\xE1rio discorda ou corrige algo que voc\xEA gerou
+
+1. Releia a mensagem anterior sua antes de responder \u2014 se voc\xEA concordou com o ponto do usu\xE1rio, a resposta TEM que conter uma mudan\xE7a real em "files" ou "deletions", nunca apenas um texto reafirmando que "est\xE1 adequado" ou "n\xE3o h\xE1 nada a corrigir"
+2. NUNCA d\xEA uma explica\xE7\xE3o que se contradiz dentro do mesmo texto (ex: dizer que algo "deveria ser diferente" e na frase seguinte dizer que "est\xE1 correto como est\xE1") \u2014 decida um lado e aja de acordo
+3. Se voc\xEA concorda que havia um problema, gere o arquivo corrigido em "files". Se voc\xEA discorda do usu\xE1rio, explique objetivamente o motivo t\xE9cnico da discord\xE2ncia e n\xE3o gere nenhum arquivo \u2014 mas nunca as duas coisas ao mesmo tempo
+4. Se n\xE3o tiver certeza de como resolver o que o usu\xE1rio pediu (ex: falta um construct no @iacmp/core para a solu\xE7\xE3o ideal), diga isso explicitamente e pergunte como proceder, em vez de alegar que o estado atual j\xE1 est\xE1 correto
+
+## Contexto do projeto atual
+{PROJECT_CONTEXT}`;
+    function buildSystemPrompt2(projectContext) {
+      return exports2.SYSTEM_PROMPT_TEMPLATE.replace("{PROJECT_CONTEXT}", projectContext);
+    }
+    exports2.SYSTEM_PROMPT = exports2.SYSTEM_PROMPT_TEMPLATE.replace("{PROJECT_CONTEXT}", "Nenhum projeto carregado \u2014 modo standalone.");
+  }
+});
+
+// ../ai/dist/providers/retry.js
+var require_retry = __commonJS({
+  "../ai/dist/providers/retry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.withRetry = withRetry;
+    function isRetryable(err) {
+      if (err?.noRetry)
+        return false;
+      const status = err?.status;
+      if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504)
+        return true;
+      const code = err?.code;
+      if (code === "ECONNRESET" || code === "ETIMEDOUT")
+        return true;
+      return false;
+    }
+    async function withRetry(fn, maxAttempts = 3) {
+      let lastErr;
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+          return await fn();
+        } catch (err) {
+          lastErr = err;
+          if (attempt === maxAttempts || !isRetryable(err))
+            throw err;
+          const delayMs = 500 * 2 ** (attempt - 1);
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+      }
+      throw lastErr;
+    }
+  }
+});
+
+// ../ai/dist/providers/anthropic.js
+var require_anthropic = __commonJS({
+  "../ai/dist/providers/anthropic.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AnthropicProvider = void 0;
+    var sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+    var system_prompt_1 = require_system_prompt();
+    var retry_1 = require_retry();
+    var AnthropicProvider2 = class {
+      name = "anthropic";
+      client;
+      constructor(apiKey) {
+        this.client = new sdk_1.default({ apiKey });
+      }
+      async chat(messages) {
+        const filtered = messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }));
+        const response = await (0, retry_1.withRetry)(() => this.client.messages.create({
+          model: "claude-sonnet-4-6",
+          max_tokens: 8192,
+          system: system_prompt_1.SYSTEM_PROMPT,
+          messages: filtered
+        }));
+        const block = response.content[0];
+        return {
+          content: block.type === "text" ? block.text : "",
+          usage: {
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens
+          }
+        };
+      }
+      async stream(messages, onChunk) {
+        const filtered = messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }));
+        let emittedAny = false;
+        await (0, retry_1.withRetry)(async () => {
+          if (emittedAny)
+            throw Object.assign(new Error("stream interrompido ap\xF3s in\xEDcio \u2014 sem retry"), { noRetry: true });
+          const stream = this.client.messages.stream({
+            model: "claude-sonnet-4-6",
+            max_tokens: 8192,
+            system: system_prompt_1.SYSTEM_PROMPT,
+            messages: filtered
+          });
+          for await (const chunk of stream) {
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+              emittedAny = true;
+              onChunk(chunk.delta.text);
+            }
+          }
+        });
+      }
+    };
+    exports2.AnthropicProvider = AnthropicProvider2;
+  }
+});
+
+// ../ai/dist/providers/copilot.js
+var require_copilot = __commonJS({
+  "../ai/dist/providers/copilot.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CopilotProvider = void 0;
+    var system_prompt_1 = require_system_prompt();
+    var retry_1 = require_retry();
+    var COPILOT_ENDPOINT = "https://api.githubcopilot.com/chat/completions";
+    var CopilotProvider2 = class {
+      name = "copilot";
+      token;
+      constructor(token) {
+        this.token = token;
+      }
+      buildMessages(messages) {
+        const result = [
+          { role: "system", content: system_prompt_1.SYSTEM_PROMPT }
+        ];
+        for (const m of messages) {
+          if (m.role !== "system") {
+            result.push({ role: m.role, content: m.content });
+          }
+        }
+        return result;
+      }
+      async chat(messages) {
+        return (0, retry_1.withRetry)(async () => {
+          const response = await fetch(COPILOT_ENDPOINT, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              "Copilot-Integration-Id": "iacmp-cli"
+            },
+            body: JSON.stringify({
+              model: "gpt-4o",
+              messages: this.buildMessages(messages),
+              max_tokens: 8192
+            })
+          });
+          if (!response.ok) {
+            const text = await response.text();
+            throw Object.assign(new Error(`Copilot API error ${response.status}: ${text}`), { status: response.status });
+          }
+          const data = await response.json();
+          return {
+            content: data.choices[0].message.content,
+            usage: {
+              inputTokens: data.usage.prompt_tokens,
+              outputTokens: data.usage.completion_tokens
+            }
+          };
+        });
+      }
+      async stream(messages, onChunk) {
+        let emittedAny = false;
+        await (0, retry_1.withRetry)(async () => {
+          if (emittedAny)
+            throw Object.assign(new Error("stream interrompido ap\xF3s in\xEDcio \u2014 sem retry"), { noRetry: true });
+          const response = await fetch(COPILOT_ENDPOINT, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              "Copilot-Integration-Id": "iacmp-cli"
+            },
+            body: JSON.stringify({
+              model: "gpt-4o",
+              messages: this.buildMessages(messages),
+              max_tokens: 8192,
+              stream: true
+            })
+          });
+          if (!response.ok) {
+            const text = await response.text();
+            throw Object.assign(new Error(`Copilot API error ${response.status}: ${text}`), { status: response.status });
+          }
+          if (!response.body) {
+            throw new Error("Copilot: response body vazio");
+          }
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            const raw = decoder.decode(value);
+            const lines = raw.split("\n").filter((l) => l.startsWith("data: "));
+            for (const line of lines) {
+              const json = line.slice(6).trim();
+              if (json === "[DONE]")
+                return;
+              try {
+                const parsed = JSON.parse(json);
+                const text = parsed.choices?.[0]?.delta?.content ?? "";
+                if (text) {
+                  emittedAny = true;
+                  onChunk(text);
+                }
+              } catch {
+              }
+            }
+          }
+        });
+      }
+    };
+    exports2.CopilotProvider = CopilotProvider2;
+  }
+});
+
+// ../ai/dist/parser/code-extractor.js
+var require_code_extractor = __commonJS({
+  "../ai/dist/parser/code-extractor.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MAX_FILE_BYTES = exports2.MAX_DELETIONS = exports2.MAX_FILES = void 0;
+    exports2.extractResponse = extractResponse2;
+    exports2.MAX_FILES = 50;
+    exports2.MAX_DELETIONS = 100;
+    exports2.MAX_FILE_BYTES = 256 * 1024;
+    function extractResponse2(raw) {
+      const trimmed = raw.trim();
+      const direct = tryParse(trimmed);
+      if (direct)
+        return validate(direct);
+      const codeBlock = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/);
+      if (codeBlock) {
+        const parsed = tryParse(codeBlock[1].trim());
+        if (parsed)
+          return validate(parsed);
+      }
+      const firstBrace = trimmed.indexOf("{");
+      const lastBrace = trimmed.lastIndexOf("}");
+      if (firstBrace !== -1 && lastBrace > firstBrace) {
+        const slice = trimmed.slice(firstBrace, lastBrace + 1);
+        const parsed = tryParse(slice);
+        if (parsed)
+          return validate(parsed);
+      }
+      throw new Error("N\xE3o foi poss\xEDvel extrair JSON do response da IA.\nResponse recebido:\n" + trimmed.slice(0, 300) + (trimmed.length > 300 ? "..." : ""));
+    }
+    function tryParse(text) {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return null;
+      }
+    }
+    function validate(obj) {
+      if (typeof obj !== "object" || obj === null) {
+        throw new Error("Response da IA n\xE3o \xE9 um objeto JSON v\xE1lido.");
+      }
+      const o = obj;
+      if (typeof o["explanation"] !== "string") {
+        throw new Error('Response da IA est\xE1 faltando o campo "explanation" (string).');
+      }
+      if (!Array.isArray(o["files"])) {
+        throw new Error('Response da IA est\xE1 faltando o campo "files" (array).');
+      }
+      const rawFiles = o["files"];
+      if (rawFiles.length > exports2.MAX_FILES) {
+        throw new Error(`Response da IA excede o limite de arquivos: ${rawFiles.length} > ${exports2.MAX_FILES}. Reduza o escopo da requisi\xE7\xE3o.`);
+      }
+      const files = [];
+      for (const f of rawFiles) {
+        if (typeof f !== "object" || f === null) {
+          throw new Error('Cada item em "files" deve ser um objeto com "path" e "content".');
+        }
+        const file = f;
+        if (typeof file["path"] !== "string" || typeof file["content"] !== "string") {
+          throw new Error('Cada arquivo deve ter "path" (string) e "content" (string).');
+        }
+        const byteLen = Buffer.byteLength(file["content"], "utf-8");
+        if (byteLen > exports2.MAX_FILE_BYTES) {
+          throw new Error(`Arquivo "${file["path"]}" excede o limite de tamanho: ${byteLen} bytes > ${exports2.MAX_FILE_BYTES} bytes. Divida o conte\xFAdo em arquivos menores.`);
+        }
+        files.push({ path: file["path"], content: file["content"] });
+      }
+      const rawDeletions = Array.isArray(o["deletions"]) ? o["deletions"].filter((s) => typeof s === "string") : [];
+      if (rawDeletions.length > exports2.MAX_DELETIONS) {
+        throw new Error(`Response da IA excede o limite de remo\xE7\xF5es: ${rawDeletions.length} > ${exports2.MAX_DELETIONS}. Reduza o escopo da requisi\xE7\xE3o.`);
+      }
+      return {
+        explanation: o["explanation"],
+        files,
+        deletions: rawDeletions,
+        nextSteps: Array.isArray(o["nextSteps"]) ? o["nextSteps"].filter((s) => typeof s === "string") : [],
+        warnings: Array.isArray(o["warnings"]) ? o["warnings"].filter((s) => typeof s === "string") : []
+      };
+    }
+  }
+});
+
+// ../ai/dist/parser/validator.js
+var require_validator = __commonJS({
+  "../ai/dist/parser/validator.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.validateTypeScript = validateTypeScript2;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var os = __importStar(require("os"));
+    var child_process_1 = require("child_process");
+    function validateTypeScript2(files, projectDir) {
+      const tmpDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "iacmp-validate-"));
+      try {
+        for (const file of files) {
+          const filePath = path2.join(tmpDir, path2.basename(file.path));
+          fs2.writeFileSync(filePath, file.content, "utf-8");
+        }
+        const coreTypesPath = (function findCoreTypes() {
+          const candidates2 = [
+            // monorepo local (dev)
+            path2.resolve(__dirname, "..", "..", "..", "core", "dist"),
+            // node_modules do CLI instalado globalmente
+            path2.resolve(__dirname, "..", "..", "node_modules", "@iacmp", "core", "dist"),
+            // node_modules do projeto do usuário
+            path2.join(projectDir, "node_modules", "@iacmp", "core", "dist")
+          ];
+          for (const c of candidates2) {
+            if (fs2.existsSync(path2.join(c, "index.d.ts")))
+              return c;
+          }
+          return null;
+        })();
+        const tsconfigPaths = {};
+        if (coreTypesPath) {
+          tsconfigPaths["@iacmp/core"] = [path2.join(coreTypesPath, "index.d.ts")];
+          tsconfigPaths["@iacmp/core/*"] = [path2.join(coreTypesPath, "*")];
+        }
+        const tsconfig = {
+          compilerOptions: {
+            target: "ES2022",
+            module: "commonjs",
+            moduleResolution: "node",
+            esModuleInterop: true,
+            strict: false,
+            skipLibCheck: true,
+            noEmit: true,
+            baseUrl: "/",
+            paths: tsconfigPaths
+          },
+          include: [path2.join(tmpDir, "*.ts")]
+        };
+        fs2.writeFileSync(path2.join(tmpDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2), "utf-8");
+        const candidates = [
+          path2.join(projectDir, "node_modules", ".bin", "tsc"),
+          path2.resolve(__dirname, "..", "..", "node_modules", ".bin", "tsc"),
+          path2.resolve(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "tsc")
+        ];
+        const tscPath = candidates.find((c) => fs2.existsSync(c));
+        if (!tscPath) {
+          return { valid: true, errors: [] };
+        }
+        (0, child_process_1.execSync)(`${tscPath} --noEmit --project ${path2.join(tmpDir, "tsconfig.json")}`, {
+          cwd: tmpDir,
+          stdio: "pipe"
+        });
+        return { valid: true, errors: [] };
+      } catch (err) {
+        const error = err;
+        if (error.code === "ENOENT") {
+          return { valid: true, errors: [] };
+        }
+        const output = (error.stdout?.toString() ?? "") + (error.stderr?.toString() ?? "");
+        const errors = output.split("\n").filter((l) => l.trim().length > 0).slice(0, 20);
+        return { valid: false, errors };
+      } finally {
+        try {
+          fs2.rmSync(tmpDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+  }
+});
+
+// ../ai/dist/chat/session.js
+var require_session = __commonJS({
+  "../ai/dist/chat/session.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ChatSession = void 0;
+    var ChatSession2 = class {
+      messages = [];
+      addUserMessage(content) {
+        this.messages.push({ role: "user", content });
+      }
+      addAssistantMessage(content) {
+        this.messages.push({ role: "assistant", content });
+      }
+      getMessages() {
+        return [...this.messages];
+      }
+      removeLast() {
+        this.messages.pop();
+      }
+      clear() {
+        this.messages = [];
+      }
+    };
+    exports2.ChatSession = ChatSession2;
+  }
+});
+
+// ../ai/dist/chat/renderer.js
+var require_renderer = __commonJS({
+  "../ai/dist/chat/renderer.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.printThinking = printThinking;
+    exports2.stopThinking = stopThinking;
+    exports2.printExplanation = printExplanation2;
+    exports2.printWarnings = printWarnings2;
+    exports2.printNextSteps = printNextSteps2;
+    exports2.printStreamChunk = printStreamChunk;
+    var chalk_1 = __importDefault(require("chalk"));
+    var ora_1 = __importDefault(require("ora"));
+    var activeSpinner = null;
+    function printThinking() {
+      activeSpinner = (0, ora_1.default)({ text: "Gerando stack...", color: "cyan" }).start();
+      return activeSpinner;
+    }
+    function stopThinking() {
+      if (activeSpinner) {
+        activeSpinner.stop();
+        activeSpinner = null;
+      }
+    }
+    function printExplanation2(text) {
+      console.log("\n" + chalk_1.default.cyan.bold("\u2500\u2500\u2500 Explica\xE7\xE3o \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk_1.default.white(text));
+      console.log(chalk_1.default.cyan("\u2500".repeat(50)));
+    }
+    function printWarnings2(warnings) {
+      if (warnings.length === 0)
+        return;
+      console.log("\n" + chalk_1.default.yellow.bold("Avisos:"));
+      for (const w of warnings) {
+        console.log(chalk_1.default.yellow(`  ! ${w}`));
+      }
+    }
+    function printNextSteps2(steps) {
+      if (steps.length === 0)
+        return;
+      console.log("\n" + chalk_1.default.dim("Pr\xF3ximos passos:"));
+      for (const s of steps) {
+        console.log(chalk_1.default.dim(`  $ ${s}`));
+      }
+    }
+    function printStreamChunk(chunk) {
+      process.stdout.write(chunk);
+    }
+  }
+});
+
+// ../ai/dist/tools/diff-renderer.js
+var require_diff_renderer = __commonJS({
+  "../ai/dist/tools/diff-renderer.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.renderAndConfirm = renderAndConfirm;
+    var chalk_1 = __importDefault(require("chalk"));
+    var DiffLib = __importStar(require("diff"));
+    async function renderAndConfirm(diffs, ask2) {
+      console.log("");
+      for (const file of diffs) {
+        const isNew = file.oldContent === null;
+        const label = isNew ? `  ${chalk_1.default.bold(file.path)}  ${chalk_1.default.blue("[novo]")}` : `  ${chalk_1.default.bold(file.path)}  ${chalk_1.default.yellow("[modificado]")}`;
+        console.log("\n" + label);
+        console.log(chalk_1.default.dim("\u2500".repeat(62)));
+        if (isNew) {
+          for (const line of file.newContent.split("\n")) {
+            console.log(chalk_1.default.green(`+ ${line}`));
+          }
+        } else {
+          const changes = DiffLib.diffLines(file.oldContent, file.newContent);
+          for (const change of changes) {
+            const lines = change.value.split("\n");
+            if (lines[lines.length - 1] === "")
+              lines.pop();
+            for (const line of lines) {
+              if (change.added) {
+                console.log(chalk_1.default.green(`+ ${line}`));
+              } else if (change.removed) {
+                console.log(chalk_1.default.red(`- ${line}`));
+              } else {
+                console.log(`  ${line}`);
+              }
+            }
+          }
+        }
+        console.log(chalk_1.default.dim("\u2500".repeat(62)));
+      }
+      const newCount = diffs.filter((d) => d.oldContent === null).length;
+      const modCount = diffs.filter((d) => d.oldContent !== null).length;
+      const parts = [];
+      if (modCount > 0)
+        parts.push(`${modCount} modificado(s)`);
+      if (newCount > 0)
+        parts.push(`${newCount} novo(s)`);
+      console.log(chalk_1.default.dim("\n  " + parts.join(" \xB7 ") + "\n"));
+      const answer = await ask2("Aplicar mudan\xE7as? [y/n] ");
+      return answer.toLowerCase() === "y";
+    }
+  }
+});
+
+// ../ai/dist/tools/safe-path.js
+var require_safe_path = __commonJS({
+  "../ai/dist/tools/safe-path.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.NATIVE_PROVIDERS = void 0;
+    exports2.safeJoin = safeJoin;
+    exports2.isWithin = isWithin;
+    exports2.errMessage = errMessage;
+    exports2.assertValidStackName = assertValidStackName;
+    exports2.assertValidProvider = assertValidProvider;
+    var path2 = __importStar(require("path"));
+    exports2.NATIVE_PROVIDERS = ["aws", "azure", "gcp", "terraform"];
+    var STACK_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+    var PROVIDER_PATTERN = /^[a-z0-9_-]+$/;
+    function safeJoin(baseDir, relativePath) {
+      if (typeof relativePath !== "string" || relativePath.length === 0) {
+        throw new Error("Caminho vazio ou inv\xE1lido recebido.");
+      }
+      if (path2.isAbsolute(relativePath)) {
+        throw new Error(`Caminho absoluto rejeitado por seguran\xE7a: "${relativePath}". Use sempre caminhos relativos ao projeto.`);
+      }
+      const baseResolved = path2.resolve(baseDir);
+      const fullResolved = path2.resolve(baseResolved, relativePath);
+      if (fullResolved !== baseResolved && !fullResolved.startsWith(baseResolved + path2.sep)) {
+        throw new Error(`Caminho fora do diret\xF3rio do projeto rejeitado: "${relativePath}" (resolveria para "${fullResolved}"). Path traversal n\xE3o \xE9 permitido.`);
+      }
+      return fullResolved;
+    }
+    function isWithin(baseDir, candidatePath) {
+      try {
+        const baseResolved = path2.resolve(baseDir);
+        const fullResolved = path2.isAbsolute(candidatePath) ? path2.resolve(candidatePath) : path2.resolve(baseResolved, candidatePath);
+        return fullResolved === baseResolved || fullResolved.startsWith(baseResolved + path2.sep);
+      } catch {
+        return false;
+      }
+    }
+    function errMessage(err) {
+      if (err instanceof Error)
+        return err.message;
+      if (typeof err === "string")
+        return err;
+      if (err === null)
+        return "null";
+      if (err === void 0)
+        return "undefined";
+      if (typeof err === "object" && "message" in err) {
+        const m = err.message;
+        if (typeof m === "string")
+          return m;
+      }
+      try {
+        const s = JSON.stringify(err);
+        return typeof s === "string" ? s : String(err);
+      } catch {
+        return String(err);
+      }
+    }
+    function assertValidStackName(stackName) {
+      if (typeof stackName !== "string" || !STACK_NAME_PATTERN.test(stackName)) {
+        throw new Error(`Nome de stack inv\xE1lido: "${stackName}". Use apenas letras, n\xFAmeros, h\xEDfen e underscore (regex: /^[A-Za-z0-9_-]+$/).`);
+      }
+    }
+    function assertValidProvider(provider, allowlist) {
+      if (typeof provider !== "string" || !PROVIDER_PATTERN.test(provider)) {
+        throw new Error(`Nome de provider inv\xE1lido: "${provider}". Use apenas letras min\xFAsculas, n\xFAmeros, h\xEDfen e underscore.`);
+      }
+      const allowed = allowlist ?? exports2.NATIVE_PROVIDERS;
+      if (!allowed.includes(provider)) {
+        throw new Error(`Provider "${provider}" n\xE3o permitido. Allowlist: ${allowed.join(", ")}.`);
+      }
+    }
+  }
+});
+
+// ../ai/dist/tools/file-writer.js
+var require_file_writer = __commonJS({
+  "../ai/dist/tools/file-writer.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.writeGeneratedFiles = writeGeneratedFiles2;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var chalk_1 = __importDefault(require("chalk"));
+    var diff_renderer_1 = require_diff_renderer();
+    var safe_path_1 = require_safe_path();
+    async function writeGeneratedFiles2(files, projectDir, dryRun2, ask2) {
+      const validated = [];
+      for (const file of files) {
+        const fullPath = (0, safe_path_1.safeJoin)(projectDir, file.path);
+        validated.push({ file, fullPath });
+      }
+      if (dryRun2) {
+        console.log(chalk_1.default.dim("\n[dry-run] Arquivos que seriam gerados:\n"));
+        for (const { file } of validated) {
+          console.log(chalk_1.default.cyan(`  ${file.path}`));
+          console.log(chalk_1.default.dim("\u2500".repeat(62)));
+          for (const line of file.content.split("\n")) {
+            console.log(chalk_1.default.green(`+ ${line}`));
+          }
+          console.log(chalk_1.default.dim("\u2500".repeat(62)));
+          console.log("");
+        }
+        console.log(chalk_1.default.dim("[dry-run] Nenhum arquivo foi salvo.\n"));
+        return;
+      }
+      const diffs = validated.map(({ file, fullPath }) => {
+        let oldContent = null;
+        try {
+          oldContent = fs2.readFileSync(fullPath, "utf-8");
+        } catch {
+        }
+        return { path: file.path, oldContent, newContent: file.content };
+      });
+      const confirmed = await (0, diff_renderer_1.renderAndConfirm)(diffs, ask2);
+      if (!confirmed) {
+        console.log(chalk_1.default.dim("\n  Opera\xE7\xE3o cancelada. Nenhum arquivo foi alterado.\n"));
+        return;
+      }
+      for (const { file, fullPath } of validated) {
+        fs2.mkdirSync(path2.dirname(fullPath), { recursive: true });
+        fs2.writeFileSync(fullPath, file.content, "utf-8");
+        console.log(chalk_1.default.green(`  \u2713 ${file.path}`));
+      }
+      console.log("");
+    }
+  }
+});
+
+// ../ai/dist/tools/file-deleter.js
+var require_file_deleter = __commonJS({
+  "../ai/dist/tools/file-deleter.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.deleteFiles = deleteFiles2;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var cp = __importStar(require("child_process"));
+    var chalk_1 = __importDefault(require("chalk"));
+    var safe_path_1 = require_safe_path();
+    function synthOutPaths(filePath, projectDir) {
+      const basename = path2.basename(filePath).replace(/\.(ts|js)$/, "");
+      const root = path2.join(projectDir, "synth-out");
+      if (!fs2.existsSync(root))
+        return [];
+      const found = [];
+      const check = (dir) => {
+        for (const ext of [".json", ".tf"]) {
+          const c = path2.join(dir, `${basename}${ext}`);
+          if (fs2.existsSync(c) && fs2.statSync(c).isFile())
+            found.push(c);
+        }
+      };
+      check(root);
+      try {
+        for (const entry of fs2.readdirSync(root, { withFileTypes: true })) {
+          if (entry.isDirectory())
+            check(path2.join(root, entry.name));
+        }
+      } catch {
+      }
+      return found;
+    }
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function removeReferences(stackName, projectDir) {
+      const modified = [];
+      const stacksDir = path2.join(projectDir, "stacks");
+      if (!fs2.existsSync(stacksDir))
+        return modified;
+      const escaped = escapeRegex(stackName);
+      const findTs = (dir) => {
+        const entries = fs2.readdirSync(dir, { withFileTypes: true });
+        const files = [];
+        for (const e of entries) {
+          const full = path2.join(dir, e.name);
+          if (e.isDirectory())
+            files.push(...findTs(full));
+          else if (e.name.endsWith(".ts"))
+            files.push(full);
+        }
+        return files;
+      };
+      for (const file of findTs(stacksDir)) {
+        const content = fs2.readFileSync(file, "utf-8");
+        const pattern = new RegExp(`(import[^;]*from\\s*['"][^'"]*${escaped}[^'"]*['"]\\s*;?\\n?)|(.*${escaped}.*)`, "g");
+        if (pattern.test(content)) {
+          const cleaned = content.replace(pattern, "").replace(/\n{3,}/g, "\n\n").trim() + "\n";
+          if (cleaned !== content) {
+            fs2.writeFileSync(file, cleaned, "utf-8");
+            modified.push(path2.relative(projectDir, file));
+          }
+        }
+      }
+      return modified;
+    }
+    function resolveCliEntrypoint() {
+      try {
+        return require.resolve("iacmp/bin/run.js");
+      } catch {
+        return null;
+      }
+    }
+    async function deleteFiles2(deletions, projectDir, iacProvider2, ask2, options) {
+      (0, safe_path_1.assertValidProvider)(iacProvider2, options?.providerAllowlist);
+      const stackFiles = deletions.filter((f) => f.match(/\.(ts|js)$/) && f.includes("stacks/"));
+      const otherFiles = deletions.filter((f) => !stackFiles.includes(f));
+      const seen = /* @__PURE__ */ new Set();
+      const allToDelete = [];
+      const synthOuts = [];
+      const add = (rel, full) => {
+        if (!seen.has(full)) {
+          seen.add(full);
+          allToDelete.push({ rel, full });
+        }
+      };
+      for (const filePath of stackFiles) {
+        let full;
+        try {
+          full = (0, safe_path_1.safeJoin)(projectDir, filePath);
+        } catch (err) {
+          console.log(chalk_1.default.yellow(`  ! ${(0, safe_path_1.errMessage)(err)} \u2014 ignorando ${filePath}`));
+          continue;
+        }
+        if (fs2.existsSync(full))
+          add(filePath, full);
+        for (const synthOut of synthOutPaths(filePath, projectDir)) {
+          const rel = path2.relative(projectDir, synthOut);
+          add(rel, synthOut);
+          if (!synthOuts.includes(rel))
+            synthOuts.push(rel);
+        }
+      }
+      for (const filePath of otherFiles) {
+        let full;
+        try {
+          full = (0, safe_path_1.safeJoin)(projectDir, filePath);
+        } catch (err) {
+          console.log(chalk_1.default.yellow(`  ! ${(0, safe_path_1.errMessage)(err)} \u2014 ignorando ${filePath}`));
+          continue;
+        }
+        if (fs2.existsSync(full))
+          add(filePath, full);
+      }
+      if (allToDelete.length === 0) {
+        console.log(chalk_1.default.dim("\n  Nenhum arquivo encontrado para remover.\n"));
+        return;
+      }
+      console.log("");
+      console.log(chalk_1.default.red.bold("  Arquivos que ser\xE3o removidos:"));
+      for (const f of allToDelete) {
+        console.log(chalk_1.default.red(`  - ${f.rel}`));
+      }
+      console.log("");
+      if (synthOuts.length > 0) {
+        const runDestroy = await ask2("Rodar `iacmp destroy` para remover os recursos na nuvem antes de apagar? [y/n] ");
+        if (runDestroy.toLowerCase() === "y") {
+          const cliEntry = resolveCliEntrypoint();
+          for (const synthOut of synthOuts) {
+            const stackName = path2.basename(synthOut).replace(/\.(json|tf)$/, "");
+            try {
+              (0, safe_path_1.assertValidStackName)(stackName);
+            } catch (err) {
+              console.log(chalk_1.default.yellow(`  ! ${(0, safe_path_1.errMessage)(err)} \u2014 pulando destroy de ${stackName}`));
+              continue;
+            }
+            console.log(chalk_1.default.dim(`
+  Rodando destroy para ${stackName}...`));
+            try {
+              if (cliEntry) {
+                cp.execFileSync(process.execPath, [cliEntry, "destroy", "--stack", stackName, "--provider", iacProvider2, "--force"], { cwd: projectDir, stdio: "inherit" });
+              } else {
+                cp.execFileSync("npx", ["iacmp", "destroy", "--stack", stackName, "--provider", iacProvider2, "--force"], { cwd: projectDir, stdio: "inherit" });
+              }
+            } catch {
+              console.log(chalk_1.default.yellow(`  ! destroy falhou para ${stackName} \u2014 continuando com remo\xE7\xE3o local`));
+            }
+          }
+        }
+      }
+      const confirm = await ask2("\nApagar arquivos locais? [y/n] ");
+      if (confirm.toLowerCase() !== "y") {
+        console.log(chalk_1.default.dim("  Remo\xE7\xE3o cancelada.\n"));
+        return;
+      }
+      for (const { rel, full } of allToDelete) {
+        try {
+          fs2.rmSync(full, { force: true });
+          console.log(chalk_1.default.red(`  \u2717 ${rel}`));
+        } catch {
+          console.log(chalk_1.default.yellow(`  ! N\xE3o foi poss\xEDvel remover: ${rel}`));
+        }
+      }
+      for (const filePath of stackFiles) {
+        const stackName = path2.basename(filePath).replace(/\.(ts|js)$/, "");
+        const modified = removeReferences(stackName, projectDir);
+        for (const f of modified) {
+          console.log(chalk_1.default.yellow(`  ~ refer\xEAncias removidas em: ${f}`));
+        }
+      }
+      console.log("");
+    }
+  }
+});
+
+// ../ai/dist/tools/synth-runner.js
+var require_synth_runner = __commonJS({
+  "../ai/dist/tools/synth-runner.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.runSynth = runSynth2;
+    var child_process_1 = require("child_process");
+    var chalk_1 = __importDefault(require("chalk"));
+    var safe_path_1 = require_safe_path();
+    function runSynth2(projectDir, provider, options) {
+      try {
+        (0, safe_path_1.assertValidProvider)(provider, options?.providerAllowlist);
+      } catch (err) {
+        console.error(chalk_1.default.red("\nProvider inv\xE1lido para synth:"));
+        console.error(chalk_1.default.red((0, safe_path_1.errMessage)(err)));
+        return false;
+      }
+      let cliEntry = null;
+      try {
+        cliEntry = require.resolve("iacmp/bin/run.js");
+      } catch {
+        cliEntry = null;
+      }
+      try {
+        if (cliEntry) {
+          (0, child_process_1.execFileSync)(process.execPath, [cliEntry, "synth", "--provider", provider], { cwd: projectDir, stdio: "inherit" });
+        } else {
+          (0, child_process_1.execFileSync)("npx", ["iacmp", "synth", "--provider", provider], { cwd: projectDir, stdio: "inherit" });
+        }
+        return true;
+      } catch (err) {
+        const error = err;
+        console.error(chalk_1.default.red("\nErro ao executar iacmp synth:"));
+        if (error.stderr) {
+          console.error(chalk_1.default.red(error.stderr.toString()));
+        }
+        return false;
+      }
+    }
+  }
+});
+
+// ../ai/dist/rag/chunker.js
+var require_chunker = __commonJS({
+  "../ai/dist/rag/chunker.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.chunkStackFile = chunkStackFile;
+    exports2.chunkIacmpDocs = chunkIacmpDocs;
+    exports2.chunkKnowledgeFile = chunkKnowledgeFile;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    function chunkStackFile(filePath, projectDir) {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      const rel = path2.relative(projectDir, filePath);
+      const stackName = path2.basename(filePath, ".ts");
+      const chunks = [];
+      const constructRegex = /new\s+([\w]+\.[\w]+)\s*\(\s*\w+\s*,\s*'([\w-]+)'\s*,\s*(\{[\s\S]*?\})\s*\)/g;
+      let match;
+      let index = 0;
+      while ((match = constructRegex.exec(content)) !== null) {
+        const constructType = match[1];
+        const constructId = match[2];
+        const propsRaw = match[3];
+        chunks.push({
+          id: `stack:${rel}:${constructId}`,
+          content: `[construct] ${constructType} "${constructId}" em ${rel}
+${propsRaw}`,
+          metadata: {
+            source: "project-stack",
+            file: rel,
+            stackName,
+            constructType,
+            constructId
+          }
+        });
+        index++;
+      }
+      if (chunks.length === 0 && content.trim().length > 0) {
+        chunks.push({
+          id: `stack:${rel}:full`,
+          content: `[stack] ${stackName} em ${rel}
+${content}`,
+          metadata: {
+            source: "project-stack",
+            file: rel,
+            stackName
+          }
+        });
+      }
+      return chunks;
+    }
+    function chunkIacmpDocs(systemPromptTemplate) {
+      const chunks = [];
+      const sections = systemPromptTemplate.split(/(?=^### )/m);
+      for (const section of sections) {
+        const titleMatch = section.match(/^### (.+)/);
+        if (!titleMatch)
+          continue;
+        const title = titleMatch[1].trim();
+        const trimmed = section.trim();
+        if (trimmed.length < 30)
+          continue;
+        chunks.push({
+          id: `docs:${title.replace(/[^a-zA-Z0-9]/g, "-")}`,
+          content: trimmed,
+          metadata: {
+            source: "iacmp-docs",
+            section: title
+          }
+        });
+      }
+      return chunks;
+    }
+    function chunkKnowledgeFile(filePath, platform) {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      const fileName = path2.basename(filePath, ".md");
+      const chunks = [];
+      const sections = content.split(/(?=^#{1,3} )/m);
+      for (const section of sections) {
+        const titleMatch = section.match(/^#{1,3} (.+)/);
+        const title = titleMatch ? titleMatch[1].trim() : fileName;
+        const trimmed = section.trim();
+        if (trimmed.length < 50)
+          continue;
+        if (trimmed.length > 2e3) {
+          const paragraphs = trimmed.split(/\n\n+/);
+          let buffer = "";
+          let bufferIndex = 0;
+          for (const para of paragraphs) {
+            buffer += para + "\n\n";
+            if (buffer.length > 800) {
+              chunks.push({
+                id: `knowledge:${platform}:${fileName}:${title.replace(/[^a-zA-Z0-9]/g, "-")}-${bufferIndex}`,
+                content: `[${platform.toUpperCase()}] ${title}
+
+${buffer.trim()}`,
+                metadata: {
+                  source: "platform-knowledge",
+                  platform,
+                  file: path2.basename(filePath),
+                  section: title
+                }
+              });
+              buffer = "";
+              bufferIndex++;
+            }
+          }
+          if (buffer.trim().length > 50) {
+            chunks.push({
+              id: `knowledge:${platform}:${fileName}:${title.replace(/[^a-zA-Z0-9]/g, "-")}-${bufferIndex}`,
+              content: `[${platform.toUpperCase()}] ${title}
+
+${buffer.trim()}`,
+              metadata: {
+                source: "platform-knowledge",
+                platform,
+                file: path2.basename(filePath),
+                section: title
+              }
+            });
+          }
+        } else {
+          chunks.push({
+            id: `knowledge:${platform}:${fileName}:${title.replace(/[^a-zA-Z0-9]/g, "-")}`,
+            content: `[${platform.toUpperCase()}] ${title}
+
+${trimmed}`,
+            metadata: {
+              source: "platform-knowledge",
+              platform,
+              file: path2.basename(filePath),
+              section: title
+            }
+          });
+        }
+      }
+      return chunks;
+    }
+  }
+});
+
+// ../ai/dist/rag/contextualizer.js
+var require_contextualizer = __commonJS({
+  "../ai/dist/rag/contextualizer.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Contextualizer = void 0;
+    var sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+    var CONTEXTUALIZER_PROMPT = `Voc\xEA est\xE1 processando um chunk de documento para indexa\xE7\xE3o em um sistema RAG de infraestrutura como c\xF3digo.
+
+Dado o documento completo e o chunk espec\xEDfico abaixo, gere um par\xE1grafo conciso (2-4 frases) que:
+1. Explique o que este chunk representa no contexto do documento maior
+2. Mencione conceitos-chave, servi\xE7os cloud, ou padr\xF5es de arquitetura relevantes
+3. Inclua termos alternativos ou sin\xF4nimos que ajudem na busca (ex: "Lambda" e "fun\xE7\xE3o serverless", "RDS" e "banco relacional")
+
+Seja direto e t\xE9cnico. N\xE3o use markdown. Responda apenas com o par\xE1grafo de contexto.
+
+<documento_completo>
+{DOCUMENT}
+</documento_completo>
+
+<chunk>
+{CHUNK}
+</chunk>`;
+    var Contextualizer = class {
+      client;
+      model = "claude-haiku-4-5";
+      // usa Haiku para minimizar custo — tarefa simples
+      constructor(apiKey) {
+        this.client = new sdk_1.default({ apiKey });
+      }
+      // Enriquece um único chunk com contexto gerado pelo Claude
+      async enrichChunk(chunk, fullDocument) {
+        const prompt = CONTEXTUALIZER_PROMPT.replace("{DOCUMENT}", fullDocument.slice(0, 8e3)).replace("{CHUNK}", chunk.content.slice(0, 2e3));
+        try {
+          const response = await this.client.messages.create({
+            model: this.model,
+            max_tokens: 256,
+            messages: [{ role: "user", content: prompt }]
+          });
+          const contextText = response.content[0].type === "text" ? response.content[0].text.trim() : "";
+          return {
+            ...chunk,
+            // contextualContent = contexto gerado + conteúdo original
+            // É isso que vai para o índice BM25/vetorial
+            contextualContent: `${contextText}
+
+${chunk.content}`
+          };
+        } catch {
+          return { ...chunk, contextualContent: chunk.content };
+        }
+      }
+      // Enriquece um lote de chunks em paralelo com controle de concorrência
+      async enrichBatch(chunks, fullDocument, options = {}) {
+        const { concurrency = 5, onProgress } = options;
+        const results = new Array(chunks.length);
+        let done = 0;
+        for (let i = 0; i < chunks.length; i += concurrency) {
+          const batch = chunks.slice(i, i + concurrency);
+          const batchResults = await Promise.all(batch.map((chunk) => this.enrichChunk(chunk, fullDocument)));
+          for (let j = 0; j < batchResults.length; j++) {
+            results[i + j] = batchResults[j];
+          }
+          done += batch.length;
+          onProgress?.(done, chunks.length);
+        }
+        return results;
+      }
+    };
+    exports2.Contextualizer = Contextualizer;
+  }
+});
+
+// ../ai/dist/rag/bm25.js
+var require_bm25 = __commonJS({
+  "../ai/dist/rag/bm25.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.buildBM25Index = buildBM25Index;
+    exports2.bm25Search = bm25Search;
+    var K1 = 1.5;
+    var B = 0.75;
+    function tokenize(text) {
+      return text.toLowerCase().replace(/[^a-z0-9\s._-]/g, " ").split(/\s+/).filter((t) => t.length > 1);
+    }
+    function termFrequency(tokens) {
+      const tf = {};
+      for (const t of tokens) {
+        tf[t] = (tf[t] ?? 0) + 1;
+      }
+      return tf;
+    }
+    function buildBM25Index(chunks) {
+      const documents = [];
+      const df = {};
+      let totalLength = 0;
+      for (const chunk of chunks) {
+        const text = chunk.contextualContent ?? chunk.content;
+        const tokens = tokenize(text);
+        const terms = termFrequency(tokens);
+        totalLength += tokens.length;
+        documents.push({ id: chunk.id, terms, length: tokens.length });
+        for (const term of Object.keys(terms)) {
+          df[term] = (df[term] ?? 0) + 1;
+        }
+      }
+      return {
+        documents,
+        df,
+        avgLength: documents.length > 0 ? totalLength / documents.length : 0,
+        totalDocs: documents.length
+      };
+    }
+    function bm25Search(index, query, topK = 5) {
+      const queryTerms = tokenize(query);
+      const scores = {};
+      for (const term of queryTerms) {
+        const docFreq = index.df[term] ?? 0;
+        if (docFreq === 0)
+          continue;
+        const idf = Math.log((index.totalDocs - docFreq + 0.5) / (docFreq + 0.5) + 1);
+        for (const doc of index.documents) {
+          const tf = doc.terms[term] ?? 0;
+          if (tf === 0)
+            continue;
+          const tfNorm = tf * (K1 + 1) / (tf + K1 * (1 - B + B * (doc.length / index.avgLength)));
+          scores[doc.id] = (scores[doc.id] ?? 0) + idf * tfNorm;
+        }
+      }
+      return Object.entries(scores).sort((a, b) => b[1] - a[1]).slice(0, topK).map(([id, score]) => ({ id, score }));
+    }
+  }
+});
+
+// ../ai/dist/rag/embedder.js
+var require_embedder = __commonJS({
+  "../ai/dist/rag/embedder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.BM25Embedder = exports2.VoyageEmbedder = void 0;
+    exports2.createEmbedder = createEmbedder;
+    var VoyageEmbedder = class {
+      apiKey;
+      model = "voyage-code-2";
+      endpoint = "https://api.voyageai.com/v1/embeddings";
+      constructor(apiKey) {
+        this.apiKey = apiKey;
+      }
+      async embed(texts) {
+        if (texts.length === 0)
+          return [];
+        const BATCH_SIZE = 128;
+        const results = [];
+        for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+          const batch = texts.slice(i, i + BATCH_SIZE);
+          const batchVectors = await this.embedBatch(batch);
+          results.push(...batchVectors);
+        }
+        return results;
+      }
+      async embedBatch(texts) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3e4);
+        try {
+          const response = await fetch(this.endpoint, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              model: this.model,
+              input: texts,
+              input_type: "document"
+            }),
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Voyage API error ${response.status}: ${body}`);
+          }
+          const data = await response.json();
+          const sorted = data.data.sort((a, b) => a.index - b.index);
+          return sorted.map((d) => d.embedding);
+        } finally {
+          clearTimeout(timeout);
+        }
+      }
+    };
+    exports2.VoyageEmbedder = VoyageEmbedder;
+    var BM25Embedder = class {
+      vocabSize;
+      constructor(vocabSize = 4096) {
+        this.vocabSize = vocabSize;
+      }
+      async embed(texts) {
+        return texts.map((text) => this.textToVector(text));
+      }
+      textToVector(text) {
+        const tokens = this.tokenize(text);
+        const tf = this.termFrequency(tokens);
+        const vector = new Float64Array(this.vocabSize);
+        for (const [term, freq] of Object.entries(tf)) {
+          const hash = this.termHash(term);
+          const pos = Math.abs(hash) % this.vocabSize;
+          vector[pos] += Math.log(1 + freq) / Math.max(1, tokens.length);
+        }
+        return this.normalizeL2(Array.from(vector));
+      }
+      tokenize(text) {
+        return text.toLowerCase().replace(/[^a-z0-9\s._-]/g, " ").split(/\s+/).filter((t) => t.length > 1);
+      }
+      termFrequency(tokens) {
+        const tf = {};
+        for (const t of tokens) {
+          tf[t] = (tf[t] ?? 0) + 1;
+        }
+        return tf;
+      }
+      termHash(term) {
+        let hash = 5381;
+        for (let i = 0; i < term.length; i++) {
+          hash = (hash << 5) + hash ^ term.charCodeAt(i);
+          hash = hash & 2147483647;
+        }
+        return hash;
+      }
+      normalizeL2(vector) {
+        const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+        if (norm === 0)
+          return vector;
+        return vector.map((v) => v / norm);
+      }
+    };
+    exports2.BM25Embedder = BM25Embedder;
+    function createEmbedder(voyageApiKey) {
+      if (voyageApiKey) {
+        return new VoyageEmbedder(voyageApiKey);
+      }
+      return new BM25Embedder();
+    }
+  }
+});
+
+// ../ai/dist/rag/vector-store.js
+var require_vector_store = __commonJS({
+  "../ai/dist/rag/vector-store.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VectorStore = void 0;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var VectorStore = class {
+      entries = [];
+      dimension = 0;
+      add(id, vector, metadata) {
+        if (this.dimension === 0) {
+          this.dimension = vector.length;
+        }
+        const normalized = this.normalizeL2(vector);
+        this.entries.push({
+          id,
+          vector: new Float32Array(normalized),
+          metadata
+        });
+      }
+      search(queryVector, topK = 5) {
+        if (this.entries.length === 0)
+          return [];
+        const normalizedQuery = new Float32Array(this.normalizeL2(queryVector));
+        const scores = [];
+        for (let i = 0; i < this.entries.length; i++) {
+          const score = this.cosineSimilarity(normalizedQuery, this.entries[i].vector);
+          scores.push({ index: i, score });
+        }
+        return scores.sort((a, b) => b.score - a.score).slice(0, topK).map(({ index, score }) => ({
+          id: this.entries[index].id,
+          score,
+          metadata: this.entries[index].metadata
+        }));
+      }
+      size() {
+        return this.entries.length;
+      }
+      clear() {
+        this.entries = [];
+        this.dimension = 0;
+      }
+      // Serializa o índice em binário para persistência
+      // Formato: [header: 16 bytes][entries...]
+      // Header: magic(4) + version(4) + numEntries(4) + dimension(4)
+      // Entry: idLen(4) + id(idLen) + metadataLen(4) + metadata(metadataLen) + vector(dimension * 4)
+      save(filePath) {
+        fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+        const MAGIC = 1447379796;
+        const VERSION = 1;
+        const encodedEntries = this.entries.map((entry) => {
+          const idBytes = Buffer.from(entry.id, "utf-8");
+          const metaBytes = Buffer.from(JSON.stringify(entry.metadata), "utf-8");
+          return { entry, idBytes, metaBytes };
+        });
+        const totalSize = 16 + encodedEntries.reduce((sum, { entry, idBytes, metaBytes }) => {
+          return sum + 4 + idBytes.length + 4 + metaBytes.length + entry.vector.length * 4;
+        }, 0);
+        const buffer = Buffer.alloc(totalSize);
+        let offset = 0;
+        buffer.writeUInt32BE(MAGIC, offset);
+        offset += 4;
+        buffer.writeUInt32BE(VERSION, offset);
+        offset += 4;
+        buffer.writeUInt32BE(this.entries.length, offset);
+        offset += 4;
+        buffer.writeUInt32BE(this.dimension, offset);
+        offset += 4;
+        for (const { entry, idBytes, metaBytes } of encodedEntries) {
+          buffer.writeUInt32BE(idBytes.length, offset);
+          offset += 4;
+          idBytes.copy(buffer, offset);
+          offset += idBytes.length;
+          buffer.writeUInt32BE(metaBytes.length, offset);
+          offset += 4;
+          metaBytes.copy(buffer, offset);
+          offset += metaBytes.length;
+          for (const v of entry.vector) {
+            buffer.writeFloatBE(v, offset);
+            offset += 4;
+          }
+        }
+        fs2.writeFileSync(filePath, buffer);
+      }
+      // Carrega índice do binário
+      load(filePath) {
+        if (!fs2.existsSync(filePath))
+          return false;
+        try {
+          const buffer = fs2.readFileSync(filePath);
+          let offset = 0;
+          const magic = buffer.readUInt32BE(offset);
+          offset += 4;
+          if (magic !== 1447379796)
+            return false;
+          const version = buffer.readUInt32BE(offset);
+          offset += 4;
+          if (version !== 1)
+            return false;
+          const numEntries = buffer.readUInt32BE(offset);
+          offset += 4;
+          const dimension = buffer.readUInt32BE(offset);
+          offset += 4;
+          this.dimension = dimension;
+          this.entries = [];
+          for (let i = 0; i < numEntries; i++) {
+            const idLen = buffer.readUInt32BE(offset);
+            offset += 4;
+            const id = buffer.subarray(offset, offset + idLen).toString("utf-8");
+            offset += idLen;
+            const metaLen = buffer.readUInt32BE(offset);
+            offset += 4;
+            const metaStr = buffer.subarray(offset, offset + metaLen).toString("utf-8");
+            offset += metaLen;
+            const metadata = JSON.parse(metaStr);
+            const vector = new Float32Array(dimension);
+            for (let d = 0; d < dimension; d++) {
+              vector[d] = buffer.readFloatBE(offset);
+              offset += 4;
+            }
+            this.entries.push({ id, vector, metadata });
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+          return 0;
+        let dot = 0;
+        for (let i = 0; i < a.length; i++) {
+          dot += a[i] * b[i];
+        }
+        return Math.max(-1, Math.min(1, dot));
+      }
+      normalizeL2(vector) {
+        const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+        if (norm === 0)
+          return vector;
+        return vector.map((v) => v / norm);
+      }
+    };
+    exports2.VectorStore = VectorStore;
+  }
+});
+
+// ../ai/dist/rag/indexer.js
+var require_indexer = __commonJS({
+  "../ai/dist/rag/indexer.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.buildIndexes = buildIndexes;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var crypto = __importStar(require("crypto"));
+    var chunker_1 = require_chunker();
+    var contextualizer_1 = require_contextualizer();
+    var bm25_1 = require_bm25();
+    var embedder_1 = require_embedder();
+    var vector_store_1 = require_vector_store();
+    var INDEX_FILE = ".iacmp/rag-index.json";
+    var KNOWLEDGE_DIR = path2.join(__dirname, "../knowledge");
+    function hashProjectStacks(projectDir) {
+      const stacksDir = path2.join(projectDir, "stacks");
+      if (!fs2.existsSync(stacksDir))
+        return "empty";
+      const findFiles = (dir) => {
+        const entries = fs2.readdirSync(dir, { withFileTypes: true });
+        const files2 = [];
+        for (const e of entries) {
+          const full = path2.join(dir, e.name);
+          if (e.isDirectory())
+            files2.push(...findFiles(full));
+          else if (e.name.endsWith(".ts"))
+            files2.push(full);
+        }
+        return files2.sort();
+      };
+      const files = findFiles(stacksDir);
+      const content = files.map((f) => `${f}:${fs2.statSync(f).mtimeMs}`).join("\n");
+      return crypto.createHash("sha256").update(content).digest("hex").slice(0, 12);
+    }
+    function loadPersistedProjectChunks(projectDir, currentHash) {
+      const indexPath = path2.join(projectDir, INDEX_FILE);
+      if (!fs2.existsSync(indexPath))
+        return null;
+      try {
+        const data = JSON.parse(fs2.readFileSync(indexPath, "utf-8"));
+        if (data.projectHash !== currentHash)
+          return null;
+        return data.chunks;
+      } catch {
+        return null;
+      }
+    }
+    function saveProjectChunks(projectDir, hash, chunks) {
+      const indexPath = path2.join(projectDir, INDEX_FILE);
+      fs2.mkdirSync(path2.dirname(indexPath), { recursive: true });
+      const data = {
+        projectHash: hash,
+        chunks,
+        builtAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      fs2.writeFileSync(indexPath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    function loadKnowledgeChunks() {
+      const chunks = [];
+      if (!fs2.existsSync(KNOWLEDGE_DIR))
+        return chunks;
+      const platforms = ["aws", "azure", "gcp", "cross-cloud"];
+      for (const platform of platforms) {
+        const platformDir = path2.join(KNOWLEDGE_DIR, platform);
+        if (!fs2.existsSync(platformDir))
+          continue;
+        const files = fs2.readdirSync(platformDir).filter((f) => f.endsWith(".md"));
+        for (const file of files) {
+          try {
+            const fileChunks = (0, chunker_1.chunkKnowledgeFile)(path2.join(platformDir, file), platform);
+            chunks.push(...fileChunks);
+          } catch {
+          }
+        }
+      }
+      return chunks;
+    }
+    var VECTOR_INDEX_FILE = ".iacmp/vector-index.bin";
+    async function buildIndexes(options) {
+      const { projectDir, systemPromptTemplate, anthropicApiKey, voyageApiKey = process.env["VOYAGE_API_KEY"], useContextualRetrieval = !!anthropicApiKey, onProgress } = options;
+      const log = (msg) => onProgress?.(msg);
+      log("Indexando stacks do projeto...");
+      const currentHash = hashProjectStacks(projectDir);
+      let projectChunks = loadPersistedProjectChunks(projectDir, currentHash);
+      if (!projectChunks) {
+        log("Stacks mudaram \u2014 reindexando...");
+        const stacksDir = path2.join(projectDir, "stacks");
+        const rawChunks = [];
+        if (fs2.existsSync(stacksDir)) {
+          const findFiles = (dir) => {
+            const entries = fs2.readdirSync(dir, { withFileTypes: true });
+            const files = [];
+            for (const e of entries) {
+              const full = path2.join(dir, e.name);
+              if (e.isDirectory())
+                files.push(...findFiles(full));
+              else if (e.name.endsWith(".ts"))
+                files.push(full);
+            }
+            return files;
+          };
+          for (const file of findFiles(stacksDir)) {
+            rawChunks.push(...(0, chunker_1.chunkStackFile)(file, projectDir));
+          }
+        }
+        if (useContextualRetrieval && anthropicApiKey && rawChunks.length > 0) {
+          log(`Aplicando Contextual Retrieval em ${rawChunks.length} chunks de stacks...`);
+          const contextualizer = new contextualizer_1.Contextualizer(anthropicApiKey);
+          const fullDocument = rawChunks.map((c) => c.content).join("\n\n");
+          projectChunks = await contextualizer.enrichBatch(rawChunks, fullDocument, {
+            concurrency: 5,
+            onProgress: (done, total2) => log(`  ${done}/${total2} chunks enriquecidos`)
+          });
+        } else {
+          projectChunks = rawChunks;
+        }
+        saveProjectChunks(projectDir, currentHash, projectChunks);
+        log(`${projectChunks.length} chunks de stacks indexados.`);
+      } else {
+        log(`${projectChunks.length} chunks de stacks carregados do cache.`);
+      }
+      log("Indexando documenta\xE7\xE3o de constructs...");
+      let docsChunks = (0, chunker_1.chunkIacmpDocs)(systemPromptTemplate);
+      if (useContextualRetrieval && anthropicApiKey && docsChunks.length > 0) {
+        log(`Aplicando Contextual Retrieval em ${docsChunks.length} chunks de docs...`);
+        const contextualizer = new contextualizer_1.Contextualizer(anthropicApiKey);
+        const fullDoc = systemPromptTemplate;
+        docsChunks = await contextualizer.enrichBatch(docsChunks, fullDoc, { concurrency: 5 });
+      }
+      log(`${docsChunks.length} chunks de docs indexados.`);
+      log("Indexando base de conhecimento de plataforma...");
+      const knowledgeChunks = loadKnowledgeChunks();
+      log(`${knowledgeChunks.length} chunks de conhecimento indexados.`);
+      const projectIndex = (0, bm25_1.buildBM25Index)(projectChunks);
+      const docsIndex = (0, bm25_1.buildBM25Index)(docsChunks);
+      const knowledgeIndex = (0, bm25_1.buildBM25Index)(knowledgeChunks);
+      const chunkMap = /* @__PURE__ */ new Map();
+      for (const c of [...projectChunks, ...docsChunks, ...knowledgeChunks]) {
+        chunkMap.set(c.id, c);
+      }
+      const vectorStore = new vector_store_1.VectorStore();
+      const vectorIndexPath = path2.join(projectDir, VECTOR_INDEX_FILE);
+      if (voyageApiKey) {
+        const loaded = vectorStore.load(vectorIndexPath);
+        if (!loaded) {
+          log(`Gerando embeddings com Voyage AI (${knowledgeChunks.length} chunks de conhecimento)...`);
+          const embedder = (0, embedder_1.createEmbedder)(voyageApiKey);
+          const texts = knowledgeChunks.map((c) => c.contextualContent ?? c.content);
+          try {
+            const vectors = await embedder.embed(texts);
+            for (let i = 0; i < knowledgeChunks.length; i++) {
+              const chunk = knowledgeChunks[i];
+              vectorStore.add(chunk.id, vectors[i], {
+                id: chunk.id,
+                source: chunk.metadata.source,
+                section: chunk.metadata.section,
+                platform: chunk.metadata.platform
+              });
+            }
+            vectorStore.save(vectorIndexPath);
+            log(`${vectorStore.size()} vetores gerados e salvos.`);
+          } catch (err) {
+            log(`Embeddings Voyage AI falharam \u2014 usando apenas BM25: ${err.message}`);
+          }
+        } else {
+          log(`${vectorStore.size()} vetores carregados do cache.`);
+        }
+      }
+      const total = projectChunks.length + docsChunks.length + knowledgeChunks.length;
+      log(`RAG pronto \u2014 ${total} chunks indexados no total${voyageApiKey ? ` + ${vectorStore.size()} vetores` : ""}.`);
+      return { projectIndex, docsIndex, knowledgeIndex, chunkMap, vectorStore };
+    }
+  }
+});
+
+// ../ai/dist/rag/retriever.js
+var require_retriever = __commonJS({
+  "../ai/dist/rag/retriever.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.retrieve = retrieve;
+    exports2.formatRetrievedContext = formatRetrievedContext;
+    var bm25_1 = require_bm25();
+    var DEFAULT_K = {
+      project: 5,
+      docs: 3,
+      knowledge: 5
+    };
+    function retrieve(indexes, query, options = {}) {
+      const { projectK = DEFAULT_K.project, docsK = DEFAULT_K.docs, knowledgeK = DEFAULT_K.knowledge, minScore = 0.1 } = options;
+      const results = [];
+      const projectHits = (0, bm25_1.bm25Search)(indexes.projectIndex, query, projectK);
+      const docsHits = (0, bm25_1.bm25Search)(indexes.docsIndex, query, docsK);
+      const knowledgeHits = (0, bm25_1.bm25Search)(indexes.knowledgeIndex, query, knowledgeK);
+      for (const hit of [...projectHits, ...docsHits, ...knowledgeHits]) {
+        if (hit.score < minScore)
+          continue;
+        const chunk = indexes.chunkMap.get(hit.id);
+        if (!chunk)
+          continue;
+        results.push({
+          chunk,
+          score: hit.score,
+          source: chunk.metadata.source
+        });
+      }
+      return results.sort((a, b) => b.score - a.score);
+    }
+    function formatRetrievedContext(results) {
+      if (results.length === 0)
+        return "";
+      const sections = ["## Contexto recuperado pelo RAG\n"];
+      const bySource = {
+        "project-stack": results.filter((r) => r.chunk.metadata.source === "project-stack"),
+        "iacmp-docs": results.filter((r) => r.chunk.metadata.source === "iacmp-docs"),
+        "platform-knowledge": results.filter((r) => r.chunk.metadata.source === "platform-knowledge")
+      };
+      if (bySource["project-stack"].length > 0) {
+        sections.push("### Stacks do projeto relevantes");
+        for (const r of bySource["project-stack"]) {
+          sections.push(r.chunk.content);
+          sections.push("");
+        }
+      }
+      if (bySource["iacmp-docs"].length > 0) {
+        sections.push("### Documenta\xE7\xE3o de constructs relevante");
+        for (const r of bySource["iacmp-docs"]) {
+          sections.push(r.chunk.content);
+          sections.push("");
+        }
+      }
+      if (bySource["platform-knowledge"].length > 0) {
+        sections.push("### Conhecimento de plataforma relevante");
+        for (const r of bySource["platform-knowledge"]) {
+          sections.push(r.chunk.content);
+          sections.push("");
+        }
+      }
+      return sections.join("\n");
+    }
+  }
+});
+
+// ../ai/dist/rag/live-retriever.js
+var require_live_retriever = __commonJS({
+  "../ai/dist/rag/live-retriever.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LIVE_SIGNALS = void 0;
+    exports2.fetchLive = fetchLive;
+    exports2.shouldFetchLive = shouldFetchLive;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var CACHE_FILE = ".iacmp/live-cache.json";
+    var CACHE_TTL_MS = 60 * 60 * 1e3;
+    var FETCH_TIMEOUT_MS = 3e3;
+    function loadCache(projectDir) {
+      const filePath = projectDir ? path2.join(projectDir, CACHE_FILE) : path2.join(process.cwd(), CACHE_FILE);
+      if (!fs2.existsSync(filePath))
+        return {};
+      try {
+        return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+      } catch {
+        return {};
+      }
+    }
+    function saveCache(store, projectDir) {
+      const filePath = projectDir ? path2.join(projectDir, CACHE_FILE) : path2.join(process.cwd(), CACHE_FILE);
+      try {
+        fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+        fs2.writeFileSync(filePath, JSON.stringify(store, null, 2), "utf-8");
+      } catch {
+      }
+    }
+    function getCached2(store, key) {
+      const entry = store[key];
+      if (!entry)
+        return null;
+      if (Date.now() > entry.expiresAt)
+        return null;
+      return entry.value;
+    }
+    function setCached(store, key, value) {
+      store[key] = { value, expiresAt: Date.now() + CACHE_TTL_MS };
+      const now = Date.now();
+      for (const k of Object.keys(store)) {
+        if (store[k].expiresAt < now) {
+          delete store[k];
+        }
+      }
+    }
+    async function fetchWithTimeout(url, options = {}) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+      try {
+        const resp = await fetch(url, { ...options, signal: controller.signal });
+        if (!resp.ok)
+          return "";
+        return await resp.text();
+      } catch {
+        return "";
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    function parseRssText(xml, maxItems = 5) {
+      const items = [];
+      const itemRegex = /<item[^>]*>([\s\S]*?)<\/item>/gi;
+      const titleRegex = /<title[^>]*><!\[CDATA\[(.*?)\]\]><\/title>|<title[^>]*>(.*?)<\/title>/i;
+      const descRegex = /<description[^>]*><!\[CDATA\[(.*?)\]\]><\/description>|<description[^>]*>(.*?)<\/description>/i;
+      let match;
+      let count = 0;
+      while ((match = itemRegex.exec(xml)) !== null && count < maxItems) {
+        const itemContent = match[1];
+        const titleMatch = titleRegex.exec(itemContent);
+        const descMatch = descRegex.exec(itemContent);
+        const title = (titleMatch?.[1] ?? titleMatch?.[2] ?? "").trim();
+        const desc = (descMatch?.[1] ?? descMatch?.[2] ?? "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 200);
+        if (title) {
+          items.push(desc ? `- ${title}: ${desc}` : `- ${title}`);
+          count++;
+        }
+      }
+      return items.join("\n");
+    }
+    function mentionsPrice(query) {
+      const lower = query.toLowerCase();
+      return ["pre\xE7o", "preco", "custo", "quanto custa", "valor", "cost", "price", "pricing"].some((s) => lower.includes(s));
+    }
+    function mentionsTerraform(query) {
+      const lower = query.toLowerCase();
+      return ["terraform", "tf provider", "terraform provider", "hashicorp"].some((s) => lower.includes(s));
+    }
+    function mentionsRecent(query) {
+      const lower = query.toLowerCase();
+      return ["lan\xE7ou", "lancou", "novidade", "recente", "novo servi\xE7o", "novo recurso", "anunciou", "what's new", "whats new"].some((s) => lower.includes(s));
+    }
+    function mentionsAzure(query) {
+      const lower = query.toLowerCase();
+      return ["azure", "microsoft azure", "az "].some((s) => lower.includes(s));
+    }
+    function mentionsGcp(query) {
+      const lower = query.toLowerCase();
+      return ["gcp", "google cloud", "gcloud", "cloud run", "bigquery", "cloud functions", "pub/sub", "pubsub", "spanner"].some((s) => lower.includes(s));
+    }
+    function extractAzureServiceName(query) {
+      const lower = query.toLowerCase();
+      const serviceMap = [
+        [["functions", "function app"], "Azure Functions"],
+        [["app service", "web app"], "Azure App Service"],
+        [["sql database", "azure sql"], "SQL Database"],
+        [["cosmos", "cosmosdb"], "Azure Cosmos DB"],
+        [["blob", "storage account"], "Storage"],
+        [["kubernetes", "aks"], "Azure Kubernetes Service"],
+        [["container instance", "aci"], "Container Instances"],
+        [["virtual machine", "vm ", "vms "], "Virtual Machines"],
+        [["redis", "cache"], "Azure Cache for Redis"],
+        [["service bus"], "Service Bus"],
+        [["event hub"], "Event Hubs"],
+        [["api management", "apim"], "API Management"],
+        [["postgresql", "postgres"], "Azure Database for PostgreSQL"],
+        [["mysql"], "Azure Database for MySQL"]
+      ];
+      for (const [terms, serviceName] of serviceMap) {
+        if (terms.some((t) => lower.includes(t)))
+          return serviceName;
+      }
+      return null;
+    }
+    function extractGcpServiceId(query) {
+      const lower = query.toLowerCase();
+      const serviceMap = [
+        [["cloud run"], "Cloud Run"],
+        [["cloud functions", "functions"], "Cloud Functions"],
+        [["bigquery"], "BigQuery"],
+        [["gke", "kubernetes", "kubernetes engine"], "Kubernetes Engine"],
+        [["cloud sql", "sql"], "Cloud SQL"],
+        [["spanner"], "Cloud Spanner"],
+        [["pub/sub", "pubsub"], "Cloud Pub/Sub"],
+        [["compute engine", "vm ", "inst\xE2ncia"], "Compute Engine"],
+        [["cloud storage", "gcs"], "Cloud Storage"],
+        [["cloud bigtable", "bigtable"], "Cloud Bigtable"]
+      ];
+      for (const [terms, serviceId] of serviceMap) {
+        if (terms.some((t) => lower.includes(t)))
+          return serviceId;
+      }
+      return null;
+    }
+    async function fetchAwsWhatsNew(cache) {
+      const cacheKey = "aws-whats-new";
+      const cached = getCached2(cache, cacheKey);
+      if (cached !== null)
+        return cached;
+      const xml = await fetchWithTimeout("https://aws.amazon.com/about-aws/whats-new/recent/feed/");
+      if (!xml)
+        return "";
+      const text = parseRssText(xml, 5);
+      const result = text ? `### AWS What's New (recente)
+${text}` : "";
+      setCached(cache, cacheKey, result);
+      return result;
+    }
+    async function fetchAwsPricing(query, cache) {
+      const sections = [];
+      if (query.toLowerCase().includes("lambda")) {
+        const cacheKey = "aws-pricing-lambda";
+        const cached = getCached2(cache, cacheKey);
+        if (cached !== null) {
+          if (cached)
+            sections.push(cached);
+        } else {
+          const url = "https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AWSLambda/current/us-east-1/index.json";
+          const raw = await fetchWithTimeout(url);
+          let result = "";
+          if (raw) {
+            try {
+              const data = JSON.parse(raw);
+              const pricePoints = [];
+              if (data.terms?.OnDemand) {
+                let count = 0;
+                for (const sku of Object.values(data.terms.OnDemand)) {
+                  for (const term of Object.values(sku)) {
+                    for (const dim of Object.values(term.priceDimensions ?? {})) {
+                      const usd = dim.pricePerUnit?.USD;
+                      const desc = dim.description;
+                      if (usd && desc && count < 3) {
+                        pricePoints.push(`  - ${desc}: $${usd}`);
+                        count++;
+                      }
+                    }
+                  }
+                }
+              }
+              if (pricePoints.length > 0) {
+                result = `### AWS Lambda Pricing (us-east-1)
+${pricePoints.join("\n")}`;
+              }
+            } catch {
+            }
+          }
+          setCached(cache, cacheKey, result);
+          if (result)
+            sections.push(result);
+        }
+      }
+      if (query.toLowerCase().includes("rds") || query.toLowerCase().includes("aurora")) {
+        const cacheKey = "aws-pricing-rds-note";
+        const cached = getCached2(cache, cacheKey);
+        if (cached !== null) {
+          if (cached)
+            sections.push(cached);
+        } else {
+          const result = `### AWS RDS Pricing
+Pre\xE7os variam por engine (MySQL, PostgreSQL, Oracle, SQL Server, Aurora), tipo de inst\xE2ncia e regi\xE3o.
+Calculadora oficial: https://aws.amazon.com/rds/pricing/
+Endpoint JSON: https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonRDS/current/index.json`;
+          setCached(cache, cacheKey, result);
+          sections.push(result);
+        }
+      }
+      return sections.join("\n\n");
+    }
+    async function fetchAzurePricing(query, cache) {
+      const serviceName = extractAzureServiceName(query);
+      if (!serviceName)
+        return "";
+      const cacheKey = `azure-pricing-${serviceName.toLowerCase().replace(/\s+/g, "-")}`;
+      const cached = getCached2(cache, cacheKey);
+      if (cached !== null)
+        return cached;
+      const filter = encodeURIComponent(`serviceName eq '${serviceName}' and armRegionName eq 'eastus' and priceType eq 'Consumption'`);
+      const url = `https://prices.azure.com/api/retail/prices?$filter=${filter}&$top=10`;
+      const raw = await fetchWithTimeout(url);
+      if (!raw)
+        return "";
+      try {
+        const data = JSON.parse(raw);
+        if (!data.Items || data.Items.length === 0)
+          return "";
+        const lines = [`### Azure ${serviceName} Pricing (East US)`];
+        let count = 0;
+        for (const item of data.Items) {
+          if (count >= 6)
+            break;
+          const sku = item.skuName ?? item.productName ?? "";
+          const price = item.retailPrice;
+          const unit = item.unitOfMeasure ?? "";
+          if (sku && price !== void 0) {
+            lines.push(`  - ${sku}: $${price}/${unit}`);
+            count++;
+          }
+        }
+        if (lines.length <= 1)
+          return "";
+        const result = lines.join("\n");
+        setCached(cache, cacheKey, result);
+        return result;
+      } catch {
+        return "";
+      }
+    }
+    async function fetchAzureUpdates(cache) {
+      const cacheKey = "azure-updates";
+      const cached = getCached2(cache, cacheKey);
+      if (cached !== null)
+        return cached;
+      const xml = await fetchWithTimeout("https://www.microsoft.com/releasecommunications/api/v2/azure/rss");
+      if (!xml)
+        return "";
+      const text = parseRssText(xml, 5);
+      const result = text ? `### Azure Updates (recente)
+${text}` : "";
+      setCached(cache, cacheKey, result);
+      return result;
+    }
+    async function fetchGcpPricing(query, cache) {
+      const targetService = extractGcpServiceId(query);
+      if (!targetService)
+        return "";
+      const cacheKey = `gcp-pricing-${targetService.toLowerCase().replace(/\s+/g, "-")}`;
+      const cached = getCached2(cache, cacheKey);
+      if (cached !== null)
+        return cached;
+      const servicesRaw = await fetchWithTimeout("https://cloudbilling.googleapis.com/v1/services?pageSize=200");
+      if (!servicesRaw)
+        return "";
+      let serviceId = null;
+      try {
+        const servicesData = JSON.parse(servicesRaw);
+        const match = (servicesData.services ?? []).find((s) => s.displayName?.toLowerCase().includes(targetService.toLowerCase()));
+        if (match?.name) {
+          serviceId = match.name;
+        }
+      } catch {
+        return "";
+      }
+      if (!serviceId)
+        return "";
+      const skusRaw = await fetchWithTimeout(`https://cloudbilling.googleapis.com/v1/${serviceId}/skus?pageSize=10&currencyCode=USD`);
+      if (!skusRaw)
+        return "";
+      try {
+        const skusData = JSON.parse(skusRaw);
+        if (!skusData.skus || skusData.skus.length === 0)
+          return "";
+        const lines = [`### GCP ${targetService} Pricing (USD)`];
+        let count = 0;
+        for (const sku of skusData.skus) {
+          if (count >= 6)
+            break;
+          const desc = sku.description;
+          const rate = sku.pricingInfo?.[0]?.pricingExpression?.tieredRates?.[0];
+          const unit = sku.pricingInfo?.[0]?.pricingExpression?.usageUnit ?? "";
+          if (desc && rate?.unitPrice) {
+            const units = Number(rate.unitPrice.units ?? 0);
+            const nanos = (rate.unitPrice.nanos ?? 0) / 1e9;
+            const price = units + nanos;
+            lines.push(`  - ${desc}: $${price.toFixed(6)}/${unit}`);
+            count++;
+          }
+        }
+        if (lines.length <= 1)
+          return "";
+        const result = lines.join("\n");
+        setCached(cache, cacheKey, result);
+        return result;
+      } catch {
+        return "";
+      }
+    }
+    async function fetchGcpReleaseNotes(cache) {
+      const cacheKey = "gcp-release-notes";
+      const cached = getCached2(cache, cacheKey);
+      if (cached !== null)
+        return cached;
+      const xml = await fetchWithTimeout("https://cloud.google.com/feeds/gcp-release-notes.xml");
+      if (!xml)
+        return "";
+      const text = parseAtomText(xml, 5);
+      const result = text ? `### GCP Release Notes (recente)
+${text}` : "";
+      setCached(cache, cacheKey, result);
+      return result;
+    }
+    function parseAtomText(xml, maxItems = 5) {
+      const items = [];
+      const entryRegex = /<entry[^>]*>([\s\S]*?)<\/entry>/gi;
+      const titleRegex = /<title[^>]*>(.*?)<\/title>/i;
+      const summaryRegex = /<summary[^>]*>([\s\S]*?)<\/summary>/i;
+      let match;
+      let count = 0;
+      while ((match = entryRegex.exec(xml)) !== null && count < maxItems) {
+        const entryContent = match[1];
+        const titleMatch = titleRegex.exec(entryContent);
+        const summaryMatch = summaryRegex.exec(entryContent);
+        const title = (titleMatch?.[1] ?? "").replace(/<[^>]+>/g, "").trim();
+        const summary = (summaryMatch?.[1] ?? "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 200);
+        if (title) {
+          items.push(summary ? `- ${title}: ${summary}` : `- ${title}`);
+          count++;
+        }
+      }
+      return items.join("\n");
+    }
+    async function fetchTerraformProviderVersion(cache) {
+      const cacheKey = "tf-aws-provider-version";
+      const cached = getCached2(cache, cacheKey);
+      if (cached !== null)
+        return cached;
+      const raw = await fetchWithTimeout("https://registry.terraform.io/v1/providers/hashicorp/aws");
+      if (!raw)
+        return "";
+      try {
+        const data = JSON.parse(raw);
+        const version = data.version;
+        if (!version)
+          return "";
+        const result = `### Terraform AWS Provider
+Vers\xE3o atual: ${version}
+Documenta\xE7\xE3o: https://registry.terraform.io/providers/hashicorp/aws/latest/docs`;
+        setCached(cache, cacheKey, result);
+        return result;
+      } catch {
+        return "";
+      }
+    }
+    async function fetchLive(query, signals, options = {}) {
+      const cache = loadCache(options.projectDir);
+      const parts = [];
+      const sigSet = new Set(signals);
+      try {
+        const isRecent = mentionsRecent(query) || sigSet.has("recent");
+        const isPrice = mentionsPrice(query) || sigSet.has("price");
+        const isAzure = mentionsAzure(query) || sigSet.has("azure");
+        const isGcp = mentionsGcp(query) || sigSet.has("gcp");
+        const isTf = mentionsTerraform(query) || sigSet.has("terraform");
+        const fetches = [];
+        if (isRecent && !isAzure && !isGcp)
+          fetches.push(fetchAwsWhatsNew(cache));
+        if (isPrice && !isAzure && !isGcp)
+          fetches.push(fetchAwsPricing(query, cache));
+        if (isPrice && isAzure)
+          fetches.push(fetchAzurePricing(query, cache));
+        if (isRecent && isAzure)
+          fetches.push(fetchAzureUpdates(cache));
+        if (isPrice && isGcp)
+          fetches.push(fetchGcpPricing(query, cache));
+        if (isRecent && isGcp)
+          fetches.push(fetchGcpReleaseNotes(cache));
+        if (isTf)
+          fetches.push(fetchTerraformProviderVersion(cache));
+        const results = await Promise.all(fetches);
+        for (const r of results) {
+          if (r)
+            parts.push(r);
+        }
+      } finally {
+        saveCache(cache, options.projectDir);
+      }
+      return parts.join("\n\n");
+    }
+    exports2.LIVE_SIGNALS = [
+      // Preço / custo
+      "pre\xE7o",
+      "preco",
+      "custo",
+      "quanto custa",
+      "valor",
+      "pricing",
+      // Novidades / recente
+      "lan\xE7ou",
+      "lancou",
+      "novidade",
+      "recente",
+      "novo servi\xE7o",
+      "novo recurso",
+      "anunciou",
+      "vers\xE3o atual",
+      "versao atual",
+      "what's new",
+      "whats new",
+      "release notes",
+      "release note",
+      // Terraform
+      "terraform provider",
+      "terraform aws",
+      "terraform azure",
+      "terraform gcp",
+      // Azure (específicos que indicam contexto Azure + info ao vivo)
+      "azure functions pre\xE7o",
+      "app service custo",
+      "cosmos db custo",
+      "azure sql pre\xE7o",
+      // GCP (específicos)
+      "cloud run pre\xE7o",
+      "bigquery custo",
+      "gke pre\xE7o",
+      "cloud sql gcp"
+    ];
+    function shouldFetchLive(query) {
+      const lower = query.toLowerCase();
+      return exports2.LIVE_SIGNALS.some((s) => lower.includes(s));
+    }
+  }
+});
+
+// ../ai/dist/tools/context-reader.js
+var require_context_reader = __commonJS({
+  "../ai/dist/tools/context-reader.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.readProjectMeta = readProjectMeta;
+    exports2.readProjectContext = readProjectContext;
+    exports2.readProjectContextRAG = readProjectContextRAG2;
+    exports2.invalidateIndexCache = invalidateIndexCache;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var indexer_1 = require_indexer();
+    var retriever_1 = require_retriever();
+    var system_prompt_1 = require_system_prompt();
+    var live_retriever_1 = require_live_retriever();
+    var indexCache = /* @__PURE__ */ new Map();
+    function readProjectMeta(projectDir) {
+      const lines = [];
+      const configPath = path2.join(projectDir, "iacmp.json");
+      if (fs2.existsSync(configPath)) {
+        try {
+          const config = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+          lines.push("## Configura\xE7\xE3o do projeto (iacmp.json)");
+          lines.push(`- Provider: ${config["provider"] ?? "aws"}`);
+          lines.push(`- Regi\xE3o: ${config["region"] ?? "us-east-1"}`);
+          lines.push(`- Linguagem: ${config["language"] ?? "typescript"}`);
+          lines.push(`- Nome: ${config["name"] ?? path2.basename(projectDir)}`);
+          lines.push("");
+        } catch {
+          lines.push("iacmp.json encontrado mas inv\xE1lido.");
+          lines.push("");
+        }
+      } else {
+        lines.push("Nenhum iacmp.json encontrado \u2014 projeto n\xE3o inicializado.");
+        lines.push("");
+      }
+      const stacksDir = path2.join(projectDir, "stacks");
+      if (fs2.existsSync(stacksDir)) {
+        const findStackFiles = (dir) => {
+          const entries = fs2.readdirSync(dir, { withFileTypes: true });
+          const files = [];
+          for (const e of entries) {
+            const full = path2.join(dir, e.name);
+            if (e.isDirectory())
+              files.push(...findStackFiles(full));
+            else if (e.name.endsWith(".ts") || e.name.endsWith(".js"))
+              files.push(full);
+          }
+          return files;
+        };
+        const stackFiles = findStackFiles(stacksDir);
+        if (stackFiles.length > 0) {
+          lines.push("## Stacks existentes");
+          lines.push("IMPORTANTE: Estas s\xE3o as stacks reais do projeto. Ao modificar ou mover recursos, use exatamente estes caminhos \u2014 n\xE3o crie arquivos novos se o destino j\xE1 existe.");
+          for (const filePath of stackFiles) {
+            const rel = path2.relative(projectDir, filePath);
+            lines.push(`
+### ${rel}`);
+            lines.push("```typescript");
+            lines.push(fs2.readFileSync(filePath, "utf-8").trimEnd());
+            lines.push("```");
+          }
+          lines.push("");
+        } else {
+          lines.push("## Stacks existentes\nNenhuma stack encontrada em stacks/.");
+          lines.push("");
+        }
+      } else {
+        lines.push("Diret\xF3rio stacks/ n\xE3o encontrado.");
+        lines.push("");
+      }
+      return lines.join("\n");
+    }
+    function readProjectContext(projectDir) {
+      const lines = [];
+      const configPath = path2.join(projectDir, "iacmp.json");
+      if (fs2.existsSync(configPath)) {
+        try {
+          const config = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+          lines.push("## Configura\xE7\xE3o do projeto (iacmp.json)");
+          lines.push(`- Provider: ${config["provider"] ?? "aws"}`);
+          lines.push(`- Regi\xE3o: ${config["region"] ?? "us-east-1"}`);
+          lines.push(`- Linguagem: ${config["language"] ?? "typescript"}`);
+          lines.push(`- Nome: ${config["name"] ?? path2.basename(projectDir)}`);
+          lines.push("");
+        } catch {
+          lines.push("iacmp.json encontrado mas inv\xE1lido.");
+          lines.push("");
+        }
+      } else {
+        lines.push("Nenhum iacmp.json encontrado \u2014 projeto n\xE3o inicializado.");
+        lines.push("");
+      }
+      const stacksDir = path2.join(projectDir, "stacks");
+      if (fs2.existsSync(stacksDir)) {
+        const findStackFiles = (dir) => {
+          const entries = fs2.readdirSync(dir, { withFileTypes: true });
+          const files = [];
+          for (const e of entries) {
+            const full = path2.join(dir, e.name);
+            if (e.isDirectory())
+              files.push(...findStackFiles(full));
+            else if (e.name.endsWith(".ts") || e.name.endsWith(".js"))
+              files.push(full);
+          }
+          return files;
+        };
+        const stackFiles = findStackFiles(stacksDir);
+        if (stackFiles.length > 0) {
+          lines.push("## Stacks existentes");
+          lines.push('Caminhos completos (use exatamente estes em "deletions"):');
+          for (const filePath of stackFiles) {
+            const rel = path2.relative(projectDir, filePath);
+            const stat = fs2.statSync(filePath);
+            lines.push(`- ${rel} (${(stat.size / 1024).toFixed(1)} KB)`);
+            const content = fs2.readFileSync(filePath, "utf-8");
+            if (content.split("\n").length <= 200) {
+              lines.push("```typescript");
+              lines.push(content);
+              lines.push("```");
+            }
+          }
+          lines.push("");
+        } else {
+          lines.push("## Stacks existentes\nNenhuma stack encontrada em stacks/.");
+          lines.push("");
+        }
+      } else {
+        lines.push("Diret\xF3rio stacks/ n\xE3o encontrado.");
+        lines.push("");
+      }
+      return lines.join("\n");
+    }
+    async function readProjectContextRAG2(projectDir, userQuery, options = {}) {
+      const { anthropicApiKey, useContextualRetrieval, onProgress } = options;
+      try {
+        const indexerOptions = {
+          projectDir,
+          systemPromptTemplate: system_prompt_1.SYSTEM_PROMPT_TEMPLATE,
+          anthropicApiKey,
+          useContextualRetrieval,
+          onProgress: onProgress ?? (() => {
+          })
+        };
+        const indexes = await (0, indexer_1.buildIndexes)(indexerOptions);
+        indexCache.set(projectDir, indexes);
+        const results = (0, retriever_1.retrieve)(indexes, userQuery, {
+          projectK: 5,
+          docsK: 3,
+          knowledgeK: 5,
+          minScore: 0.05
+        });
+        const ragContext = (0, retriever_1.formatRetrievedContext)(results);
+        const meta = readProjectMeta(projectDir);
+        let liveContext = "";
+        if ((0, live_retriever_1.shouldFetchLive)(userQuery)) {
+          liveContext = await (0, live_retriever_1.fetchLive)(userQuery, [], { projectDir });
+        }
+        if (!ragContext && !liveContext) {
+          return readProjectContext(projectDir);
+        }
+        const parts = [meta];
+        if (ragContext)
+          parts.push(ragContext);
+        if (liveContext)
+          parts.push(`## Informa\xE7\xF5es ao vivo
+${liveContext}`);
+        return parts.join("\n");
+      } catch {
+        return readProjectContext(projectDir);
+      }
+    }
+    function invalidateIndexCache(projectDir) {
+      if (projectDir) {
+        indexCache.delete(projectDir);
+      } else {
+        indexCache.clear();
+      }
+    }
+  }
+});
+
+// ../ai/dist/tools/session-store.js
+var require_session_store = __commonJS({
+  "../ai/dist/tools/session-store.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.loadSession = loadSession2;
+    exports2.saveSession = saveSession2;
+    exports2.clearSession = clearSession2;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var crypto = __importStar(require("crypto"));
+    var SESSION_FILE = ".iacmp/session.json";
+    var MAX_MESSAGES = 20;
+    function sessionPath(projectDir) {
+      return path2.join(projectDir, SESSION_FILE);
+    }
+    function hashProject(projectDir) {
+      const stacksDir = path2.join(projectDir, "stacks");
+      if (!fs2.existsSync(stacksDir))
+        return "empty";
+      const findFiles = (dir) => {
+        const entries = fs2.readdirSync(dir, { withFileTypes: true });
+        const files = [];
+        for (const e of entries) {
+          const full = path2.join(dir, e.name);
+          if (e.isDirectory())
+            files.push(...findFiles(full));
+          else if (e.name.endsWith(".ts"))
+            files.push(path2.relative(projectDir, full));
+        }
+        return files.sort();
+      };
+      return crypto.createHash("sha256").update(findFiles(stacksDir).join("\n")).digest("hex").slice(0, 8);
+    }
+    function loadSession2(projectDir) {
+      const file = sessionPath(projectDir);
+      if (!fs2.existsSync(file))
+        return [];
+      try {
+        const data = JSON.parse(fs2.readFileSync(file, "utf-8"));
+        const currentHash = hashProject(projectDir);
+        if (data.projectHash && data.projectHash !== currentHash) {
+          return [];
+        }
+        const messages = data.messages ?? [];
+        for (let i = 0; i < messages.length - 1; i++) {
+          if (messages[i].role === "user" && messages[i + 1].role === "user")
+            return [];
+        }
+        if (messages.length > 0 && messages[messages.length - 1].role === "user")
+          return [];
+        return messages;
+      } catch {
+        return [];
+      }
+    }
+    function saveSession2(projectDir, messages) {
+      const dir = path2.dirname(sessionPath(projectDir));
+      fs2.mkdirSync(dir, { recursive: true });
+      const data = {
+        messages: messages.slice(-MAX_MESSAGES),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        projectHash: hashProject(projectDir)
+      };
+      fs2.writeFileSync(sessionPath(projectDir), JSON.stringify(data, null, 2), "utf-8");
+    }
+    function clearSession2(projectDir) {
+      const file = sessionPath(projectDir);
+      if (fs2.existsSync(file))
+        fs2.unlinkSync(file);
+    }
+  }
+});
+
+// ../ai/dist/tools/response-cache.js
+var require_response_cache = __commonJS({
+  "../ai/dist/tools/response-cache.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.hashPrompt = hashPrompt;
+    exports2.getCached = getCached2;
+    exports2.setCache = setCache2;
+    exports2.clearCache = clearCache2;
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var crypto_1 = require("crypto");
+    var CACHE_FILE = ".iacmp/cache.json";
+    var TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+    function cachePath(projectDir) {
+      return path2.join(projectDir, CACHE_FILE);
+    }
+    function loadCache(projectDir) {
+      const file = cachePath(projectDir);
+      if (!fs2.existsSync(file))
+        return { entries: [] };
+      try {
+        return JSON.parse(fs2.readFileSync(file, "utf-8"));
+      } catch {
+        return { entries: [] };
+      }
+    }
+    function saveCache(projectDir, data) {
+      const dir = path2.dirname(cachePath(projectDir));
+      fs2.mkdirSync(dir, { recursive: true });
+      fs2.writeFileSync(cachePath(projectDir), JSON.stringify(data, null, 2), "utf-8");
+    }
+    function hashPrompt(prompt) {
+      return (0, crypto_1.createHash)("sha256").update(prompt.trim()).digest("hex").slice(0, 16);
+    }
+    function getCached2(projectDir, prompt) {
+      const hash = hashPrompt(prompt);
+      const data = loadCache(projectDir);
+      const entry = data.entries.find((e) => e.hash === hash);
+      if (!entry)
+        return null;
+      const age = Date.now() - new Date(entry.createdAt).getTime();
+      if (age > TTL_MS)
+        return null;
+      return entry.response;
+    }
+    function setCache2(projectDir, prompt, response) {
+      const hash = hashPrompt(prompt);
+      const data = loadCache(projectDir);
+      data.entries = data.entries.filter((e) => e.hash !== hash);
+      data.entries.push({
+        hash,
+        prompt: prompt.slice(0, 200),
+        response,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      saveCache(projectDir, data);
+    }
+    function clearCache2(projectDir) {
+      const file = cachePath(projectDir);
+      if (fs2.existsSync(file))
+        fs2.unlinkSync(file);
+    }
+  }
+});
+
+// ../ai/dist/index.js
+var require_dist = __commonJS({
+  "../ai/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.buildIndexes = exports2.formatRetrievedContext = exports2.retrieve = exports2.bm25Search = exports2.buildBM25Index = exports2.Contextualizer = exports2.chunkKnowledgeFile = exports2.chunkIacmpDocs = exports2.chunkStackFile = exports2.clearCache = exports2.setCache = exports2.getCached = exports2.clearSession = exports2.saveSession = exports2.loadSession = exports2.invalidateIndexCache = exports2.readProjectContextAsync = exports2.readProjectContextRAG = exports2.readProjectMeta = exports2.readProjectContext = exports2.NATIVE_PROVIDERS = exports2.assertValidProvider = exports2.assertValidStackName = exports2.errMessage = exports2.isWithin = exports2.safeJoin = exports2.runSynth = exports2.renderAndConfirm = exports2.deleteFiles = exports2.writeGeneratedFiles = exports2.printStreamChunk = exports2.printNextSteps = exports2.printWarnings = exports2.printExplanation = exports2.stopThinking = exports2.printThinking = exports2.ChatSession = exports2.validateTypeScript = exports2.extractResponse = exports2.buildSystemPrompt = exports2.SYSTEM_PROMPT_TEMPLATE = exports2.SYSTEM_PROMPT = exports2.CopilotProvider = exports2.AnthropicProvider = void 0;
+    var anthropic_1 = require_anthropic();
+    Object.defineProperty(exports2, "AnthropicProvider", { enumerable: true, get: function() {
+      return anthropic_1.AnthropicProvider;
+    } });
+    var copilot_1 = require_copilot();
+    Object.defineProperty(exports2, "CopilotProvider", { enumerable: true, get: function() {
+      return copilot_1.CopilotProvider;
+    } });
+    var system_prompt_1 = require_system_prompt();
+    Object.defineProperty(exports2, "SYSTEM_PROMPT", { enumerable: true, get: function() {
+      return system_prompt_1.SYSTEM_PROMPT;
+    } });
+    Object.defineProperty(exports2, "SYSTEM_PROMPT_TEMPLATE", { enumerable: true, get: function() {
+      return system_prompt_1.SYSTEM_PROMPT_TEMPLATE;
+    } });
+    Object.defineProperty(exports2, "buildSystemPrompt", { enumerable: true, get: function() {
+      return system_prompt_1.buildSystemPrompt;
+    } });
+    var code_extractor_1 = require_code_extractor();
+    Object.defineProperty(exports2, "extractResponse", { enumerable: true, get: function() {
+      return code_extractor_1.extractResponse;
+    } });
+    var validator_1 = require_validator();
+    Object.defineProperty(exports2, "validateTypeScript", { enumerable: true, get: function() {
+      return validator_1.validateTypeScript;
+    } });
+    var session_1 = require_session();
+    Object.defineProperty(exports2, "ChatSession", { enumerable: true, get: function() {
+      return session_1.ChatSession;
+    } });
+    var renderer_1 = require_renderer();
+    Object.defineProperty(exports2, "printThinking", { enumerable: true, get: function() {
+      return renderer_1.printThinking;
+    } });
+    Object.defineProperty(exports2, "stopThinking", { enumerable: true, get: function() {
+      return renderer_1.stopThinking;
+    } });
+    Object.defineProperty(exports2, "printExplanation", { enumerable: true, get: function() {
+      return renderer_1.printExplanation;
+    } });
+    Object.defineProperty(exports2, "printWarnings", { enumerable: true, get: function() {
+      return renderer_1.printWarnings;
+    } });
+    Object.defineProperty(exports2, "printNextSteps", { enumerable: true, get: function() {
+      return renderer_1.printNextSteps;
+    } });
+    Object.defineProperty(exports2, "printStreamChunk", { enumerable: true, get: function() {
+      return renderer_1.printStreamChunk;
+    } });
+    var file_writer_1 = require_file_writer();
+    Object.defineProperty(exports2, "writeGeneratedFiles", { enumerable: true, get: function() {
+      return file_writer_1.writeGeneratedFiles;
+    } });
+    var file_deleter_1 = require_file_deleter();
+    Object.defineProperty(exports2, "deleteFiles", { enumerable: true, get: function() {
+      return file_deleter_1.deleteFiles;
+    } });
+    var diff_renderer_1 = require_diff_renderer();
+    Object.defineProperty(exports2, "renderAndConfirm", { enumerable: true, get: function() {
+      return diff_renderer_1.renderAndConfirm;
+    } });
+    var synth_runner_1 = require_synth_runner();
+    Object.defineProperty(exports2, "runSynth", { enumerable: true, get: function() {
+      return synth_runner_1.runSynth;
+    } });
+    var safe_path_1 = require_safe_path();
+    Object.defineProperty(exports2, "safeJoin", { enumerable: true, get: function() {
+      return safe_path_1.safeJoin;
+    } });
+    Object.defineProperty(exports2, "isWithin", { enumerable: true, get: function() {
+      return safe_path_1.isWithin;
+    } });
+    Object.defineProperty(exports2, "errMessage", { enumerable: true, get: function() {
+      return safe_path_1.errMessage;
+    } });
+    Object.defineProperty(exports2, "assertValidStackName", { enumerable: true, get: function() {
+      return safe_path_1.assertValidStackName;
+    } });
+    Object.defineProperty(exports2, "assertValidProvider", { enumerable: true, get: function() {
+      return safe_path_1.assertValidProvider;
+    } });
+    Object.defineProperty(exports2, "NATIVE_PROVIDERS", { enumerable: true, get: function() {
+      return safe_path_1.NATIVE_PROVIDERS;
+    } });
+    var context_reader_1 = require_context_reader();
+    Object.defineProperty(exports2, "readProjectContext", { enumerable: true, get: function() {
+      return context_reader_1.readProjectContext;
+    } });
+    Object.defineProperty(exports2, "readProjectMeta", { enumerable: true, get: function() {
+      return context_reader_1.readProjectMeta;
+    } });
+    Object.defineProperty(exports2, "readProjectContextRAG", { enumerable: true, get: function() {
+      return context_reader_1.readProjectContextRAG;
+    } });
+    Object.defineProperty(exports2, "readProjectContextAsync", { enumerable: true, get: function() {
+      return context_reader_1.readProjectContextRAG;
+    } });
+    Object.defineProperty(exports2, "invalidateIndexCache", { enumerable: true, get: function() {
+      return context_reader_1.invalidateIndexCache;
+    } });
+    var session_store_1 = require_session_store();
+    Object.defineProperty(exports2, "loadSession", { enumerable: true, get: function() {
+      return session_store_1.loadSession;
+    } });
+    Object.defineProperty(exports2, "saveSession", { enumerable: true, get: function() {
+      return session_store_1.saveSession;
+    } });
+    Object.defineProperty(exports2, "clearSession", { enumerable: true, get: function() {
+      return session_store_1.clearSession;
+    } });
+    var response_cache_1 = require_response_cache();
+    Object.defineProperty(exports2, "getCached", { enumerable: true, get: function() {
+      return response_cache_1.getCached;
+    } });
+    Object.defineProperty(exports2, "setCache", { enumerable: true, get: function() {
+      return response_cache_1.setCache;
+    } });
+    Object.defineProperty(exports2, "clearCache", { enumerable: true, get: function() {
+      return response_cache_1.clearCache;
+    } });
+    var chunker_1 = require_chunker();
+    Object.defineProperty(exports2, "chunkStackFile", { enumerable: true, get: function() {
+      return chunker_1.chunkStackFile;
+    } });
+    Object.defineProperty(exports2, "chunkIacmpDocs", { enumerable: true, get: function() {
+      return chunker_1.chunkIacmpDocs;
+    } });
+    Object.defineProperty(exports2, "chunkKnowledgeFile", { enumerable: true, get: function() {
+      return chunker_1.chunkKnowledgeFile;
+    } });
+    var contextualizer_1 = require_contextualizer();
+    Object.defineProperty(exports2, "Contextualizer", { enumerable: true, get: function() {
+      return contextualizer_1.Contextualizer;
+    } });
+    var bm25_1 = require_bm25();
+    Object.defineProperty(exports2, "buildBM25Index", { enumerable: true, get: function() {
+      return bm25_1.buildBM25Index;
+    } });
+    Object.defineProperty(exports2, "bm25Search", { enumerable: true, get: function() {
+      return bm25_1.bm25Search;
+    } });
+    var retriever_1 = require_retriever();
+    Object.defineProperty(exports2, "retrieve", { enumerable: true, get: function() {
+      return retriever_1.retrieve;
+    } });
+    Object.defineProperty(exports2, "formatRetrievedContext", { enumerable: true, get: function() {
+      return retriever_1.formatRetrievedContext;
+    } });
+    var indexer_1 = require_indexer();
+    Object.defineProperty(exports2, "buildIndexes", { enumerable: true, get: function() {
+      return indexer_1.buildIndexes;
+    } });
+  }
+});
+
+// bin/chat.js
+var readline = require("readline");
+var path = require("path");
+var fs = require("fs");
+(function loadEnv() {
+  const cwd2 = process.env.IACMP_CWD || process.cwd();
+  const envPath = path.resolve(cwd2, ".env");
+  if (!fs.existsSync(envPath)) return;
+  const lines = fs.readFileSync(envPath, "utf8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const val = trimmed.slice(eq + 1).trim();
+    if (key) process.env[key] = val;
+  }
+})();
+var Module = require("module");
+var _orig = Module._resolveFilename.bind(Module);
+var cliDir = path.resolve(__dirname, "..");
+var searchRoots = [cliDir, path.resolve(cliDir, "..", "..")];
+Module._resolveFilename = function(req, parent, isMain, opts) {
+  if (req.startsWith("@iacmp/")) {
+    try {
+      return _orig(req, parent, isMain, opts);
+    } catch {
+    }
+    for (const root of searchRoots) {
+      try {
+        return _orig(req, { id: path.join(root, "_fake.js"), filename: path.join(root, "_fake.js") }, isMain, opts);
+      } catch {
+      }
+    }
+    const pkgName = req.replace("@iacmp/", "");
+    const candidates = [
+      path.resolve(cliDir, "..", pkgName, "dist", "index.js"),
+      path.resolve(cliDir, "node_modules", req, "dist", "index.js")
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+  }
+  return _orig(req, parent, isMain, opts);
+};
+var chalk = require("chalk");
+var {
+  AnthropicProvider,
+  CopilotProvider,
+  ChatSession,
+  extractResponse,
+  validateTypeScript,
+  writeGeneratedFiles,
+  deleteFiles,
+  runSynth,
+  readProjectContextRAG,
+  printExplanation,
+  printWarnings,
+  printNextSteps,
+  buildSystemPrompt,
+  loadSession,
+  saveSession,
+  clearSession,
+  getCached,
+  setCache,
+  clearCache
+} = require_dist();
+var cwd = process.env.IACMP_CWD || process.cwd();
+var iacProvider = process.env.IACMP_PROVIDER || "aws";
+var dryRun = process.env.IACMP_DRYRUN === "1";
+var rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: process.stdin.isTTY,
+  crlfDelay: Infinity
+});
+var _lineQueue = [];
+var _lineWaiters = [];
+var _rlDone = false;
+rl.on("line", (line) => {
+  const trimmed = line.trim();
+  if (_lineWaiters.length > 0) {
+    _lineWaiters.shift()(trimmed);
+  } else {
+    _lineQueue.push(trimmed);
+  }
+});
+rl.on("close", () => {
+  _rlDone = true;
+  while (_lineWaiters.length > 0) _lineWaiters.shift()("");
+});
+function ask(question) {
+  process.stdout.write(question);
+  return new Promise((resolve) => {
+    if (_lineQueue.length > 0) {
+      resolve(_lineQueue.shift());
+    } else if (_rlDone) {
+      resolve("");
+    } else {
+      _lineWaiters.push(resolve);
+    }
+  });
+}
+function resolveProvider() {
+  if (process.env.ANTHROPIC_API_KEY) return new AnthropicProvider(process.env.ANTHROPIC_API_KEY);
+  if (process.env.GITHUB_TOKEN) return new CopilotProvider(process.env.GITHUB_TOKEN);
+  throw new Error("Configure ANTHROPIC_API_KEY no .env do projeto");
+}
+function createContextualProvider(base, projectContext) {
+  const systemPrompt = buildSystemPrompt(projectContext);
+  return {
+    name: base.name,
+    chat: (msgs) => base.chat([{ role: "system", content: systemPrompt }, ...msgs]),
+    stream: (msgs, onChunk) => base.stream([{ role: "system", content: systemPrompt }, ...msgs], onChunk)
+  };
+}
+async function runGeneration(provider, session, lastPrompt, projectContext) {
+  let acted = false;
+  const contextHash = projectContext ? require("crypto").createHash("md5").update(projectContext).digest("hex").slice(0, 8) : "";
+  const cacheKey = contextHash ? `${lastPrompt}__ctx:${contextHash}` : lastPrompt;
+  const cached = getCached(cwd, cacheKey);
+  let raw;
+  let fromCache = false;
+  if (cached) {
+    try {
+      extractResponse(cached);
+      process.stderr.write(chalk.dim("  \u21A9 resposta do cache\n"));
+      raw = cached;
+      fromCache = true;
+      session.addAssistantMessage(raw);
+    } catch {
+      clearCache(cwd, cacheKey);
+    }
+  }
+  if (!raw) {
+    process.stderr.write(chalk.dim("Gerando...\n"));
+    const chunks = [];
+    try {
+      await provider.stream(session.getMessages(), (chunk) => chunks.push(chunk));
+    } catch (err) {
+      process.stderr.write(chalk.red("Erro: " + err.message + "\n"));
+      process.stderr.write(chalk.dim("Sua mensagem n\xE3o foi salva na sess\xE3o \u2014 pode repetir o pedido.\n"));
+      return;
+    }
+    raw = chunks.join("");
+    session.addAssistantMessage(raw);
+  }
+  let parsed;
+  try {
+    parsed = extractResponse(raw);
+  } catch {
+    console.log("\n" + raw.trim() + "\n");
+    return true;
+  }
+  if (!fromCache) {
+    setCache(cwd, cacheKey, raw);
+  }
+  const tsFiles = parsed.files.filter((f) => f.path.endsWith(".ts"));
+  if (tsFiles.length > 0) {
+    const result = validateTypeScript(tsFiles, cwd);
+    if (!result.valid) {
+      process.stderr.write(chalk.dim("Valida\xE7\xE3o falhou \u2014 corrigindo...\n"));
+      session.addUserMessage(`Erros TypeScript:
+${result.errors.join("\n")}
+
+Corrija e retorne o JSON completo.`);
+      const retryChunks = [];
+      try {
+        await provider.stream(session.getMessages(), (chunk) => retryChunks.push(chunk));
+        const retryRaw = retryChunks.join("");
+        session.addAssistantMessage(retryRaw);
+        try {
+          parsed = extractResponse(retryRaw);
+        } catch {
+        }
+      } catch (err) {
+        process.stderr.write(chalk.red("Erro no retry: " + err.message + "\n"));
+      }
+    }
+  }
+  printExplanation(parsed.explanation);
+  printWarnings(parsed.warnings);
+  if (parsed.deletions && parsed.deletions.length > 0) {
+    await deleteFiles(parsed.deletions, cwd, iacProvider, ask);
+    acted = true;
+  }
+  if (parsed.files.length > 0) {
+    await writeGeneratedFiles(parsed.files, cwd, dryRun, ask);
+    acted = true;
+  }
+  printNextSteps(parsed.nextSteps);
+  return true;
+}
+async function main() {
+  const previous = loadSession(cwd);
+  const session = new ChatSession();
+  if (previous.length > 0) {
+    const contaminated = previous.some((msg) => {
+      if (msg.role !== "assistant") return false;
+      try {
+        const parsed = JSON.parse(msg.content);
+        return typeof parsed.explanation === "string" && parsed.explanation.toLowerCase().includes("standalone");
+      } catch {
+        return false;
+      }
+    });
+    if (contaminated) {
+      clearSession(cwd);
+      clearCache(cwd);
+      console.log(chalk.dim("\n  Sess\xE3o anterior descartada (contexto desatualizado)"));
+    } else {
+      for (const msg of previous) {
+        if (msg.role === "user") session.addUserMessage(msg.content);
+        else session.addAssistantMessage(msg.content);
+      }
+      console.log(chalk.dim(`
+  Sess\xE3o anterior carregada (${previous.length} mensagens)`));
+    }
+  }
+  console.log(chalk.cyan.bold("\niacmp ai \u2014 Modo Chat Interativo"));
+  console.log(chalk.dim("Comandos: /sair, /quit \u2014 encerra | /limpar \u2014 limpa sess\xE3o e cache\n"));
+  let aiProvider;
+  try {
+    aiProvider = resolveProvider();
+  } catch (err) {
+    console.error(chalk.red(err.message));
+    rl.close();
+    process.exit(1);
+  }
+  while (true) {
+    const input = await ask(chalk.bold("> Voc\xEA: "));
+    if (!input) {
+      if (_rlDone) break;
+      continue;
+    }
+    if (input === "/sair" || input === "/quit") {
+      console.log(chalk.dim("\nEncerrando chat."));
+      break;
+    }
+    if (input === "/limpar") {
+      session.clear();
+      clearSession(cwd);
+      clearCache(cwd);
+      console.log(chalk.dim("Sess\xE3o e cache limpos.\n"));
+      continue;
+    }
+    console.log("");
+    const freshContext = await readProjectContextRAG(cwd, input);
+    const isFirstMessage = session.getMessages().length === 0;
+    const hasStacks = freshContext.includes("Stacks existentes");
+    const userMessageContent = isFirstMessage && hasStacks ? `${input}
+
+[Contexto do projeto]
+${freshContext}` : input;
+    session.addUserMessage(userMessageContent);
+    const provider = createContextualProvider(aiProvider, freshContext);
+    const responded = await runGeneration(provider, session, input, freshContext);
+    if (responded) {
+      saveSession(cwd, session.getMessages());
+    } else {
+      session.removeLast();
+    }
+    console.log("");
+  }
+  rl.close();
+}
+main().catch((err) => {
+  console.error(chalk.red("Erro: " + err.message));
+  process.exit(1);
+});