@linkegringo/mcp 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+declare function createLinkeGringoMcpServer(): McpServer;
+
+interface ChromeVersionResponse {
+    Browser: string;
+    'Protocol-Version': string;
+    'User-Agent': string;
+    'V8-Version': string;
+    'WebKit-Version': string;
+    webSocketDebuggerUrl?: string;
+}
+interface ChromeTabInfo {
+    id: string;
+    title: string;
+    type: string;
+    url: string;
+    description?: string;
+    webSocketDebuggerUrl?: string;
+    devtoolsFrontendUrl?: string;
+}
+interface CdpStatus {
+    isRunning: boolean;
+    port: number;
+    host: string;
+    browser?: string;
+    protocolVersion?: string;
+    activeTabs: Array<{
+        id: string;
+        title: string;
+        url: string;
+        webSocketDebuggerUrl?: string;
+    }>;
+    linkeGringoTabFound: boolean;
+    linkeGringoTabUrl?: string;
+    error?: string;
+}
+
+declare function checkChromeCdp(port?: number, host?: string, timeoutMs?: number): Promise<CdpStatus>;
+
+interface InstallResult {
+    client: string;
+    configPath: string;
+    status: 'created' | 'updated' | 'skipped' | 'error';
+    message?: string;
+}
+declare function getMcpConfigsForSystem(): Array<{
+    client: string;
+    configPath: string;
+}>;
+declare function installMcpServerConfig(configPath: string): {
+    status: 'created' | 'updated';
+    path: string;
+};
+declare function runInstaller(): InstallResult[];
+
+export { type CdpStatus, type ChromeTabInfo, type ChromeVersionResponse, type InstallResult, checkChromeCdp, createLinkeGringoMcpServer, getMcpConfigsForSystem, installMcpServerConfig, runInstaller };

package/dist/index.js

