fg-tracker-mcp 0.4.0 → 0.6.0

package/dist/infra/tools.js

@@ -0,0 +1,700 @@
+/**
+ * Tools de identificação e transferência de infraestrutura (CONTRATO.md §27.3, §27.9;
+ * plano-infraestrutura.md §5–§7). Nenhuma tool altera recursos na AWS: a descoberta usa só
+ * chamadas de leitura e as tools de PR escrevem arquivos locais e devolvem comandos git/gh.
+ */
+import { stat, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { z } from 'zod';
+import { TrackApiError } from '../client.js';
+import { compact, guard, json, text } from '../format.js';
+import { ENVIRONMENT_LABEL, describeAwsError, detectEnvironments, detectRegionsInUse, discoverAws, readStackOutputs, serviceLabel } from './aws.js';
+import { DOC_PATH, GUARD_PATH, GUARD_SCRIPT, HANDOVER_DIR, HANDOVER_README, LOCK_PATH, PATCH_PATH, buildHandoverEdits, formatChanges, handoverDoc, handoverReadme, lockFile, writeHandoverFiles, } from './handover.js';
+import { analyzeIac, formatIac } from './iac.js';
+import { buildInstrumentPlan } from './instrument.js';
+const projectIdSchema = z.string().uuid().describe('ID (uuid) do projeto — veja track_list_projects');
+const regionSchema = z.string().regex(/^[a-z]{2}(-gov)?-[a-z]+-\d$/, 'região AWS inválida (ex.: us-east-1)');
+const SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
+const PILLAR_LABEL = { performance: 'Performance', security: 'Segurança', scalability: 'Escalabilidade', reliability: 'Confiabilidade' };
+function listOf(value) {
+    if (Array.isArray(value))
+        return value;
+    const items = value?.items;
+    return Array.isArray(items) ? items : [];
+}
+function usd(v) {
+    return v === null || v === undefined || Number.isNaN(v) ? '—' : `US$ ${v >= 100 ? Math.round(v) : v.toFixed(2)}`;
+}
+async function resolveRoot(path) {
+    const root = resolve(process.cwd(), path ?? '.');
+    const s = await stat(root).catch(() => null);
+    if (!s?.isDirectory())
+        throw new Error(`Diretório não encontrado: ${root}. Passe \`path\` com o caminho absoluto do repositório.`);
+    return root;
+}
+function shellQuote(s) {
+    return /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+}
+export function registerInfraTools(server, client, version) {
+    const base = (projectId) => `/v1/projects/${projectId}/infra`;
+    const getProject = (projectId) => client.get(`/v1/projects/${projectId}`);
+    const getConnections = async (projectId) => {
+        try {
+            return listOf(await client.get(`${base(projectId)}/connections`));
+        }
+        catch {
+            return [];
+        }
+    };
+    const infraRouteMissing = (err) => err instanceof TrackApiError && err.status === 404 && /Cannot (GET|POST)/.test(err.message);
+    const wrapInfra = (err) => {
+        if (infraRouteMissing(err)) {
+            throw new TrackApiError(`A API em ${client.baseUrl} não expõe as rotas de infraestrutura (/v1/projects/:id/infra/*). Atualize a API do FG Tracker ou verifique INFRA_ENABLED.`, 404, err.path);
+        }
+        throw err;
+    };
+    /* 0 ---------------- detectar contas/ambientes/regiões ---------------- */
+    server.registerTool('infra_detect_environments', {
+        title: 'Detectar contas, ambientes e regiões AWS (credenciais locais)',
+        description: 'Somente leitura e local: lista os perfis de ~/.aws/config e ~/.aws/credentials (+ AWS_PROFILE e a cadeia padrão), chama sts:GetCallerIdentity em cada um (até 10; falhas são puladas com o motivo), deduplica por conta, classifica o ambiente pelo nome do perfil/ARN (prod/prd → production; stag/hml/homolog/qa → staging; dev/sandbox/test → development; senão null = pergunte ao usuário) e detecta as regiões em uso (índices do Resource Explorer ou sondagem com CloudFormation ListStacks + Tagging GetResources). Não chama a API do FG Tracker. Depois: confirme com o usuário e chame infra_connect_account por ambiente.',
+        inputSchema: {
+            profiles: z.array(z.string().min(1)).max(20).optional().describe('Perfis a testar (default: todos os perfis encontrados, até 10)'),
+            includeRegions: z.array(regionSchema).max(20).optional().describe('Regiões extras a sempre considerar além das candidatas'),
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ profiles, includeRegions }) => guard(async () => {
+        const result = await detectEnvironments({ profiles, includeRegions });
+        const accounts = result.accounts.map((a) => ({
+            profile: a.profile,
+            otherProfiles: a.otherProfiles,
+            accountId: a.accountId,
+            arn: a.arn,
+            environment: a.environment,
+            regionsInUse: a.regionsInUse,
+            stacksPerRegion: a.stacksPerRegion,
+            regionSource: a.regionSource,
+            suggestedConnectionName: a.suggestedConnectionName,
+            warnings: a.warnings,
+        }));
+        const lines = [];
+        if (!accounts.length) {
+            lines.push(`Nenhuma conta AWS acessível com as credenciais locais (perfis encontrados: ${result.profilesFound.length ? result.profilesFound.join(', ') : 'nenhum'}).`, 'Peça ao usuário para rodar `aws sso login --profile <perfil>` ou `aws configure` e chame de novo (ou passe `profiles`).');
+        }
+        else {
+            lines.push(`${accounts.length} conta(s) AWS detectada(s):`);
+            for (const a of accounts) {
+                const env = a.environment ? `${a.environment} (${ENVIRONMENT_LABEL[a.environment]})` : 'ambiente desconhecido — pergunte ao usuário';
+                const stacks = Object.entries(a.stacksPerRegion).map(([r, n]) => `${r}:${n}`).join(', ');
+                lines.push(`- conta ${a.accountId} · perfil ${a.profile ?? '(cadeia padrão)'}${a.otherProfiles.length ? ` (também: ${a.otherProfiles.join(', ')})` : ''} · ${env} · regiões ${a.regionsInUse.length ? a.regionsInUse.join(', ') : 'nenhuma detectada'}${stacks ? ` · stacks ${stacks}` : ''} · fonte ${a.regionSource}`);
+            }
+        }
+        if (result.skipped.length)
+            lines.push('', 'Perfis ignorados:', ...result.skipped.map((s) => `- ${s.profile ?? '(cadeia padrão)'}: ${s.reason}`));
+        lines.push('', 'Próximos passos:', '1. Mostre a lista ao usuário e confirme quais contas/ambientes conectar (pergunte o ambiente só quando for desconhecido; confirme as regiões).', '2. Para cada ambiente escolhido: `infra_connect_account { projectId, level, name: "<nome> · <Ambiente>", environment, regions, profile }` → peça confirmação → rode o comando de deploy devolvido → `infra_verify_connection { projectId, connectionId, profile }` → `infra_discover { projectId, profile, regions }`.');
+        return json({ accounts, skipped: result.skipped, profilesFound: result.profilesFound }, lines.join('\n'));
+    }));
+    /* 1 ---------------- conectar conta ---------------- */
+    server.registerTool('infra_connect_account', {
+        title: 'Conectar conta AWS ao projeto',
+        description: 'Cria a conexão AWS do projeto (POST /v1/projects/:id/infra/connections, mode role), salva o template em ./fg-tracker-connection-<ambiente>.json e devolve o comando exato `aws cloudformation deploy ... --profile <perfil> --region <região>`. Sem `regions`, detecta as regiões em uso com o perfil (somente leitura). Não cria nada na AWS: o agente deve pedir confirmação ao usuário antes de rodar o comando. Depois: infra_verify_connection.',
+        inputSchema: {
+            projectId: projectIdSchema,
+            level: z.enum(['read', 'operate']).describe('read = diagrama, monitoramento, custo e notas; operate = também alterar infra e implantar releases pelos stacks transferidos'),
+            environment: z.enum(['production', 'staging', 'development']).optional().describe('Ambiente da conta (veja infra_detect_environments)'),
+            regions: z.array(regionSchema).min(1).max(20).optional().describe('Regiões usadas (default: detectadas com o perfil; a primeira recebe as roles)'),
+            name: z.string().min(1).max(120).optional().describe('Nome da conexão (ex.: "<nome> · Produção"; default: <slug>-<ambiente>)'),
+            profile: z.string().min(1).optional().describe('Perfil do ~/.aws da conta (usado na detecção de regiões e no comando de deploy)'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ projectId, level, environment, regions, name, profile }) => guard(async () => {
+        const project = await getProject(projectId);
+        const notes = [];
+        let useRegions = regions;
+        if (!useRegions?.length) {
+            try {
+                const detected = await detectRegionsInUse({ profile });
+                useRegions = detected.regionsInUse.slice(0, 20);
+                notes.push(`Regiões detectadas (${detected.source}) com ${profile ? `o perfil ${profile}` : 'a cadeia padrão'}: ${useRegions.length ? useRegions.join(', ') : 'nenhuma'}.`, ...detected.warnings);
+            }
+            catch (err) {
+                notes.push(`Detecção de regiões falhou: ${describeAwsError(err)}.`);
+            }
+            if (!useRegions?.length) {
+                useRegions = [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];
+                notes.push(`Usando ${useRegions[0]} — confirme as regiões com o usuário (dá para editar a conexão depois).`);
+            }
+        }
+        const res = await client
+            .post(`${base(projectId)}/connections`, {
+            name: name ?? `${project.slug}-${environment ?? 'aws'}`,
+            level,
+            ...(environment ? { environment } : {}),
+            regions: useRegions,
+            mode: 'role',
+        })
+            .catch(wrapInfra);
+        const connectionId = res.connection?.id;
+        const stackName = `fg-tracker-${project.slug}`;
+        const tpl = res.template ?? {};
+        const region = useRegions[0] ?? 'us-east-1';
+        const profileFlag = profile ? ` --profile ${shellQuote(profile)}` : '';
+        const lines = [
+            `Conexão criada: ${res.connection?.name ?? name ?? stackName} (id ${connectionId}) · nível ${level}${environment ? ` · ${environment}` : ''} · regiões ${useRegions.join(', ')} · status ${res.connection?.status ?? 'pending'}.`,
+            ...notes,
+            res.externalId ? `External ID: ${res.externalId} (já embutido no template; não precisa ser segredo, mas não o publique).` : '',
+            '',
+        ];
+        let deployCommand = null;
+        if (tpl.body !== undefined && tpl.body !== null) {
+            const body = typeof tpl.body === 'string' ? tpl.body : JSON.stringify(tpl.body, null, 2);
+            const suffix = environment ?? (connectionId ? connectionId.slice(0, 8) : 'aws');
+            const file = join(process.cwd(), `fg-tracker-connection-${suffix}.json`);
+            await writeFile(file, body.endsWith('\n') ? body : `${body}\n`, 'utf8');
+            let params = [];
+            try {
+                const parsed = (typeof tpl.body === 'string' ? JSON.parse(tpl.body) : tpl.body);
+                params = Object.keys(parsed.Parameters ?? {});
+            }
+            catch {
+                /* template YAML */
+            }
+            if (tpl.cliCommand) {
+                deployCommand = tpl.cliCommand
+                    .split('\n')
+                    .filter(Boolean)
+                    .map((line) => `${line.replace(/--template-file\s+\S+/, `--template-file ${shellQuote(file)}`)}${profile && !/--profile\b/.test(line) ? profileFlag : ''}`)
+                    .join('\n');
+            }
+            else {
+                const overrides = res.externalId ? params.filter((p) => /external\s*id/i.test(p)).map((p) => `${p}=${res.externalId}`) : [];
+                deployCommand = [
+                    'aws cloudformation deploy',
+                    `  --template-file ${shellQuote(file)}`,
+                    `  --stack-name ${stackName}`,
+                    '  --capabilities CAPABILITY_NAMED_IAM',
+                    `  --region ${region}`,
+                    ...(profile ? [`  --profile ${shellQuote(profile)}`] : []),
+                    ...(overrides.length ? [`  --parameter-overrides ${overrides.join(' ')}`] : []),
+                ].join(' \\\n');
+            }
+            lines.push(`Template salvo em \`${file}\` (não commite).`);
+        }
+        else if (tpl.cliCommand) {
+            deployCommand = tpl.cliCommand.split('\n').filter(Boolean).map((line) => `${line}${profile && !/--profile\b/.test(line) ? profileFlag : ''}`).join('\n');
+        }
+        lines.push(`## Criar o stack de conexão \`${stackName}\` (conta${profile ? ` do perfil ${profile}` : ''}, região ${region})`);
+        if (deployCommand) {
+            lines.push('**Peça confirmação explícita ao usuário antes de rodar** — é a única mudança na AWS do fluxo (cria as roles IAM do FG Tracker). Mostre o comando e, só com o "sim", rode:', '```bash', deployCommand, '```');
+        }
+        else {
+            lines.push('A API não devolveu template nem comando. Baixe-o na tela Infraestrutura → Conexões.');
+        }
+        if (tpl.quickCreateUrl)
+            lines.push('', 'Alternativa pelo console (o usuário abre e cria):', tpl.quickCreateUrl);
+        lines.push('', '## Depois do stack criado (CREATE_COMPLETE / sem mudanças)', `1. \`infra_verify_connection { projectId: "${projectId}", connectionId: "${connectionId}"${profile ? `, profile: "${profile}"` : ''} }\` — os ARNs das roles são lidos dos outputs do stack \`${stackName}\` (somente leitura).`, `2. \`infra_discover { projectId: "${projectId}"${profile ? `, profile: "${profile}"` : ''}, regions: ${JSON.stringify(useRegions)} }\`.`);
+        return text(lines.filter((l, i) => l !== '' || lines[i - 1] !== '').join('\n'));
+    }));
+    /* 2 ---------------- verificar conexão ---------------- */
+    server.registerTool('infra_verify_connection', {
+        title: 'Verificar conexão AWS',
+        description: 'Testa a conexão (POST .../infra/connections/:connectionId/verify: AssumeRole + GetCallerIdentity no FG Tracker). Sem ARNs informados, lê os outputs do stack local `fg-tracker-<slug>` com DescribeStacks (somente leitura, credenciais locais) e os envia.',
+        inputSchema: {
+            projectId: projectIdSchema,
+            connectionId: z.string().uuid().describe('id devolvido por infra_connect_account'),
+            readRoleArn: z.string().startsWith('arn:').optional(),
+            operateRoleArn: z.string().startsWith('arn:').optional(),
+            executionRoleArn: z.string().startsWith('arn:').optional(),
+            stackName: z.string().optional().describe('Stack de conexão (default fg-tracker-<slug>)'),
+            region: regionSchema.optional().describe('Região do stack (default: primeira região da conexão)'),
+            profile: z.string().optional().describe('Perfil do ~/.aws para ler os outputs'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ projectId, connectionId, readRoleArn, operateRoleArn, executionRoleArn, stackName, region, profile }) => guard(async () => {
+        const notes = [];
+        const body = {};
+        if (readRoleArn)
+            body.readRoleArn = readRoleArn;
+        if (operateRoleArn)
+            body.operateRoleArn = operateRoleArn;
+        if (executionRoleArn)
+            body.executionRoleArn = executionRoleArn;
+        if (!Object.keys(body).length) {
+            const project = await getProject(projectId);
+            const conn = (await getConnections(projectId)).find((c) => c.id === connectionId);
+            const stack = stackName ?? `fg-tracker-${project.slug}`;
+            const r = region ?? conn?.regions?.[0] ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1';
+            try {
+                const outputs = await readStackOutputs(stack, r, profile);
+                const entries = Object.entries(outputs).filter(([, v]) => v.startsWith('arn:'));
+                const pick = (re, not) => entries.find(([k]) => re.test(k) && !(not?.test(k)))?.[1];
+                const read = pick(/read/i, /operate|exec/i);
+                const operate = pick(/operate/i);
+                const exec = pick(/exec/i);
+                if (read)
+                    body.readRoleArn = read;
+                if (operate)
+                    body.operateRoleArn = operate;
+                if (exec)
+                    body.executionRoleArn = exec;
+                notes.push(`Outputs de \`${stack}\` (${r}): ${Object.keys(body).length ? Object.entries(body).map(([k, v]) => `${k}=${v}`).join(', ') : 'nenhum ARN de role reconhecido'}.`);
+            }
+            catch (err) {
+                notes.push(`Não consegui ler o stack \`${stack}\` em ${r}: ${describeAwsError(err)}. Verificando sem ARNs (a API usa o que já tem gravado).`);
+            }
+        }
+        const result = await client.post(`${base(projectId)}/connections/${connectionId}/verify`, body).catch(wrapInfra);
+        const status = result.status ?? result.connection?.status;
+        const accountId = result.accountId ?? result.connection?.accountId;
+        const ok = status === 'connected';
+        return json(compact(result), [
+            ...notes,
+            ok ? `Conexão OK — conta ${accountId ?? '?'}.` : `Conexão com status ${status ?? '?'}${result.statusError ? `: ${result.statusError}` : ''}.`,
+            ok ? `Próximo passo: infra_discover { projectId: "${projectId}" }.` : 'Confira se o stack terminou (CREATE_COMPLETE), a região e se as roles confiam no principal do FG Tracker com o External ID.',
+        ].join('\n'));
+    }));
+    /* 3 ---------------- descoberta local ---------------- */
+    server.registerTool('infra_discover', {
+        title: 'Descobrir recursos AWS (credenciais locais)',
+        description: 'Inventário com as credenciais AWS do usuário (cadeia padrão ou `profile`), só leitura: GetCallerIdentity; por região Resource Explorer (Search "*", até 2000) ou Tagging API; CloudFormation ListStacks/ListStackResources para stacks e logical ids. Envia o snapshot para POST /v1/projects/:id/infra/snapshots e devolve resumo por serviço/região.',
+        inputSchema: {
+            projectId: projectIdSchema,
+            regions: z.array(regionSchema).min(1).max(20).optional().describe('Default: regiões das conexões do projeto, ou AWS_REGION'),
+            profile: z.string().optional().describe('Perfil do ~/.aws (default: cadeia padrão de credenciais)'),
+            path: z.string().optional().describe('Repositório para anexar a análise de IaC ao snapshot (opcional)'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ projectId, regions, profile, path }) => guard(async () => {
+        let useRegions = regions;
+        if (!useRegions?.length) {
+            const fromConnections = [...new Set((await getConnections(projectId)).flatMap((c) => c.regions ?? []))];
+            useRegions = fromConnections.length ? fromConnections : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];
+        }
+        let discovery;
+        try {
+            discovery = await discoverAws({ regions: useRegions, profile });
+        }
+        catch (err) {
+            throw new Error(describeAwsError(err));
+        }
+        let iac;
+        if (path)
+            iac = await analyzeIac(await resolveRoot(path));
+        const payload = { accountId: discovery.accountId, regions: discovery.regions, resources: discovery.resources, ...(iac ? { iac } : {}) };
+        let response;
+        let route = `${base(projectId)}/snapshots`;
+        try {
+            response = await client.post(route, payload);
+        }
+        catch (err) {
+            if (err instanceof TrackApiError && (err.status === 401 || err.status === 403 || err.status === 404) && client.hasApiKey) {
+                route = '/v1/infra/snapshots';
+                response = await client.post(route, { projectId, ...payload }).catch(wrapInfra);
+            }
+            else
+                wrapInfra(err);
+        }
+        const byService = new Map();
+        const byRegion = new Map();
+        for (const r of discovery.resources) {
+            const svc = serviceLabel(r.resourceType, r.arn);
+            byService.set(svc, (byService.get(svc) ?? 0) + 1);
+            byRegion.set(r.region, (byRegion.get(r.region) ?? 0) + 1);
+        }
+        const count = (v) => (typeof v === 'number' ? v : Array.isArray(v) ? v.length : '?');
+        const resp = response;
+        const lines = [
+            `Conta ${discovery.accountId} (${discovery.callerArn}) · ${discovery.resources.length} recursos em ${discovery.regions.join(', ')}.`,
+            `Fontes: ${Object.entries(discovery.sources).map(([r, s]) => `${r}=${s}`).join(', ')}.`,
+            `Snapshot enviado (${route}): ${count(resp?.nodes)} nós, ${count(resp?.edges)} arestas${iac ? `, IaC com ${iac.stacks.length} stack(s)` : ''}.`,
+            '',
+            'Por região: ' + [...byRegion].map(([r, n]) => `${r} ${n}`).join(' · '),
+            'Por serviço:',
+            ...[...byService].sort((a, b) => b[1] - a[1]).slice(0, 25).map(([s, n]) => `- ${s}: ${n}`),
+        ];
+        if (byService.size > 25)
+            lines.push(`- … +${byService.size - 25} serviços`);
+        if (discovery.stacks.length) {
+            lines.push('', `Stacks CloudFormation (${discovery.stacks.length}):`, ...discovery.stacks.slice(0, 25).map((s) => `- ${s.name} (${s.region}, ${s.status}) · ${s.resources} recursos, ${s.mapped} ligados a ARN`));
+            if (discovery.stacks.length > 25)
+                lines.push(`- … +${discovery.stacks.length - 25} stacks`);
+        }
+        if (discovery.warnings.length)
+            lines.push('', 'Avisos:', ...discovery.warnings.map((w) => `- ${w}`));
+        lines.push('', 'Próximos passos: `infra_analyze_iac` (liga stacks ao código) → `infra_assign_resources` (confirme com o usuário o que é do projeto e o que é compartilhado).');
+        return text(lines.join('\n'));
+    }));
+    /* 4 ---------------- análise de IaC ---------------- */
+    server.registerTool('infra_analyze_iac', {
+        title: 'Analisar IaC do repositório',
+        description: 'Lê o repositório local (sem executar nada): cdk.json e entrada do app, stacks `new XStack(app, "Nome", { env })`, constructs `aws-cdk-lib/aws-*`, assets (Code.fromAsset, NodejsFunction, DockerImageFunction, ContainerImage.fromAsset), contextos, SAM, Serverless, Terraform (somente leitura) e comandos de deploy do CI. Devolve viabilidade de handover por stack.',
+        inputSchema: { path: z.string().optional().describe('Caminho do repositório (default: diretório atual)') },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async ({ path }) => guard(async () => text(formatIac(await analyzeIac(await resolveRoot(path))))));
+    /* 5 ---------------- atribuir recursos ---------------- */
+    server.registerTool('infra_assign_resources', {
+        title: 'Confirmar recursos do projeto',
+        description: 'Confirma (include) ou remove (exclude) recursos do projeto por ARN: resolve os nós em GET .../infra/graph e chama POST .../infra/nodes/:nodeId/assign { projectOwned }. Use só depois de o usuário confirmar a lista.',
+        inputSchema: {
+            projectId: projectIdSchema,
+            include: z.array(z.string().startsWith('arn:')).max(1000).describe('ARNs que pertencem ao projeto'),
+            exclude: z.array(z.string().startsWith('arn:')).max(1000).optional().describe('ARNs que não pertencem (compartilhados/de outros projetos)'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ projectId, include, exclude }) => guard(async () => {
+        const graph = await client.get(`${base(projectId)}/graph`).catch(wrapInfra);
+        const byArn = new Map((graph.nodes ?? []).map((n) => [n.arn, n]));
+        const jobs = [...include.map((arn) => ({ arn, projectOwned: true })), ...(exclude ?? []).map((arn) => ({ arn, projectOwned: false }))];
+        const notFound = [];
+        const failed = [];
+        let assigned = 0;
+        let removed = 0;
+        const queue = [...jobs];
+        const worker = async () => {
+            for (let job = queue.shift(); job; job = queue.shift()) {
+                const node = byArn.get(job.arn);
+                if (!node) {
+                    notFound.push(job.arn);
+                    continue;
+                }
+                try {
+                    await client.post(`${base(projectId)}/nodes/${node.id}/assign`, { projectOwned: job.projectOwned });
+                    if (job.projectOwned)
+                        assigned++;
+                    else
+                        removed++;
+                }
+                catch (err) {
+                    failed.push(`${job.arn}: ${err instanceof TrackApiError ? err.message : String(err)}`);
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: 5 }, worker));
+        const lines = [`${assigned} recurso(s) confirmados no projeto, ${removed} removido(s).`];
+        if (notFound.length)
+            lines.push(`${notFound.length} ARN(s) não estão no grafo (rode infra_discover antes):`, ...notFound.slice(0, 25).map((a) => `- ${a}`));
+        if (failed.length)
+            lines.push(`${failed.length} falha(s):`, ...failed.slice(0, 25).map((f) => `- ${f}`));
+        lines.push('', `Próximo passo: infra_instrument { projectId: "${projectId}" } e infra_validate.`);
+        return { ...text(lines.join('\n')), ...(failed.length && !assigned && !removed ? { isError: true } : {}) };
+    }));
+    /* 6 ---------------- instrumentação ---------------- */
+    server.registerTool('infra_instrument', {
+        title: 'Plano de instrumentação de infra',
+        description: 'Varre o repositório e devolve um plano de patches (não aplicado): instalar fg-tracker-sdk, tracker.instrumentAws(new SQSClient()) nos clientes SQS/SNS/EventBridge/DynamoDB/Kinesis/SFN, tracker.instrumentPgPool(pool), tracker.startInfraReporter({ ecs: true }) em apps ECS, camada da extensão + FG_TRACKER_URL/FG_TRACKER_KEY nas Lambdas do CDK e tracker.wrapLambda(handler), com arquivos e trechos de código.',
+        inputSchema: { projectId: projectIdSchema, path: z.string().optional().describe('Caminho do repositório (default: diretório atual)') },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ projectId, path }) => guard(async () => {
+        const root = await resolveRoot(path);
+        const project = await getProject(projectId);
+        const conn = (await getConnections(projectId)).find((c) => c.accountId) ?? null;
+        const layerArn = conn?.accountId ? `arn:aws:lambda:${conn.regions?.[0] ?? '<região>'}:${conn.accountId}:layer:fg-tracker-extension:<versão>` : 'arn:aws:lambda:<região>:<conta>:layer:fg-tracker-extension:<versão>';
+        return text(await buildInstrumentPlan(root, { endpoint: client.baseUrl, serviceName: project.slug, layerArn }));
+    }));
+    /* 7 ---------------- validação (notas) ---------------- */
+    server.registerTool('infra_validate', {
+        title: 'Notas dos quatro pilares',
+        description: 'Relatório compacto por pilar (performance, segurança, escalabilidade, confiabilidade): GET .../infra/scores + findings abertos, com as principais recomendações.',
+        inputSchema: { projectId: projectIdSchema },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ projectId }) => guard(async () => {
+        const scores = await client.get(`${base(projectId)}/scores`).catch(wrapInfra);
+        const findings = listOf(await client.get(`${base(projectId)}/findings`, { status: 'open' }));
+        let names = new Map();
+        try {
+            const graph = await client.get(`${base(projectId)}/graph`);
+            names = new Map((graph.nodes ?? []).map((n) => [n.id, n.name]));
+        }
+        catch {
+            /* nomes opcionais */
+        }
+        const lines = [`Nota geral: ${Math.round(scores.overall)}/100 · ${findings.length} findings abertos.`];
+        for (const [pillar, p] of Object.entries(scores.pillars ?? {})) {
+            lines.push('', `## ${PILLAR_LABEL[pillar] ?? pillar}: ${Math.round(p.score)}/100 (${p.open} abertos, ${p.critical} críticos)`);
+            const top = findings.filter((f) => f.pillar === pillar).sort((a, b) => (SEVERITY_RANK[a.severity] ?? 9) - (SEVERITY_RANK[b.severity] ?? 9)).slice(0, 5);
+            for (const f of top)
+                lines.push(`- [${f.severity}] ${f.title}${f.nodeId ? ` — ${names.get(f.nodeId) ?? f.nodeId}` : ''}${f.recommendation ? `\n  → ${f.recommendation}` : ''}`);
+            if (!top.length)
+                lines.push('- sem findings abertos');
+        }
+        lines.push('', 'Correções de infra são feitas pelo FG Tracker (diagrama → mudança → aprovação), nunca direto na AWS pelo agente. Ajustes de código (timeouts, pools, retries) podem ir no PR.');
+        return text(lines.join('\n'));
+    }));
+    /* 8 ---------------- diagrama ---------------- */
+    server.registerTool('infra_get_diagram', {
+        title: 'Diagrama da infraestrutura (texto)',
+        description: 'GET .../infra/graph em texto compacto: grupos (conta/região/VPC/AZ/subnet) → nós com estado, réplicas e custo; arestas; gargalos (nós em warning/critical); deploys ativos; notas e custo.',
+        inputSchema: { projectId: projectIdSchema, maxNodes: z.number().int().min(10).max(500).default(150).describe('Máximo de nós listados') },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ projectId, maxNodes }) => guard(async () => {
+        const g = await client.get(`${base(projectId)}/graph`).catch(wrapInfra);
+        const nodes = g.nodes ?? [];
+        const groups = g.groups ?? [];
+        const nameOf = new Map(nodes.map((n) => [n.id, n.name]));
+        const lines = [
+            `Conexões: ${(g.connections ?? []).map((c) => `${c.name} (${c.mode}, ${c.status}${c.accountId ? `, ${c.accountId}` : ''})`).join('; ') || 'nenhuma'}`,
+            `Nota ${g.scores ? Math.round(g.scores.overall) : '—'}/100 · custo agora ${usd(g.costs?.nowPerHour)}/h · hoje ${usd(g.costs?.today)} · mês ${usd(g.costs?.monthToDate)} (previsão ${usd(g.costs?.forecastMonth)}) · ${nodes.length} nós · ${(g.edges ?? []).length} arestas${g.live?.active ? ' · tempo real ativo' : ''}`,
+            '',
+        ];
+        const children = new Map();
+        for (const gr of groups)
+            children.set(gr.parentId, [...(children.get(gr.parentId) ?? []), gr]);
+        const nodesByGroup = new Map();
+        for (const n of nodes)
+            nodesByGroup.set(n.groupId ?? null, [...(nodesByGroup.get(n.groupId ?? null) ?? []), n]);
+        let shown = 0;
+        const nodeLine = (n, indent) => {
+            const f = n.openFindings;
+            const fl = f && f.critical + f.high + f.medium + f.low ? ` · findings ${f.critical}c/${f.high}h/${f.medium}m/${f.low}l` : '';
+            const rep = n.replicas ? ` · réplicas ${n.replicas.current}/${n.replicas.desired ?? '—'}${n.replicas.max ? ` (máx ${n.replicas.max})` : ''}` : '';
+            return `${indent}- ${n.name} (${n.service}) ${n.state}${n.stateReason ? `: ${n.stateReason}` : ''}${rep}${n.costPerHour ? ` · ${usd(n.costPerHour)}/h` : ''}${n.instrumented ? ' · instrumentado' : ''}${n.owner === 'fg-tracker' ? ' · FG Tracker' : ''}${n.shared ? ' · compartilhado' : ''}${fl}`;
+        };
+        const visit = (parent, depth) => {
+            for (const gr of children.get(parent) ?? []) {
+                const indent = '  '.repeat(depth);
+                lines.push(`${indent}[${gr.kind}] ${gr.label}`);
+                for (const n of nodesByGroup.get(gr.id) ?? []) {
+                    if (shown++ < maxNodes)
+                        lines.push(nodeLine(n, indent + '  '));
+                }
+                visit(gr.id, depth + 1);
+            }
+        };
+        visit(null, 0);
+        const orphan = nodes.filter((n) => !n.groupId || !groups.some((gr) => gr.id === n.groupId));
+        if (orphan.length) {
+            lines.push('[sem grupo]');
+            for (const n of orphan)
+                if (shown++ < maxNodes)
+                    lines.push(nodeLine(n, '  '));
+        }
+        if (shown > maxNodes)
+            lines.push(`… +${shown - maxNodes} nós (aumente maxNodes)`);
+        const edges = g.edges ?? [];
+        if (edges.length) {
+            lines.push('', `Arestas (${edges.length}):`);
+            for (const e of [...edges].sort((a, b) => b.volumePerMin - a.volumePerMin).slice(0, 80))
+                lines.push(`- ${nameOf.get(e.source) ?? e.source} → ${nameOf.get(e.target) ?? e.target} (${e.relation}, ${e.kind}${e.volumePerMin ? `, ${Math.round(e.volumePerMin)}/min` : ''})`);
+            if (edges.length > 80)
+                lines.push(`- … +${edges.length - 80} arestas`);
+        }
+        const hot = nodes.filter((n) => n.state === 'critical' || n.state === 'warning');
+        lines.push('', `Gargalos/alertas (${hot.length}):`, ...(hot.length ? hot.slice(0, 20).map((n) => `- [${n.state}] ${n.name}${n.stateReason ? `: ${n.stateReason}` : ''}`) : ['- nenhum']));
+        const deploys = g.activeDeployments ?? [];
+        if (deploys.length)
+            lines.push('', 'Deploys ativos:', ...deploys.slice(0, 10).map((d) => `- ${d.name} ${d.status}${d.stage ? ` (${d.stage})` : ''}${d.release ? ` · ${d.release}` : d.commitSha ? ` · ${d.commitSha.slice(0, 7)}` : ''}`));
+        return text(lines.join('\n'));
+    }));
+    /* 9 / 10 ---------------- handover ---------------- */
+    const handoverInputs = {
+        projectId: projectIdSchema,
+        stackNames: z.array(z.string().min(1)).min(1).max(50).describe('Nomes dos stacks CloudFormation a transferir'),
+        path: z.string().optional().describe('Caminho do repositório (default: diretório atual)'),
+    };
+    async function prepareHandover(projectId, stackNames, path) {
+        const root = await resolveRoot(path);
+        const analysis = await analyzeIac(root);
+        let apiPlan = null;
+        let apiPlanError = null;
+        try {
+            apiPlan = await client.post(`${base(projectId)}/handover/plan`, { stackNames });
+        }
+        catch (err) {
+            apiPlanError = infraRouteMissing(err) ? 'rota POST /infra/handover/plan indisponível nesta API' : err instanceof TrackApiError ? err.describe() : String(err);
+        }
+        const edits = await buildHandoverEdits(root, analysis, stackNames);
+        return { root, analysis, apiPlan, apiPlanError, edits };
+    }
+    function feasibilityLines(edits) {
+        const lines = edits.matched.map((s) => `- ${s.name} (${s.tool}): ${s.handover}${s.entryFile ? ` — \`${s.entryFile}${s.entryLines ? `:${s.entryLines[0]}` : ''}\`` : ''}`);
+        for (const m of edits.missing)
+            lines.push(`- ${m}: não encontrado no IaC do repositório (stack manual ou de outro repo) — o PR só registra no lock.`);
+        return lines;
+    }
+    server.registerTool('infra_plan_handover', {
+        title: 'Planejar transferência de controle',
+        description: 'Combina POST .../infra/handover/plan com a análise local de IaC e devolve a lista exata de edições do PR: remover stacks do app CDK e do cdk deploy do CI, separar deploy de código (fg-tracker-release deploy --release <sha>), guard do CI, infra/fg-tracker.lock.json e README. Não escreve nada.',
+        inputSchema: handoverInputs,
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ projectId, stackNames, path }) => guard(async () => {
+        const { apiPlan, apiPlanError, edits } = await prepareHandover(projectId, stackNames, path);
+        const patchLines = edits.patch.split('\n');
+        const lines = [
+            `# Plano de transferência: ${stackNames.join(', ')}`,
+            '',
+            '## Viabilidade',
+            ...feasibilityLines(edits),
+            ...(edits.unsupported.length ? [`Terraform não é transferível: ${edits.unsupported.map((s) => s.name).join(', ')}.`] : []),
+            '',
+            '## Plano do FG Tracker',
+            apiPlanError ? `Indisponível: ${apiPlanError}` : '```json\n' + JSON.stringify(compact(apiPlan), null, 2) + '\n```',
+            '',
+            '## Edições do PR',
+            formatChanges(edits),
+        ];
+        if (edits.warnings.length)
+            lines.push('', '## Pendências', ...edits.warnings.map((w) => `- ${w}`));
+        if (edits.patch)
+            lines.push('', `## Patch (prévia${patchLines.length > 150 ? `, ${patchLines.length} linhas — completo no infra_open_handover_pr` : ''})`, '```diff', patchLines.slice(0, 150).join('\n'), '```');
+        lines.push('', `Próximo passo (após o usuário aprovar o plano): infra_open_handover_pr { projectId: "${projectId}", stackNames: ${JSON.stringify(stackNames)} }.`);
+        return text(lines.join('\n'));
+    }));
+    server.registerTool('infra_open_handover_pr', {
+        title: 'Gerar arquivos do PR de transferência',
+        description: `Escreve SÓ arquivos locais: ${LOCK_PATH}, ${GUARD_PATH} (guard do CI), ${DOC_PATH} (corpo do PR), ${HANDOVER_README} e ${PATCH_PATH} (diff que remove os stacks do app CDK/CI). Não apaga nem move código e não executa git/gh: devolve os comandos exatos (git checkout -b, git apply, git mv, git add, git commit, gh pr create --body-file) e o passo pós-merge (infra_complete_handover).`,
+        inputSchema: { ...handoverInputs, branch: z.string().regex(/^[\w./-]+$/).optional().describe('Branch do PR (default fg-tracker/handover-<stacks>)') },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ projectId, stackNames, path, branch }) => guard(async () => {
+        const { root, analysis, apiPlan, apiPlanError, edits } = await prepareHandover(projectId, stackNames, path);
+        if (!edits.matched.length && !edits.missing.length)
+            throw new Error('Nenhum stack informado.');
+        if (edits.unsupported.length === edits.matched.length && edits.matched.length && !edits.missing.length)
+            throw new Error(`Stacks Terraform não são transferíveis: ${edits.unsupported.map((s) => s.name).join(', ')}.`);
+        const project = await getProject(projectId);
+        const connections = await getConnections(projectId);
+        const conn = connections.find((c) => c.accountId) ?? connections[0];
+        const stackRegions = {};
+        try {
+            const graph = await client.get(`${base(projectId)}/graph`);
+            for (const n of graph.nodes ?? [])
+                if (n.service === 'cloudformation.stack' && stackNames.includes(n.name))
+                    stackRegions[n.name] = n.region ?? null;
+        }
+        catch {
+            /* regiões opcionais */
+        }
+        const ctx = {
+            projectId,
+            projectSlug: project.slug,
+            projectName: project.name,
+            endpoint: client.baseUrl,
+            accountId: conn?.accountId ?? null,
+            environment: conn?.environment ?? null,
+            regions: conn?.regions ?? [],
+            stackRegions,
+            version,
+        };
+        const slug = stackNames.join('-').toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/-+/g, '-').slice(0, 60).replace(/^-|-$/g, '');
+        const prBranch = branch ?? `fg-tracker/handover-${slug || 'stacks'}`;
+        // Stacks sem IaC local entram no lock como registro.
+        const lockEdits = { ...edits, matched: [...edits.matched, ...edits.missing.map((name) => ({ name, constructId: null, className: null, tool: 'cloudformation', appDir: '.', entryFile: null, entryLines: null, variable: null, standalone: false, sourceFiles: [], env: null, constructs: [], assets: [], resourceTypes: [], handover: 'ok', notes: [] }))] };
+        const files = {
+            [LOCK_PATH]: lockFile(ctx, analysis, lockEdits),
+            [GUARD_PATH]: GUARD_SCRIPT,
+            [DOC_PATH]: handoverDoc(ctx, lockEdits, prBranch),
+            [HANDOVER_README]: handoverReadme(edits),
+        };
+        if (edits.patch)
+            files[PATCH_PATH] = edits.patch;
+        const written = await writeHandoverFiles(root, files);
+        const patched = [...new Set(edits.changes.filter((c) => c.kind === 'patch').map((c) => c.path))];
+        const title = `Transferir ${stackNames.join(', ')} ao FG Tracker`;
+        const commands = [
+            `cd ${shellQuote(root)}`,
+            `git checkout -b ${prBranch}`,
+            ...(edits.patch ? [`git apply --check ${PATCH_PATH} && git apply ${PATCH_PATH}`] : []),
+            ...edits.moves.map((m) => `mkdir -p ${shellQuote(m.to.split('/').slice(0, -1).join('/'))} && git mv ${shellQuote(m.from)} ${shellQuote(m.to)}`),
+            `node ${GUARD_PATH}`,
+            `git add ${[LOCK_PATH, GUARD_PATH, DOC_PATH, HANDOVER_DIR, ...patched].map(shellQuote).join(' ')}`,
+            `git commit -m ${shellQuote(`infra: transfere ${stackNames.join(', ')} ao FG Tracker`)}`,
+            `git push -u origin ${prBranch}`,
+            `gh pr create --title ${shellQuote(title)} --body-file ${DOC_PATH}`,
+        ];
+        const lines = [
+            `Arquivos gerados em ${root}:`,
+            ...written.map((w) => `- ${w.path}${w.overwritten ? ' (sobrescrito)' : ''}`),
+            '',
+            '## Edições',
+            formatChanges(edits),
+            ...(edits.warnings.length ? ['', '## Pendências (resolver antes do commit)', ...edits.warnings.map((w) => `- ${w}`)] : []),
+            ...(apiPlanError ? ['', `Plano do FG Tracker indisponível: ${apiPlanError}`] : apiPlan ? ['', 'Plano do FG Tracker validado (POST /infra/handover/plan).'] : []),
+            '',
+            '## Comandos (mostre ao usuário; rode só com a aprovação dele)',
+            '```bash',
+            ...commands,
+            '```',
+            '',
+            'Antes do commit: revise o diff (`git diff`), rode `npx cdk ls`/`cdk synth` e os testes do repositório.',
+            `Depois do MERGE do PR: infra_complete_handover { projectId: "${projectId}", stackNames: ${JSON.stringify(stackNames)}, prUrl: "<url do PR>" }. O FG Tracker só assume os stacks nesse passo, com a verificação de change set vazio.`,
+        ];
+        return text(lines.join('\n'));
+    }));
+    /* 11 ---------------- concluir handover ---------------- */
+    server.registerTool('infra_complete_handover', {
+        title: 'Concluir transferência de controle',
+        description: 'Depois do merge do PR: POST .../infra/handover { stackIds, prUrl } — o FG Tracker lê os templates, cria o estado desejado v1, marca os stacks com fg-tracker:owner=true, aplica a stack policy e verifica com change set vazio (em dry-run só simula). Aceita stackNames (resolvidos em GET .../infra/stacks).',
+        inputSchema: {
+            projectId: projectIdSchema,
+            stackIds: z.array(z.string().uuid()).optional(),
+            stackNames: z.array(z.string().min(1)).optional(),
+            prUrl: z.string().url().describe('URL do PR mergeado'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ projectId, stackIds, stackNames, prUrl }) => guard(async () => {
+        const ids = new Set(stackIds ?? []);
+        const unresolved = [];
+        if (stackNames?.length) {
+            const stacks = listOf(await client.get(`${base(projectId)}/stacks`).catch(wrapInfra));
+            for (const name of stackNames) {
+                const found = stacks.filter((s) => (s.stackName ?? s.name) === name);
+                if (!found.length)
+                    unresolved.push(name);
+                for (const s of found)
+                    ids.add(s.id);
+            }
+        }
+        if (!ids.size)
+            throw new Error(`Nenhum stack resolvido${unresolved.length ? ` (${unresolved.join(', ')} não estão em GET /infra/stacks — rode infra_discover)` : ''}.`);
+        const result = await client.post(`${base(projectId)}/handover`, { stackIds: [...ids], prUrl }).catch(wrapInfra);
+        const r = result;
+        return json(compact(result), [
+            `Handover ${r.id ?? ''} registrado: status ${r.status ?? '?'} para ${ids.size} stack(s).`,
+            unresolved.length ? `Não resolvidos: ${unresolved.join(', ')}.` : '',
+            `Atualize "status" em ${LOCK_PATH} para "completed" num commit seguinte, se quiser manter o registro fiel. Acompanhe a verificação com infra_get_diagram (stacks com owner FG Tracker).`,
+        ].filter(Boolean).join('\n'));
+    }));
+    /* ---------------- prompt ---------------- */
+    server.registerPrompt('connect-infrastructure', {
+        title: 'Conectar a infraestrutura AWS ao FG Tracker',
+        description: 'Roteiro para o agente: detectar contas/ambientes/regiões → conectar cada ambiente (com confirmação antes do stack) → verificar → descobrir → analisar IaC → confirmar recursos → instrumentar → validar → planejar e gerar o PR de transferência, com regras de segurança.',
+        argsSchema: {
+            projectId: z.string().optional().describe('Projeto no FG Tracker (default: ler da mensagem do usuário ou escolher com track_list_projects)'),
+            level: z.string().optional().describe('read | operate (default: ler da mensagem do usuário)'),
+            name: z.string().optional().describe('Nome base da conexão (opcional)'),
+            path: z.string().optional().describe('Repositório (default: diretório atual)'),
+            environment: z.string().optional().describe('Restringe a um ambiente: production | staging | development'),
+        },
+    }, ({ projectId, level, name, path, environment }) => ({
+        messages: [{ role: 'user', content: { type: 'text', text: connectInfrastructurePrompt({ projectId, level, name, path, environment }, client.baseUrl) } }],
+    }));
+}
+export function connectInfrastructurePrompt(args, endpoint) {
+    const p = args.projectId ? `projectId **${args.projectId}**` : 'o projeto indicado na mensagem do usuário (senão use `track_list_projects` e pergunte)';
+    const repo = args.path ? `\`${args.path}\`` : 'o diretório atual';
+    const known = [args.level ? `nível **${args.level}**` : '', args.name ? `nome da conexão **${args.name}**` : '', args.environment ? `somente o ambiente **${args.environment}**` : ''].filter(Boolean).join(', ');
+    return `Você vai integrar a infraestrutura AWS deste repositório (${repo}) ao FG Tracker (${endpoint}) para ${p}${known ? ` (${known})` : ''}. Trabalhe passo a passo, mostre o resultado de cada tool e peça confirmação nos pontos marcados. Você mesmo identifica contas, ambientes e regiões — não peça ao usuário o que dá para detectar.
+
+## Regras de segurança (obrigatórias)
+- **A única mudança na AWS permitida é criar o stack de conexão \`fg-tracker-<slug>\`**, com o comando devolvido por \`infra_connect_account\` e **somente depois de o usuário confirmar explicitamente** (mostre conta, perfil, região e comando). Nunca rode \`cdk deploy\`, \`sam deploy\`, \`terraform apply\` ou outros \`aws ... create/update/delete/put\`.
+- Alterações de infraestrutura só acontecem no FG Tracker, com **aprovação humana na tela**. O merge do PR de transferência é a confirmação humana do handover.
+- Não faça \`git push\` nem \`gh pr create\` sem o usuário aprovar os comandos. Nunca commite chaves (\`FG_TRACKER_KEY\`, credenciais AWS, External ID, \`fg-tracker-connection-*.json\`).
+- Se \`track_status\` indicar API fora do ar ou sem \`FG_TRACKER_TOKEN\`, pare e explique o que configurar.
+
+## Roteiro
+1. **Ler o pedido** — extraia da mensagem do usuário o \`projectId\`, o nível (\`read\` | \`operate\`) e o nome da conexão (opcional; default: nome do projeto). Pergunte só o que faltar.
+2. **Detectar ambientes** — \`infra_detect_environments\`. Mostre as contas/perfis, o ambiente classificado e as regiões em uso, e **confirme com o usuário** quais conectar. Pergunte o ambiente apenas quando vier desconhecido (null); se não houver credenciais válidas, peça \`aws sso login --profile <perfil>\` e repita.
+3. **Para cada ambiente escolhido**:
+   a. \`infra_connect_account { projectId, level, name: "<nome> · <Ambiente>", environment, regions, profile }\` (Ambiente = Produção | Staging | Desenvolvimento).
+   b. Mostre o comando \`aws cloudformation deploy ... --profile <perfil> --region <região>\` e **peça confirmação**; com o "sim", rode-o e espere terminar.
+   c. \`infra_verify_connection { projectId, connectionId, profile }\` — se falhar, explique o status e corrija antes de seguir.
+   d. \`infra_discover { projectId, profile, regions }\` com as regiões da conexão.
+4. **Analisar o IaC** — \`infra_analyze_iac { path }\`: apps CDK, stacks, assets, CI. Relacione cada stack do repositório aos stacks descobertos (por ambiente).
+5. **Confirmar recursos** — proponha o que pertence ao projeto e o que é compartilhado (VPC, bancos de outros times, buckets comuns). **Peça confirmação** e só então \`infra_assign_resources { include, exclude }\`.
+6. **Instrumentar** — \`infra_instrument { projectId, path }\`; aplique os patches de código (SDK, clientes AWS, pools, reporter ECS, camada nas Lambdas, \`wrapLambda\`) no repositório, em edits mínimos. Não implante.
+7. **Validar** — \`infra_validate { projectId }\` e \`infra_get_diagram\`; resuma as notas por pilar e as 3–5 recomendações mais importantes.
+8. **Planejar o handover** — pergunte quais stacks transferir (só CloudFormation/CDK/SAM; Terraform fica somente leitura). \`infra_plan_handover { projectId, stackNames, path }\`; explique viabilidade, separação do deploy de código (\`fg-tracker-release deploy --release <sha>\`) e pendências. **Peça aprovação**.
+9. **Gerar o PR** — \`infra_open_handover_pr\`; mostre os arquivos gerados e os comandos git/gh. Aplique o patch e rode as verificações locais (\`cdk ls\`, guard, testes); só rode push/PR com aprovação.
+10. **Após o merge** — \`infra_complete_handover { projectId, stackNames, prUrl }\`.
+
+Ao final, liste: conexões criadas (ambiente, conta, regiões, status), nº de recursos por ambiente, recursos confirmados, arquivos alterados, notas por pilar e o estado do handover.`;
+}
+//# sourceMappingURL=tools.js.map