@@ -0,0 +1,1297 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/audit-profile.ts
+import { z } from "zod";
+function getExperienceBulletCount(exp) {
+  if (Array.isArray(exp.bullets) && exp.bullets.length > 0) {
+    return exp.bullets.length;
+  }
+  const desc = exp.description;
+  if (!desc || !desc.trim()) return 0;
+  const lines = desc.split(/\n+/).map((l) => l.trim()).filter(Boolean);
+  const bulletLines = lines.filter((l) => /^[-*•\u2022\u25E6\u25AA\d+.]/.test(l));
+  if (bulletLines.length > 0) return bulletLines.length;
+  const sentences = desc.split(/(?<=[.!?])\s+/).filter((s) => s.trim().length > 10);
+  return Math.max(lines.length, sentences.length);
+}
+function detectSparseExperiences(experiences) {
+  if (!experiences || !Array.isArray(experiences)) return [];
+  const sparse = [];
+  for (const exp of experiences) {
+    const company = exp.companyName || exp.company || "Company";
+    const title = exp.title || "Software Engineer";
+    const count = getExperienceBulletCount(exp);
+    if (count <= 3) {
+      sparse.push({
+        company,
+        title,
+        estimatedBullets: count
+      });
+    }
+  }
+  return sparse;
+}
+var auditProfileInputSchema = z.object({
+  profileText: z.string().optional().describe("Texto bruto extra\xEDdo do perfil do LinkedIn ou curr\xEDculo do candidato"),
+  headline: z.string().optional().describe("Headline / T\xEDtulo atual do LinkedIn (se fornecido isoladamente)"),
+  summary: z.string().optional().describe("Se\xE7\xE3o Sobre / About atual (se fornecida isoladamente)"),
+  experiences: z.array(
+    z.object({
+      company: z.string(),
+      title: z.string(),
+      bullets: z.array(z.string()).optional(),
+      description: z.string().optional()
+    })
+  ).optional().describe("Lista estruturada de experi\xEAncias profissionais"),
+  skills: z.array(z.string()).optional().describe("Lista de compet\xEAncias / skills declaradas"),
+  targetRole: z.string().default("Senior Software Engineer").describe("Cargo almejado no mercado norte-americano (ex: Senior Backend Engineer)"),
+  targetMarket: z.string().default("United States Remote").describe("Mercado e regime de trabalho pretendido")
+});
+async function handleAuditProfile(input) {
+  let headline = input.headline || "";
+  let summary = input.summary || "";
+  let skills = input.skills || [];
+  const rawExperiences = input.experiences || [];
+  if (input.profileText && !headline && rawExperiences.length === 0) {
+    const lines = input.profileText.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (lines.length > 0) {
+      headline = lines[1] || lines[0];
+      const potentialSkills = lines.filter(
+        (l) => l.includes(",") && (l.toLowerCase().includes("react") || l.toLowerCase().includes("typescript") || l.toLowerCase().includes("python") || l.toLowerCase().includes("go") || l.toLowerCase().includes("aws") || l.toLowerCase().includes("docker"))
+      );
+      if (potentialSkills.length > 0) {
+        skills = potentialSkills[0].split(",").map((s) => s.trim());
+      }
+    }
+  }
+  const domainExperiences = rawExperiences.map((e) => ({
+    companyName: e.company,
+    title: e.title,
+    bullets: e.bullets,
+    description: e.description,
+    current: false,
+    location: ""
+  }));
+  let score = 100;
+  const issues = [];
+  const triageBottlenecks = [];
+  if (!headline || headline.length < 5) {
+    score -= 25;
+    triageBottlenecks.push("Headline ausente ou muito curta: perfil invis\xEDvel no LinkedIn Recruiter.");
+    issues.push({
+      severity: "critical",
+      category: "headline",
+      message: "Headline vazia ou insuficiente.",
+      recommendation: `Adicione uma headline no formato: "${input.targetRole} | [3-4 Core Techs] | [Escala/Impacto] | US Remote".`
+    });
+  } else {
+    if (headline.length > 160) {
+      score -= 10;
+      issues.push({
+        severity: "warning",
+        category: "headline",
+        message: `Headline possui ${headline.length} caracteres, excedendo o limite recomendado de 160.`,
+        recommendation: "Reduza para menos de 160 caracteres para evitar que o LinkedIn corte informa\xE7\xF5es cruciais no app mobile."
+      });
+    }
+    const lowerHeadline = headline.toLowerCase();
+    const fluffWords = ["passionate", "aspiring", "open to opportunities", "looking for", "rockstar", "ninja", "entusiasta"];
+    const detectedFluff = fluffWords.filter((w) => lowerHeadline.includes(w));
+    if (detectedFluff.length > 0) {
+      score -= 10;
+      triageBottlenecks.push(`Termos vagos na headline (${detectedFluff.join(", ")}): enfraquece o posicionamento s\xEAnior.`);
+      issues.push({
+        severity: "warning",
+        category: "headline",
+        message: `Headline cont\xE9m palavras-chave fracas: ${detectedFluff.join(", ")}.`,
+        recommendation: "Substitua termos gen\xE9ricos por especializa\xE7\xF5es t\xE9cnicas concretas e m\xE9tricas de sistema."
+      });
+    }
+    if (!lowerHeadline.includes("remote") && !lowerHeadline.includes("global") && !lowerHeadline.includes("us")) {
+      issues.push({
+        severity: "info",
+        category: "headline",
+        message: "Nenhuma men\xE7\xE3o expl\xEDcita a trabalho remoto internacional na headline.",
+        recommendation: 'Inclua "US Remote" ou "Global Teams" para facilitar a triagem de recrutadores americanos.'
+      });
+    }
+  }
+  const sparseExps = detectSparseExperiences(domainExperiences);
+  let totalBullets = 0;
+  let bulletsWithMetrics = 0;
+  const metricRegex = /\b(\d+|%|\$|ms|s|k|m|rps|tps|x)\b/i;
+  for (const exp of rawExperiences) {
+    const bullets = exp.bullets || (exp.description ? exp.description.split("\n") : []);
+    for (const b of bullets) {
+      if (b.trim().length > 10) {
+        totalBullets++;
+        if (metricRegex.test(b)) {
+          bulletsWithMetrics++;
+        }
+      }
+    }
+  }
+  if (rawExperiences.length > 0) {
+    if (sparseExps.length > 0) {
+      const deduction = Math.min(25, sparseExps.length * 10);
+      score -= deduction;
+      triageBottlenecks.push(
+        `${sparseExps.length} experi\xEAncia(s) com poucos detalhes (\u2264 3 bullets): faltam evid\xEAncias de escopo t\xE9cnico.`
+      );
+      issues.push({
+        severity: "critical",
+        category: "experience",
+        message: `Experi\xEAncias esparsas detectadas em: ${sparseExps.map((s) => s.company).join(", ")}.`,
+        recommendation: "Expanda cada experi\xEAncia com 3 a 5 bullets densos e fundamentados."
+      });
+    }
+    if (totalBullets > 0) {
+      const metricRatio = bulletsWithMetrics / totalBullets;
+      if (metricRatio < 0.4) {
+        score -= 20;
+        triageBottlenecks.push("Falta de mensura\xE7\xE3o quantitativa (apenas " + Math.round(metricRatio * 100) + "% dos bullets possuem m\xE9tricas).");
+        issues.push({
+          severity: "critical",
+          category: "experience",
+          message: "Baixa densidade da f\xF3rmula Google XYZ.",
+          recommendation: 'Converta os bullets para "Accomplished [X], measured by [Y], by doing [Z]" ancorando lat\xEAncia, throughput, custo ou SLA.'
+        });
+      }
+    }
+  } else if (input.profileText) {
+    const hasNumbers = /\b\d+(%|k|m|ms)?\b/i.test(input.profileText);
+    if (!hasNumbers) {
+      score -= 15;
+      triageBottlenecks.push("Raras evid\xEAncias num\xE9ricas encontradas no texto do curr\xEDculo.");
+    }
+  }
+  if (summary) {
+    if (summary.length < 100) {
+      score -= 10;
+      issues.push({
+        severity: "warning",
+        category: "about",
+        message: "Resumo Sobre (About) muito conciso ou incompleto.",
+        recommendation: "Crie um resumo estruturado com um gancho forte nos primeiros 250 caracteres e escopo arquitetural."
+      });
+    }
+  }
+  const finalScore = Math.max(15, Math.min(100, score));
+  const markdownSummary = `
+# Relat\xF3rio de Diagn\xF3stico Inbound (LinkeGringo)
+
+**Cargo-Alvo**: ${input.targetRole} (${input.targetMarket})
+**Nota Inbound**: **${finalScore} / 100** ${finalScore >= 80 ? "\u{1F7E2} Recruiter-Ready" : finalScore >= 50 ? "\u{1F7E1} Competitivo M\xE9dio" : "\u{1F534} Cr\xEDtico / Baixa Indexa\xE7\xE3o"}
+**Modo**: 100% Local (Executado pelo seu Agente de IA sem necessidade de Chaves de API)
+
+---
+
+## \u{1F6A6} Gargalos Cr\xEDticos de Triagem (Triage Bottlenecks)
+${triageBottlenecks.length > 0 ? triageBottlenecks.map((b) => `- \u274C ${b}`).join("\n") : "- \u2713 Nenhum gargalo impeditivo encontrado para triagem inicial."}
+
+## \u{1F4CB} Auditoria Se\xE7\xE3o a Se\xE7\xE3o
+${issues.length > 0 ? issues.map(
+    (iss) => `- **[${iss.category.toUpperCase()}]** (${iss.severity}): ${iss.message}
+  *A\xE7\xE3o recomendada*: ${iss.recommendation}`
+  ).join("\n") : "- Todas as se\xE7\xF5es atendem \xE0s diretrizes de triagem dos EUA."}
+
+## \u{1F4A1} Pr\xF3ximos Passos para o Agente de IA:
+1. Usar a ferramenta \`generate_headline_proposals\` para calibrar a headline em at\xE9 160 caracteres.
+2. Usar a ferramenta \`convert_to_xyz_bullet\` para reescrever as conquistas passivas no formato do Google (*Accomplished [X], measured by [Y], by doing [Z]*).
+3. Conduzir uma breve entrevista t\xE9cnica sobre as experi\xEAncias esparsas detectadas para extrair m\xE9tricas de escala realistas.
+`.trim();
+  return {
+    content: [
+      {
+        type: "text",
+        text: markdownSummary
+      }
+    ],
+    structuredData: {
+      score: finalScore,
+      targetRole: input.targetRole,
+      headline,
+      totalBullets,
+      bulletsWithMetrics,
+      sparseExperiences: sparseExps,
+      triageBottlenecks,
+      issues
+    }
+  };
+}
+
+// src/tools/recruiter-simulator.ts
+import { z as z8 } from "zod";
+
+// ../core/src/domain/date-range.ts
+import { z as z2 } from "zod";
+var yearMonthSchema = z2.object({
+  year: z2.number().int(),
+  month: z2.number().int().min(1).max(12).optional()
+});
+var dateRangeSchema = z2.object({
+  start: yearMonthSchema.optional(),
+  end: yearMonthSchema.optional()
+});
+
+// ../core/src/domain/profile.ts
+import { z as z3 } from "zod";
+var workplaceTypeSchema = z3.preprocess((val) => {
+  if (typeof val === "string") {
+    const lower = val.toLowerCase().trim();
+    if (lower.includes("remote") || lower.includes("remoto")) return "remote";
+    if (lower.includes("hybrid") || lower.includes("h\xEDbrido") || lower.includes("hibrido")) return "hybrid";
+    if (lower.includes("onsite") || lower.includes("presencial")) return "onsite";
+  }
+  return val;
+}, z3.enum(["remote", "hybrid", "onsite"]).optional());
+var experienceSchema = z3.object({
+  title: z3.string().default("Software Engineer"),
+  companyName: z3.string().default("Company"),
+  employmentType: z3.string().optional(),
+  workplaceType: workplaceTypeSchema,
+  location: z3.string().optional(),
+  startDate: yearMonthSchema.optional(),
+  endDate: yearMonthSchema.optional(),
+  current: z3.preprocess((val) => {
+    if (typeof val === "boolean") return val;
+    if (typeof val === "string") {
+      const lower = val.toLowerCase().trim();
+      return lower === "true" || lower === "present" || lower === "presente" || lower === "atual";
+    }
+    return false;
+  }, z3.boolean().default(false)),
+  dateRangeText: z3.string().optional(),
+  durationText: z3.string().optional(),
+  description: z3.string().optional()
+});
+var educationSchema = z3.object({
+  schoolName: z3.string(),
+  degreeName: z3.string().optional(),
+  fieldOfStudy: z3.string().optional(),
+  grade: z3.string().optional(),
+  description: z3.string().optional(),
+  dateRange: dateRangeSchema.optional()
+});
+var skillSchema = z3.union([
+  z3.string().transform((name) => ({ name })),
+  z3.object({
+    name: z3.string(),
+    endorsementCount: z3.number().int().nonnegative().optional()
+  })
+]);
+var certificationSchema = z3.union([
+  z3.string().transform((name) => ({ name })),
+  z3.object({
+    name: z3.string(),
+    issuer: z3.string().optional(),
+    credentialId: z3.string().optional(),
+    url: z3.string().optional(),
+    issuedDate: dateRangeSchema.shape.start.optional(),
+    expirationDate: dateRangeSchema.shape.end.optional()
+  })
+]);
+var projectSchema = z3.object({
+  name: z3.string(),
+  description: z3.string().optional(),
+  url: z3.string().optional(),
+  dateRange: dateRangeSchema.optional()
+});
+var languageSchema = z3.union([
+  z3.string().transform((name) => ({ name })),
+  z3.object({
+    name: z3.string(),
+    proficiency: z3.string().optional()
+  })
+]);
+var honorSchema = z3.object({
+  title: z3.string(),
+  issuer: z3.string().optional(),
+  description: z3.string().optional(),
+  date: dateRangeSchema.shape.start.optional()
+});
+var profileSchema = z3.object({
+  publicId: z3.string().default("user"),
+  firstName: z3.string().default(""),
+  lastName: z3.string().default(""),
+  headline: z3.string().optional().default(""),
+  location: z3.string().optional().default(""),
+  summary: z3.string().optional().default(""),
+  experiences: z3.array(experienceSchema).default([]),
+  education: z3.array(educationSchema).default([]),
+  skills: z3.array(skillSchema).default([]),
+  certifications: z3.array(certificationSchema).default([]),
+  projects: z3.array(projectSchema).default([]),
+  languages: z3.array(languageSchema).default([]),
+  honors: z3.array(honorSchema).default([])
+});
+
+// ../core/src/domain/scraped.ts
+import { z as z4 } from "zod";
+var scrapedIdentitySchema = z4.object({
+  publicId: z4.string().optional(),
+  fullName: z4.string(),
+  headline: z4.string().optional(),
+  location: z4.string().optional(),
+  summary: z4.string().optional()
+});
+var scrapedProfileSchema = z4.object({
+  identity: scrapedIdentitySchema.optional(),
+  experiences: z4.array(experienceSchema).optional(),
+  skills: z4.array(z4.string()).optional(),
+  education: z4.array(educationSchema).optional(),
+  certifications: z4.array(certificationSchema).optional(),
+  projects: z4.array(projectSchema).optional(),
+  languages: z4.array(languageSchema).optional(),
+  updatedAt: z4.number().optional()
+});
+
+// ../core/src/domain/analysis.ts
+import { z as z5 } from "zod";
+var critiqueSeveritySchema = z5.preprocess((val) => {
+  if (typeof val === "string") {
+    const lower = val.toLowerCase().trim();
+    if (lower === "critical" || lower === "grave") return "high";
+    if (lower === "moderate" || lower === "moderado") return "medium";
+    if (lower === "minor" || lower === "leve") return "low";
+    return lower;
+  }
+  return val;
+}, z5.enum(["high", "medium", "low"]).catch("medium"));
+var sectionCritiqueSchema = z5.object({
+  section: z5.string(),
+  assessment: z5.string(),
+  strengths: z5.preprocess((val) => {
+    if (typeof val === "string") return [val];
+    if (Array.isArray(val)) return val.map(String);
+    return [];
+  }, z5.array(z5.string()).default([])),
+  issues: z5.preprocess((val) => {
+    if (typeof val === "string") return [val];
+    if (Array.isArray(val)) return val.map(String);
+    return [];
+  }, z5.array(z5.string()).default([])),
+  severity: critiqueSeveritySchema
+});
+var scoreNumber = z5.coerce.number().transform((n) => Math.round(n)).pipe(z5.number().min(0).max(100));
+var profileScoresSchema = z5.object({
+  searchRelevance: scoreNumber,
+  humanVoice: scoreNumber,
+  credibility: scoreNumber,
+  positioningClarity: scoreNumber,
+  evidenceCoverage: scoreNumber
+});
+var scoreExplanationsSchema = z5.object({
+  searchRelevance: z5.string().default(""),
+  humanVoice: z5.string().default(""),
+  credibility: z5.string().default(""),
+  positioningClarity: z5.string().default(""),
+  evidenceCoverage: z5.string().default("")
+});
+var profileDirectionSchema = z5.object({
+  positioning: z5.string(),
+  primaryRole: z5.string(),
+  alternativeRoles: z5.preprocess((val) => {
+    if (Array.isArray(val)) return val.map(String);
+    if (typeof val === "string" && val.trim()) return [val.trim()];
+    return [];
+  }, z5.array(z5.string()).default([])),
+  openToWorkTitles: z5.preprocess((val) => {
+    if (Array.isArray(val)) return val.map(String);
+    if (typeof val === "string" && val.trim()) return [val.trim()];
+    return void 0;
+  }, z5.array(z5.string()).optional()),
+  rationale: z5.string()
+});
+var profileGapTargetSectionSchema = z5.enum(["headline", "about", "experience", "skills"]);
+var profileGapSchema = z5.object({
+  id: z5.string(),
+  label: z5.string(),
+  targetSection: profileGapTargetSectionSchema,
+  targetExperienceId: z5.string().optional(),
+  targetBulletIndex: z5.number().optional(),
+  targetBlockId: z5.string().optional(),
+  suggestedUnlock: z5.string().optional()
+});
+var profileReviewSchema = z5.object({
+  targetMarket: z5.string().default("United States"),
+  language: z5.string().default("en"),
+  overallScore: scoreNumber,
+  scores: profileScoresSchema,
+  scoreExplanations: scoreExplanationsSchema.optional(),
+  executiveSummary: z5.string(),
+  profileDirection: profileDirectionSchema,
+  critique: z5.array(sectionCritiqueSchema).default([]),
+  triageBottlenecks: z5.preprocess((val) => {
+    if (Array.isArray(val)) return val;
+    if (typeof val === "string" && val.trim()) return [val.trim()];
+    return [];
+  }, z5.array(z5.string()).default([])),
+  primaryGaps: z5.array(profileGapSchema).optional(),
+  inboundReadiness: z5.object({
+    score: scoreNumber,
+    primaryGapId: z5.string().optional()
+  }).optional()
+});
+var rewrittenExperienceSchema = z5.object({
+  id: z5.string().optional(),
+  title: z5.string(),
+  companyName: z5.string(),
+  bullets: z5.preprocess((val) => {
+    if (typeof val === "string") return [val];
+    if (Array.isArray(val)) return val.map(String);
+    return [];
+  }, z5.array(z5.string()).default([]))
+});
+var rewrittenProfileSchema = z5.object({
+  headline: z5.string(),
+  summary: z5.string(),
+  experiences: z5.array(rewrittenExperienceSchema).default([]),
+  skills: z5.preprocess((val) => {
+    if (typeof val === "string") return val.split(/,\s*/);
+    if (Array.isArray(val)) {
+      return val.map((v) => typeof v === "object" && v && "name" in v ? String(v.name) : String(v));
+    }
+    return [];
+  }, z5.array(z5.string()).default([])),
+  openToWorkTitles: z5.preprocess((val) => {
+    if (Array.isArray(val)) return val.map(String);
+    if (typeof val === "string" && val.trim()) return [val.trim()];
+    return void 0;
+  }, z5.array(z5.string()).optional()),
+  cardConversionBadges: z5.preprocess((val) => {
+    if (Array.isArray(val)) return val.map(String);
+    if (typeof val === "string" && val.trim()) return [val.trim()];
+    return void 0;
+  }, z5.array(z5.string()).optional()),
+  cardConversionReasons: z5.preprocess((val) => {
+    if (Array.isArray(val)) return val.map(String);
+    if (typeof val === "string" && val.trim()) return [val.trim()];
+    return void 0;
+  }, z5.array(z5.string()).optional())
+});
+var profileAnalysisSchema = z5.object({
+  targetMarket: z5.string().default("United States"),
+  language: z5.string().default("en"),
+  initialScore: scoreNumber.optional(),
+  overallScore: scoreNumber,
+  scores: profileScoresSchema,
+  scoreExplanations: scoreExplanationsSchema.optional(),
+  executiveSummary: z5.string(),
+  profileDirection: profileDirectionSchema,
+  critique: z5.array(sectionCritiqueSchema).default([]),
+  triageBottlenecks: z5.preprocess((val) => {
+    if (Array.isArray(val)) return val;
+    if (typeof val === "string" && val.trim()) return [val.trim()];
+    return [];
+  }, z5.array(z5.string()).default([])),
+  primaryGaps: z5.array(profileGapSchema).optional(),
+  inboundReadiness: z5.object({
+    score: scoreNumber,
+    primaryGapId: z5.string().optional()
+  }).optional(),
+  rewritten: rewrittenProfileSchema
+});
+var inboundStageStatusSchema = z5.enum(["ready", "needs_attention", "blocked", "not_measurable"]);
+var inboundStageSchema = z5.object({
+  id: z5.enum(["search", "card", "profile", "inmail"]),
+  name: z5.string(),
+  score: z5.number().optional(),
+  status: inboundStageStatusSchema,
+  primaryGapId: z5.string().optional(),
+  primaryGap: profileGapSchema.optional(),
+  description: z5.string().optional()
+});
+var inboundJourneySchema = z5.object({
+  search: inboundStageSchema,
+  card: inboundStageSchema,
+  profile: inboundStageSchema,
+  inmail: inboundStageSchema,
+  stages: z5.array(inboundStageSchema)
+});
+
+// ../core/src/domain/interview.ts
+import { z as z6 } from "zod";
+var interviewCategorySchema = z6.preprocess((val) => {
+  if (typeof val === "string") {
+    const lower = val.toLowerCase().trim();
+    if (lower.includes("tech") || lower.includes("arch") || lower.includes("deep")) return "technical-depth";
+    if (lower.includes("scale") || lower.includes("volume") || lower.includes("concurr")) return "scale";
+    if (lower.includes("impact") || lower.includes("result") || lower.includes("metric")) return "impact";
+    if (lower.includes("lead") || lower.includes("mentor")) return "leadership";
+    if (lower.includes("responsib") || lower.includes("invisib")) return "responsibility";
+    if (lower.includes("pref") || lower.includes("stack")) return "preference";
+    if (lower.includes("diff") || lower.includes("unique")) return "differentiation";
+    if (lower.includes("credib") || lower.includes("evid")) return "credibility";
+    if (lower.includes("market") || lower.includes("align")) return "market";
+    if (lower.includes("direct") || lower.includes("goal")) return "direction";
+    return lower;
+  }
+  return val;
+}, z6.enum([
+  "direction",
+  "responsibility",
+  "technical-depth",
+  "impact",
+  "scale",
+  "leadership",
+  "preference",
+  "market",
+  "credibility",
+  "differentiation"
+]).catch("technical-depth"));
+var careerObjectiveSchema = z6.object({
+  targetMarket: z6.string().default("United States"),
+  primaryRole: z6.string().min(1),
+  seniority: z6.string().optional(),
+  workPreference: z6.enum(["remote", "hybrid", "onsite", "flexible"]).default("remote"),
+  excludedTechnologies: z6.array(z6.string()).default([])
+});
+var interviewAnswerTypeSchema = z6.preprocess((val) => {
+  if (typeof val === "string") {
+    const lower = val.toLowerCase().trim();
+    if (lower === "text") return "long-text";
+    if (lower.includes("choice") || lower.includes("select")) return "single-choice";
+    if (lower.includes("yes") || lower.includes("bool")) return "yes-no";
+    if (lower.includes("short")) return "short-text";
+    if (lower.includes("long")) return "long-text";
+  }
+  return val;
+}, z6.enum(["short-text", "long-text", "single-choice", "yes-no"]).catch("long-text"));
+var interviewQuestionSchema = z6.object({
+  id: z6.string().min(1),
+  category: interviewCategorySchema,
+  question: z6.string().min(1),
+  reason: z6.string().min(1),
+  placeholderExample: z6.string().optional(),
+  relatedExperience: z6.string().optional(),
+  answerType: interviewAnswerTypeSchema,
+  options: z6.array(z6.string()).optional(),
+  required: z6.boolean().default(false)
+});
+var interviewAnswerSchema = z6.object({
+  questionId: z6.string().min(1),
+  value: z6.string().default(""),
+  skipped: z6.boolean().default(false)
+});
+var confirmedFactSourceSchema = z6.preprocess((val) => {
+  if (typeof val === "string") {
+    const lower = val.toLowerCase().trim();
+    if (lower.includes("link") || lower.includes("pdf") || lower.includes("resume") || lower.includes("cv") || lower.includes("profile")) {
+      return "linkedin-profile";
+    }
+    return "interview";
+  }
+  return val;
+}, z6.enum(["linkedin-profile", "interview"]).catch("interview"));
+var confirmedFactSchema = z6.object({
+  id: z6.string().min(1),
+  statement: z6.string().min(1),
+  source: confirmedFactSourceSchema,
+  sourceReference: z6.string().default("Experi\xEAncia"),
+  confirmed: z6.boolean().default(false)
+});
+var interviewPlanSchema = z6.object({
+  questions: z6.array(interviewQuestionSchema).default([])
+});
+var interviewProgressSchema = z6.object({
+  readyForGeneration: z6.boolean(),
+  rationale: z6.string().min(1),
+  questions: z6.array(interviewQuestionSchema).default([]),
+  facts: z6.array(confirmedFactSchema).default([])
+});
+
+// ../core/src/domain/micro-integration.ts
+import { z as z7 } from "zod";
+var gapTermKindSchema = z7.enum([
+  "role",
+  "technology",
+  "concept",
+  "scale",
+  "tool",
+  "domain"
+]);
+var gapEvidenceStatusSchema = z7.enum([
+  "unverified",
+  "confirmed",
+  "denied",
+  "ambiguous"
+]);
+var gapEvidenceSchema = z7.object({
+  status: gapEvidenceStatusSchema,
+  experienceId: z7.string().optional(),
+  evidenceText: z7.string().optional(),
+  source: z7.enum(["candidate", "profile"])
+});
+var searchGapSchema = z7.object({
+  id: z7.string(),
+  term: z7.string(),
+  status: z7.enum(["weak", "missing"]),
+  kind: gapTermKindSchema,
+  targetSection: z7.enum(["headline", "about", "experience", "skills"]),
+  targetExperienceId: z7.string().optional(),
+  evidence: gapEvidenceSchema.optional()
+});
+var microPatchKindSchema = z7.enum([
+  "headline_replace",
+  "about_insert",
+  "experience_rewrite",
+  "skill_add",
+  "no_safe_change"
+]);
+var microIntegrationInputSchema = z7.object({
+  targetRole: z7.string(),
+  gap: searchGapSchema,
+  currentText: z7.string(),
+  context: z7.object({
+    headline: z7.string().optional(),
+    summary: z7.string().optional(),
+    skills: z7.array(z7.string()).optional(),
+    experience: z7.any().optional()
+  }).optional(),
+  evidence: gapEvidenceSchema,
+  style: z7.object({
+    language: z7.literal("en").default("en"),
+    tone: z7.literal("executive").default("executive")
+  }).optional()
+});
+var microIntegrationProposalSchema = z7.object({
+  status: z7.enum(["ready", "blocked"]),
+  patchKind: microPatchKindSchema,
+  term: z7.string(),
+  target: z7.object({
+    section: z7.enum(["headline", "about", "experience", "skills"]),
+    experienceId: z7.string().optional(),
+    bulletIndex: z7.number().optional()
+  }),
+  before: z7.string(),
+  after: z7.string().optional(),
+  rationale: z7.string(),
+  matchedEvidence: z7.array(z7.string()).default([]),
+  warnings: z7.array(z7.string()).default([])
+});
+function termMatchesText(content, term) {
+  if (!content || !term) return false;
+  const cleanTerm = term.trim().toLowerCase().replace(/^["']|["']$/g, "");
+  if (cleanTerm.length === 0) return false;
+  const cleanContent = content.toLowerCase();
+  const words = cleanTerm.split(/[\s\-_/]+/).filter(Boolean);
+  if (words.length === 0) return false;
+  if (words.length > 1) {
+    const escapedWords = words.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    const lastWord = words[words.length - 1];
+    const escapedLast = escapedWords[escapedWords.length - 1];
+    let stemPattern = `${escapedLast}(?:s|es|d|ed|ing)?`;
+    if (lastWord.length > 3 && lastWord.endsWith("e")) {
+      const root = lastWord.slice(0, -1);
+      const escapedRoot = root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      stemPattern = `(?:${escapedLast}(?:s|d)?|${escapedRoot}(?:ing|ed)?)`;
+    }
+    const flexiblePattern = "(?:^|[^a-z0-9])" + escapedWords.slice(0, -1).join("[\\s\\-_/]+") + "[\\s\\-_/]+" + stemPattern + "(?:[^a-z0-9]|$)";
+    try {
+      const rx = new RegExp(flexiblePattern, "i");
+      if (rx.test(cleanContent)) return true;
+    } catch {
+    }
+    const joined = words.join("");
+    const joinedRx = new RegExp(`(?:^|[^a-z0-9])${joined}(?:[^a-z0-9]|$)`, "i");
+    if (joinedRx.test(cleanContent)) return true;
+  } else if (words.length === 1) {
+    const word = words[0];
+    const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const rx = new RegExp(`(?:^|[^a-z0-9])${escaped}(?:s|es|d|ed|ing)?(?:[^a-z0-9]|$)`, "i");
+    if (rx.test(cleanContent)) return true;
+    if (word.length > 6) {
+      const prefixMatch = word.match(/^(micro|multi|cross|inter|sub|meta)(.*)$/);
+      if (prefixMatch) {
+        const hyphenated = `${prefixMatch[1]}-${prefixMatch[2]}`;
+        if (cleanContent.includes(hyphenated)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/tools/recruiter-simulator.ts
+var simulateRecruiterSearchInputSchema = z8.object({
+  headline: z8.string().describe("Headline atual ou proposta do candidato"),
+  summary: z8.string().default("").describe("Resumo ou se\xE7\xE3o About do perfil"),
+  skills: z8.array(z8.string()).default([]).describe("Lista de compet\xEAncias t\xE9cnicas registradas"),
+  experienceBullets: z8.array(z8.string()).default([]).describe("Bullets das experi\xEAncias profissionais"),
+  targetRole: z8.string().default("Senior Software Engineer").describe("Cargo-alvo da busca (ex: Senior Backend Engineer)"),
+  requiredKeywords: z8.array(z8.string()).optional().describe('Termos t\xE9cnicos ou palavras-chave obrigat\xF3rias a testar (ex: ["Go", "Kubernetes", "Microservices"])')
+});
+async function handleSimulateRecruiterSearch(input) {
+  const defaultKeywords = input.requiredKeywords?.length ? input.requiredKeywords : [input.targetRole, "Senior", "Remote", "Architecture", "Scale"];
+  const highPriorityText = `${input.headline} ${input.skills.join(" ")}`;
+  const bodyText = `${input.summary} ${input.experienceBullets.join(" ")}`;
+  const evaluations = defaultKeywords.map((term) => {
+    const inHighPriority = termMatchesText(highPriorityText, term);
+    const inBody = termMatchesText(bodyText, term);
+    let status = "missing";
+    let detail = "Termo n\xE3o encontrado no perfil.";
+    if (inHighPriority) {
+      status = "match";
+      detail = "Posicionado em local de peso 3x (Headline ou Top Skills).";
+    } else if (inBody) {
+      status = "weak";
+      detail = "Presente apenas no corpo do perfil ou bullets secund\xE1rios.";
+    }
+    return {
+      term,
+      status,
+      detail
+    };
+  });
+  const matchCount = evaluations.filter((e) => e.status === "match").length;
+  const weakCount = evaluations.filter((e) => e.status === "weak").length;
+  const missingCount = evaluations.filter((e) => e.status === "missing").length;
+  const total = evaluations.length || 1;
+  const matchPercentage = Math.round(
+    (matchCount * 1 + weakCount * 0.5) / total * 100
+  );
+  const overallStatus = matchPercentage >= 80 ? "match" : matchPercentage >= 40 ? "weak" : "missing";
+  const markdownSummary = `
+# Simula\xE7\xE3o de Busca do Recrutador (LinkedIn Recruiter ATS)
+
+**Cargo Buscado**: ${input.targetRole}
+**Compatibilidade com a Busca**: **${matchPercentage}%** (${overallStatus === "match" ? "\u{1F7E2} Alta Visibilidade" : overallStatus === "weak" ? "\u{1F7E1} Visibilidade Parcial" : "\u{1F534} Fora do Radar"})
+**Resumo de Termos**: ${matchCount} com Match Direto (3x), ${weakCount} Fracos, ${missingCount} Faltantes.
+
+## \u{1F50D} An\xE1lise de Termos-Chave
+${evaluations.map(
+    (e) => `- ${e.status === "match" ? "\u2713 \u{1F7E2}" : e.status === "weak" ? "\u26A0\uFE0F \u{1F7E1}" : "\u274C \u{1F534}"} **${e.term}**: ${e.detail}`
+  ).join("\n")}
+
+${missingCount > 0 ? `
+> \u{1F4A1} **Dica do Recrutador**: Adicione os termos faltantes diretamente na sua Headline ou na se\xE7\xE3o de Compet\xEAncias para triplicar a chance de indexa\xE7\xE3o.` : "\n> \u{1F3C6} **Excelente**: Seu perfil tem densidade perfeita para capturar filtros booleanos de recrutadores dos EUA."}
+`.trim();
+  return {
+    content: [
+      {
+        type: "text",
+        text: markdownSummary
+      }
+    ],
+    structuredData: {
+      overallStatus,
+      matchPercentage,
+      evaluations,
+      matchCount,
+      weakCount,
+      missingCount
+    }
+  };
+}
+
+// src/tools/xyz-bullet-converter.ts
+import { z as z9 } from "zod";
+var convertToXyzBulletInputSchema = z9.object({
+  rawBullet: z9.string().describe('Bullet original descritivo ou passivo (ex: "Desenvolvi microsservi\xE7os em Go para pagamentos")'),
+  roleContext: z9.string().default("Senior Software Engineer").describe('Contexto da empresa, cargo ou projeto (ex: "Fintech de pagamentos, alta escala")'),
+  action: z9.string().optional().describe('A\xE7\xE3o de impacto com verbo no passado (ex: "Architected and deployed distributed payment services")'),
+  metric: z9.string().optional().describe('M\xE9trica quantitativa [Y] (ex: "reducing p99 latency by 35% and scaling to 12,000 RPS")'),
+  method: z9.string().optional().describe('Como foi feito [Z] (ex: "by migrating monolith endpoints to Go microservices on AWS EKS")')
+});
+function formatGoogleXyzBullet(parts) {
+  const cleanAction = parts.action.trim().replace(/[.,;]+$/, "");
+  const cleanMetric = parts.metric.trim().replace(/[.,;]+$/, "");
+  const cleanMethod = parts.method.trim().replace(/[.,;]+$/, "");
+  const methodPrefix = /^by\s+/i.test(cleanMethod) ? "" : "by ";
+  const metricPrefix = /^measured by\s+/i.test(cleanMetric) ? "" : /^resulting in\s+/i.test(cleanMetric) ? "" : "measured by ";
+  return `${cleanAction}, ${metricPrefix}${cleanMetric}, ${methodPrefix}${cleanMethod}.`;
+}
+async function handleConvertToXyzBullet(input) {
+  const raw = input.rawBullet.trim();
+  if (input.action && input.metric && input.method) {
+    const formatted = formatGoogleXyzBullet({
+      action: input.action,
+      metric: input.metric,
+      method: input.method
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# Bullet Google XYZ Formatado
+
+\u2728 **${formatted}**
+
+- **[X] Accomplished**: ${input.action}
+- **[Y] Measured by**: ${input.metric}
+- **[Z] By doing**: ${input.method}
+`.trim()
+        }
+      ],
+      structuredData: {
+        formattedBullet: formatted,
+        parts: { action: input.action, metric: input.metric, method: input.method }
+      }
+    };
+  }
+  const metricRegex = /\b(\d+|%|\$|ms|s|k|m|rps|tps|x)\b/i;
+  const hasMetrics = metricRegex.test(raw);
+  const activeVerbs = [
+    "Architected",
+    "Engineered",
+    "Designed",
+    "Spearheaded",
+    "Optimized",
+    "Scaled",
+    "Automated",
+    "Refactored",
+    "Implemented",
+    "Streamlined",
+    "Accelerated"
+  ];
+  const cleanBullet = raw.replace(/^[-*•\s]+/, "");
+  const optionScale = `Architected and scaled core ${input.roleContext} workflows, measured by reducing p99 latency by 35% and handling 10k+ peak RPS, by redesigning synchronous bottlenecks with distributed message queues.`;
+  const optionCost = `Optimized cloud resource utilization and data processing pipelines, measured by reducing AWS infrastructure costs by 28% ($45k/year savings), by implementing intelligent autoscaling and caching layers.`;
+  const optionReliability = `Engineered robust automated CI/CD and deployment pipelines for ${input.roleContext}, measured by increasing deployment frequency by 3x and achieving 99.99% system availability, by establishing automated regression testing and canary releases.`;
+  const report = `
+# An\xE1lise de F\xF3rmula Google XYZ
+
+**Bullet Analisado**:
+> "${cleanBullet}"
+
+**Status de Auditoria**:
+- **Verbo de A\xE7\xE3o no Passado**: ${activeVerbs.some((v) => cleanBullet.toLowerCase().startsWith(v.toLowerCase())) ? "\u2705 Presente" : "\u26A0\uFE0F Recomendado substituir o in\xEDcio por um verbo de forte lideran\xE7a t\xE9cnica (ex: Architected, Engineered, Optimized)"}
+- **M\xE9trica Quantitativa [Y]**: ${hasMetrics ? "\u2705 Detectada" : "\u274C N\xE3o detectada \u2014 faltam n\xFAmeros, porcentagens, lat\xEAncia ou volume"}
+
+---
+
+## 3 Propostas Prontas de Google XYZ para este Contexto:
+1. **Foco em Escala & Performance (Lat\xEAncia/Throughput)**:
+   > \u2728 "${optionScale}"
+2. **Foco em Otimiza\xE7\xE3o de Custo & Recursos**:
+   > \u2728 "${optionCost}"
+3. **Foco em Confiabilidade & Qualidade de Engenharia**:
+   > \u2728 "${optionReliability}"
+
+## \u{1F4A1} Instru\xE7\xF5es para o Agente de IA:
+Pergunte ao candidato qual m\xE9trica real mais se aproxima da sua entrega (${hasMetrics ? "ou valide os n\xFAmeros detectados" : "ex: % de redu\xE7\xE3o de tempo, volume de requisi\xE7\xF5es ou economia"}). Em seguida, finalize o bullet usando a estrutura:
+\`Accomplished [X], measured by [Y], by doing [Z]\`.
+`.trim();
+  return {
+    content: [
+      {
+        type: "text",
+        text: report
+      }
+    ],
+    structuredData: {
+      hasMetrics,
+      rawBullet: cleanBullet,
+      proposals: [optionScale, optionCost, optionReliability]
+    }
+  };
+}
+
+// src/tools/headline-generator.ts
+import { z as z10 } from "zod";
+var generateHeadlineInputSchema = z10.object({
+  targetRole: z10.string().default("Senior Software Engineer").describe("Cargo pretendido em ingl\xEAs (ex: Staff Distributed Systems Engineer)"),
+  coreTechnologies: z10.array(z10.string()).min(1).max(5).default(["TypeScript", "React", "Node.js"]).describe("3 a 4 tecnologias centrais e mais procuradas da sua stack"),
+  keyDifferentiator: z10.string().optional().describe("Diferencial ou escopo t\xE9cnico (ex: High Scale, Fintech, Cloud Architecture)"),
+  seniorityOrScope: z10.string().default("US Remote").describe("Senioridade ou disponibilidade (ex: US Remote, Global Teams, Staff)")
+});
+async function handleGenerateHeadline(input) {
+  const techsStr = input.coreTechnologies.slice(0, 4).join(" \u2022 ");
+  const diffStr = input.keyDifferentiator || "Distributed Systems";
+  const scopeStr = input.seniorityOrScope || "US Remote";
+  const option1 = `${input.targetRole} | ${techsStr} | ${diffStr} | ${scopeStr}`;
+  const option2 = `${input.targetRole} | Scaling ${diffStr} with ${techsStr} | ${scopeStr}`;
+  const option3 = `${input.targetRole} | ${input.coreTechnologies.slice(0, 3).join(", ")} Specialist | ${scopeStr}`;
+  const proposals = [
+    {
+      type: "Niche Specialist (Recomendada)",
+      headline: option1.length > 160 ? option1.slice(0, 157) + "..." : option1,
+      charCount: option1.length,
+      focus: "Densidade m\xE1xima de palavras-chave para o algoritmo do LinkedIn Recruiter (peso 3x)."
+    },
+    {
+      type: "Scale & Impact Oriented",
+      headline: option2.length > 160 ? option2.slice(0, 157) + "..." : option2,
+      charCount: option2.length,
+      focus: "Comunica maturidade arquitetural e foco em resolu\xE7\xE3o de problemas de neg\xF3cio."
+    },
+    {
+      type: "Direct & Concise",
+      headline: option3.length > 160 ? option3.slice(0, 157) + "..." : option3,
+      charCount: option3.length,
+      focus: "F\xF3rmula limpa ideal para visualiza\xE7\xE3o completa no app mobile do LinkedIn."
+    }
+  ];
+  const markdownSummary = `
+# Propostas de Headline de Alta Convers\xE3o
+
+**Cargo-Alvo**: ${input.targetRole}
+
+${proposals.map(
+    (p, i) => `
+### Op\xE7\xE3o ${i + 1}: ${p.type}
+> \u2728 **"${p.headline}"**
+- **Caracteres**: ${p.charCount} / 160 ${p.charCount <= 160 ? "\u2713 (Dentro do limite recomendado)" : "\u26A0\uFE0F (Excedeu 160)"}
+- **Vantagem**: ${p.focus}
+`
+  ).join("\n")}
+
+> \u{1F4A1} **Regra de Ouro**: Mantenha sempre abaixo de 160 caracteres para garantir que os recrutadores leiam o cargo e as tecnologias inteiras tanto no Desktop quanto no Mobile.
+`.trim();
+  return {
+    content: [
+      {
+        type: "text",
+        text: markdownSummary
+      }
+    ],
+    structuredData: {
+      proposals
+    }
+  };
+}
+
+// src/tools/cdp-check.ts
+import { z as z11 } from "zod";
+
+// src/cdp/probe.ts
+async function checkChromeCdp(port = 9222, host = "127.0.0.1", timeoutMs = 2e3) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const versionRes = await fetch(`http://${host}:${port}/json/version`, {
+      signal: controller.signal
+    });
+    if (!versionRes.ok) {
+      throw new Error(`HTTP ${versionRes.status}: ${versionRes.statusText}`);
+    }
+    const versionData = await versionRes.json();
+    let pageTabs = [];
+    try {
+      const listRes = await fetch(`http://${host}:${port}/json/list`, {
+        signal: controller.signal
+      });
+      if (listRes.ok) {
+        const rawTabs = await listRes.json();
+        if (Array.isArray(rawTabs)) {
+          pageTabs = rawTabs.filter((t) => t.type === "page");
+        }
+      }
+    } catch {
+    }
+    const linkeGringoTab = pageTabs.find((t) => {
+      const lowerUrl = (t.url || "").toLowerCase();
+      return lowerUrl.includes("linkegringo") || lowerUrl.includes("5173") || lowerUrl.includes("muriel-gasparini.github.io");
+    });
+    return {
+      isRunning: true,
+      port,
+      host,
+      browser: versionData.Browser,
+      protocolVersion: versionData["Protocol-Version"],
+      activeTabs: pageTabs.map((t) => ({
+        id: t.id,
+        title: t.title,
+        url: t.url,
+        webSocketDebuggerUrl: t.webSocketDebuggerUrl
+      })),
+      linkeGringoTabFound: Boolean(linkeGringoTab),
+      linkeGringoTabUrl: linkeGringoTab?.url
+    };
+  } catch (err) {
+    const error = err;
+    const isTimeout = error.name === "AbortError" || error.name === "TimeoutError";
+    return {
+      isRunning: false,
+      port,
+      host,
+      activeTabs: [],
+      linkeGringoTabFound: false,
+      error: isTimeout ? "Conex\xE3o expirou (Chrome n\xE3o respondeu em 2s na porta " + port + ")" : "Porta fechada ou depura\xE7\xE3o remota desativada. Acesse chrome://inspect/#remote-debugging para ativar."
+    };
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+// src/tools/cdp-check.ts
+var checkChromeCdpInputSchema = z11.object({
+  port: z11.number().default(9222).describe("Porta do Chrome DevTools Protocol a ser testada (padr\xE3o 9222)"),
+  host: z11.string().default("127.0.0.1").describe("Host do Chrome (padr\xE3o 127.0.0.1)"),
+  timeoutMs: z11.number().default(2e3).describe("Tempo limite em milissegundos para a conex\xE3o")
+});
+async function handleCheckChromeCdp(input) {
+  const status = await checkChromeCdp(input.port, input.host, input.timeoutMs);
+  const markdownSummary = `
+# Status do Chrome Remote Debugging (CDP)
+
+**Porta Testada**: ${status.host}:${status.port}
+**Status da Conex\xE3o**: ${status.isRunning ? "\u{1F7E2} Conectado e Ativo" : "\u{1F534} Desconectado"}
+
+${status.isRunning ? `
+- **Vers\xE3o do Navegador**: ${status.browser || "Desconhecido"}
+- **Vers\xE3o do Protocolo DevTools**: ${status.protocolVersion || "1.3"}
+- **Total de Abas Abertas**: ${status.activeTabs.length}
+- **Aba do LinkeGringo**: ${status.linkeGringoTabFound ? `\u2713 Detectada (${status.linkeGringoTabUrl})` : "\u26A0\uFE0F Nenhuma aba do LinkeGringo aberta no momento"}
+
+${status.activeTabs.length > 0 ? `### Abas Encontradas:
+${status.activeTabs.map((t) => `- [${t.title}](${t.url})`).join("\n")}` : ""}
+` : `
+> \u274C **Motivo**: ${status.error || "Porta fechada."}
+> 
+> **Como ativar no Google Chrome (M144+)**:
+> 1. Abra uma nova aba e acesse: \`chrome://inspect/#remote-debugging\`
+> 2. Marque a op\xE7\xE3o para **Ativar depura\xE7\xE3o remota**.
+> 3. Se estiver usando o servidor oficial DevTools MCP, configure com \`--autoConnect\`.
+`}
+`.trim();
+  return {
+    content: [
+      {
+        type: "text",
+        text: markdownSummary
+      }
+    ],
+    structuredData: status
+  };
+}
+
+// src/server.ts
+function createLinkeGringoMcpServer() {
+  const server = new McpServer({
+    name: "linkegringo-mcp",
+    version: "1.0.0"
+  });
+  server.registerTool(
+    "audit_profile",
+    {
+      description: "Audita um perfil de LinkedIn (via caminho de PDF, base64 ou texto) contra os crit\xE9rios de contrata\xE7\xE3o de empresas tech dos EUA. Retorna nota Inbound (0-100), gargalos de triagem de recrutadores e lacunas de stack.",
+      inputSchema: auditProfileInputSchema.shape
+    },
+    async (args) => {
+      return await handleAuditProfile(args);
+    }
+  );
+  server.registerTool(
+    "simulate_recruiter_search",
+    {
+      description: "Simula buscas booleanas e algoritmos do LinkedIn Recruiter ATS. Avalia a presen\xE7a de palavras-chave com peso 3x em Headline/Skills e peso 1x em experi\xEAncias, calculando a probabilidade de indexa\xE7\xE3o.",
+      inputSchema: simulateRecruiterSearchInputSchema.shape
+    },
+    async (args) => {
+      return await handleSimulateRecruiterSearch(args);
+    }
+  );
+  server.registerTool(
+    "convert_to_xyz_bullet",
+    {
+      description: "Transforma descri\xE7\xF5es gen\xE9ricas de atividades em bullets de alto impacto seguindo a f\xF3rmula oficial do Google: Accomplished [X], measured by [Y], by doing [Z].",
+      inputSchema: convertToXyzBulletInputSchema.shape
+    },
+    async (args) => {
+      return await handleConvertToXyzBullet(args);
+    }
+  );
+  server.registerTool(
+    "generate_headline_proposals",
+    {
+      description: "Gera propostas de Headline (t\xEDtulo) no LinkedIn com at\xE9 160 caracteres, calibradas para visualiza\xE7\xE3o sem cortes no Desktop e Mobile e alta indexa\xE7\xE3o de busca por recrutadores gringos.",
+      inputSchema: generateHeadlineInputSchema.shape
+    },
+    async (args) => {
+      return await handleGenerateHeadline(args);
+    }
+  );
+  server.registerTool(
+    "check_chrome_cdp_status",
+    {
+      description: "Verifica se o Google Chrome est\xE1 com a depura\xE7\xE3o remota (CDP) ativada (via chrome://inspect/#remote-debugging ou porta 9222) e lista as abas dispon\xEDveis, verificando se o LinkeGringo est\xE1 aberto.",
+      inputSchema: checkChromeCdpInputSchema.shape
+    },
+    async (args) => {
+      return await handleCheckChromeCdp(args);
+    }
+  );
+  server.registerResource(
+    "guidelines",
+    "linkegringo://guidelines",
+    {
+      title: "Diretrizes Oficiais do LinkeGringo para Vagas nos EUA",
+      description: "Princ\xEDpios fundamentais: f\xF3rmula Google XYZ, headlines de at\xE9 160 caracteres, elimina\xE7\xE3o de red flags culturais brasileiras e maximiza\xE7\xE3o de Inbound Readiness.",
+      mimeType: "text/markdown"
+    },
+    async () => {
+      return {
+        contents: [
+          {
+            uri: "linkegringo://guidelines",
+            text: `
+# Diretrizes Oficiais LinkeGringo: Otimiza\xE7\xE3o de Perfil para Recrutadores dos EUA
+
+1. **Headline $le$ 160 caracteres**:
+   - Formato recomendado: \`[Cargo Espec\xEDfico] | [3-4 Tecnologias Core] | [Escala/Dom\xEDnio] | US Remote\`
+   - Evite slogans vagos ("Apaixonado por tecnologia", "Resolvendo problemas complexos").
+   - Headline tem peso 3x no algoritmo de busca do LinkedIn Recruiter.
+
+2. **F\xF3rmula Google XYZ para Experi\xEAncias**:
+   - Toda conquista deve responder: *"Accomplished [X], measured by [Y], by doing [Z]"*.
+   - Exemplo: *"Architected distributed event-driven payment service in Go, reducing p99 latency by 42% and scaling to 15,000 requests/sec."*
+
+3. **Incentivo a Inbound (Ser Descoberto)**:
+   - Recrutadores usam filtros booleanos estritos. Se "Senior Software Engineer" e "Go" n\xE3o estiverem no t\xEDtulo da experi\xEAncia atual ou na headline, voc\xEA n\xE3o entra no funil inicial.
+   - Elimine red flags de localiza\xE7\xE3o restrita e declare disponibilidade para contratos internacionais (W-8BEN / PJ Internacional / B2B).
+`.trim()
+          }
+        ]
+      };
+    }
+  );
+  return server;
+}
+
+// src/cli/installer.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function getMcpConfigsForSystem() {
+  const home = os.homedir();
+  const platform = os.platform();
+  const configs = [];
+  configs.push({
+    client: "Google Antigravity",
+    configPath: path.join(home, ".gemini", "config", "mcp_config.json")
+  });
+  if (platform === "darwin") {
+    configs.push({
+      client: "Claude Desktop (macOS)",
+      configPath: path.join(
+        home,
+        "Library",
+        "Application Support",
+        "Claude",
+        "claude_desktop_config.json"
+      )
+    });
+  } else if (platform === "win32") {
+    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    configs.push({
+      client: "Claude Desktop (Windows)",
+      configPath: path.join(appData, "Claude", "claude_desktop_config.json")
+    });
+  } else {
+    configs.push({
+      client: "Claude Desktop (Linux)",
+      configPath: path.join(home, ".config", "Claude", "claude_desktop_config.json")
+    });
+  }
+  configs.push({
+    client: "Cursor AI",
+    configPath: path.join(home, ".cursor", "mcp.json")
+  });
+  return configs;
+}
+function installMcpServerConfig(configPath) {
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  let configData = { mcpServers: {} };
+  let isNew = true;
+  if (fs.existsSync(configPath)) {
+    try {
+      const raw = fs.readFileSync(configPath, "utf8");
+      if (raw.trim()) {
+        configData = JSON.parse(raw);
+        isNew = false;
+      }
+    } catch {
+      configData = { mcpServers: {} };
+    }
+  }
+  if (!configData.mcpServers || typeof configData.mcpServers !== "object") {
+    configData.mcpServers = {};
+  }
+  configData.mcpServers["linkegringo"] = {
+    command: "npx",
+    args: ["-y", "@linkegringo/mcp"]
+  };
+  configData.mcpServers["chrome-devtools"] = {
+    command: "npx",
+    args: ["-y", "chrome-devtools-mcp@latest", "--autoConnect"]
+  };
+  fs.writeFileSync(configPath, JSON.stringify(configData, null, 2) + "\n", "utf8");
+  return {
+    status: isNew ? "created" : "updated",
+    path: configPath
+  };
+}
+function runInstaller() {
+  console.log("\n\u{1F680} LinkeGringo MCP - Instalador Autom\xE1tico");
+  console.log("================================================");
+  console.log("Configurando servidores em todos os clientes locais:\n");
+  const targets = getMcpConfigsForSystem();
+  const results = [];
+  for (const target of targets) {
+    try {
+      const res = installMcpServerConfig(target.configPath);
+      results.push({
+        client: target.client,
+        configPath: target.configPath,
+        status: res.status
+      });
+      console.log(`\u2705 [${target.client}]`);
+      console.log(`   Arquivo: ${target.configPath} (${res.status === "created" ? "Criado" : "Atualizado"})
+`);
+    } catch (err) {
+      results.push({
+        client: target.client,
+        configPath: target.configPath,
+        status: "error",
+        message: err.message
+      });
+      console.warn(`\u26A0\uFE0F [${target.client}] N\xE3o foi poss\xEDvel atualizar: ${err.message}
+`);
+    }
+  }
+  console.log("---");
+  console.log("\u{1F4A1} Comandos One-Line diretos para agentes de linha de comando (CLI):");
+  console.log("   \u2022 Antigravity CLI: agy mcp add linkegringo npx -y @linkegringo/mcp");
+  console.log("   \u2022 Codex CLI:       codex mcp add linkegringo -- npx -y @linkegringo/mcp");
+  console.log("   \u2022 Claude Code CLI: claude mcp add linkegringo npx -y @linkegringo/mcp");
+  console.log('   \u2022 Goose CLI:       goose configure --add-extension "npx -y @linkegringo/mcp"');
+  console.log("================================================");
+  console.log("\u{1F389} Instala\xE7\xE3o conclu\xEDda! Reinicie o Claude Desktop, Antigravity ou Cursor para ativar.\n");
+  return results;
+}
+
+// src/index.ts
+async function main() {
+  if (process.argv.includes("install") || process.argv.includes("setup") || process.argv.includes("--install")) {
+    runInstaller();
+    return;
+  }
+  const server = createLinkeGringoMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[LinkeGringo MCP] Servidor iniciado com sucesso via stdio.");
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((err) => {
+    console.error("[LinkeGringo MCP] Erro fatal na inicializa\xE7\xE3o:", err);
+    process.exit(1);
+  });
+}
+export {
+  checkChromeCdp,
+  createLinkeGringoMcpServer,
+  getMcpConfigsForSystem,
+  installMcpServerConfig,
+  runInstaller
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@linkegringo/mcp",
+  "version": "1.0.0",
+  "description": "Servidor MCP oficial do LinkeGringo para auditoria e otimização de perfis para o mercado internacional",
+  "type": "module",
+  "bin": {
+    "linkegringo-mcp": "dist/index.js",
+    "mcp": "dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@linkegringo/core": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.6.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}