@linkegringo/mcp 1.0.10 → 2.0.0

package/dist/index.js

@@ -169,8 +169,14 @@ var bridgeJobStore = new BridgeJobStore();
 
 // src/bridge/client.ts
 var DEFAULT_BRIDGE_URL = process.env.LINKEGRINGO_BRIDGE_URL || (process.env.NODE_ENV === "test" ? "" : "http://127.0.0.1:5174");
-async function getRemoteOrLocalPendingJob(jobId, bridgeUrl = DEFAULT_BRIDGE_URL) {
-  if (bridgeUrl) {
+function getBridgeUrl(overrideUrl) {
+  if (overrideUrl) return overrideUrl;
+  if (process.env.LINKEGRINGO_BRIDGE_URL) return process.env.LINKEGRINGO_BRIDGE_URL;
+  return process.env.NODE_ENV === "test" ? "" : "http://127.0.0.1:5174";
+}
+async function getRemoteOrLocalPendingJob(jobId, bridgeUrl = getBridgeUrl()) {
+  const urlBase = getBridgeUrl(bridgeUrl);
+  if (urlBase) {
     try {
       const url = jobId ? `${bridgeUrl}/api/jobs/${encodeURIComponent(jobId)}` : `${bridgeUrl}/api/jobs/pending`;
       const controller = new AbortController();
@@ -246,6 +252,89 @@ async function failRemoteOrLocalJob(jobId, error, bridgeUrl = DEFAULT_BRIDGE_URL
   }
   return bridgeJobStore.failJob(jobId, error);
 }
+async function listRemoteJobs(filter, bridgeUrl) {
+  const base = getBridgeUrl(bridgeUrl) || "http://127.0.0.1:5174";
+  const url = new URL(`${base}/api/jobs`);
+  if (filter?.status) url.searchParams.set("status", filter.status);
+  if (filter?.type) url.searchParams.set("type", filter.type);
+  const res = await fetch(url.toString());
+  if (!res.ok) {
+    throw new Error(`Falha ao listar jobs: HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  return data.jobs || [];
+}
+async function claimRemoteJob(jobId, agent, leaseDurationMs, bridgeUrl) {
+  const base = getBridgeUrl(bridgeUrl) || "http://127.0.0.1:5174";
+  const url = `${base}/api/jobs/${encodeURIComponent(jobId)}/claim`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ agent, leaseDurationMs })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `Falha ao dar claim no job ${jobId} (HTTP ${res.status})`);
+  }
+  const data = await res.json();
+  return data.job;
+}
+async function reportRemoteProgress(jobId, agent, update, bridgeUrl) {
+  const base = getBridgeUrl(bridgeUrl) || "http://127.0.0.1:5174";
+  const url = `${base}/api/jobs/${encodeURIComponent(jobId)}/progress`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ agent, ...update })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `Falha ao reportar progresso no job ${jobId}`);
+  }
+  const data = await res.json();
+  return data.job;
+}
+async function requestRemoteUserAction(jobId, agent, details, bridgeUrl) {
+  const base = getBridgeUrl(bridgeUrl) || "http://127.0.0.1:5174";
+  const url = `${base}/api/jobs/${encodeURIComponent(jobId)}/user-action`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ agent, ...details })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `Falha ao solicitar a\xE7\xE3o do usu\xE1rio no job ${jobId}`);
+  }
+  const data = await res.json();
+  return data.job;
+}
+async function inspectRemoteDocument(fileId, bridgeUrl) {
+  const base = getBridgeUrl(bridgeUrl) || "http://127.0.0.1:5174";
+  const url = `${base}/api/documents/${encodeURIComponent(fileId)}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `Documento n\xE3o encontrado: ${fileId}`);
+  }
+  const data = await res.json();
+  return data.document;
+}
+async function submitRemoteJobResult(jobId, agent, resultData, bridgeUrl) {
+  const base = getBridgeUrl(bridgeUrl) || "http://127.0.0.1:5174";
+  const url = `${base}/api/jobs/${encodeURIComponent(jobId)}/complete`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ agent, result: resultData })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `Falha ao submeter resultado do job ${jobId}`);
+  }
+  const data = await res.json();
+  return { job: data.job, resultId: data.resultId };
+}
 
 // src/tools/audit-profile.ts
 function getExperienceBulletCount(exp) {
@@ -522,7 +611,7 @@ ${issues.length > 0 ? issues.map(
 }
 
 // src/tools/recruiter-simulator.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 
 // ../core/src/domain/date-range.ts
 import { z as z2 } from "zod";
@@ -1013,14 +1102,404 @@ function termMatchesText(content, term) {
   return false;
 }
 
+// ../core/src/domain/job.ts
+import { z as z8 } from "zod";
+var jobTypeSchema = z8.enum([
+  "diagnostic",
+  "interview",
+  "fact_confirmation",
+  "rewrite",
+  "action_hub"
+]);
+var jobStatusSchema = z8.enum([
+  "created",
+  "waiting_for_agent",
+  "running",
+  "waiting_for_user",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var jobProgressPhaseSchema = z8.enum([
+  "loading_document",
+  "reading_document",
+  "extracting_facts",
+  "diagnosing",
+  "writing_result"
+]);
+var agentIdentitySchema = z8.object({
+  agentId: z8.string().min(1),
+  sessionId: z8.string().min(1),
+  clientName: z8.string().optional(),
+  clientVersion: z8.string().optional()
+});
+var fileFingerprintSchema = z8.object({
+  name: z8.string().min(1),
+  size: z8.number().int().nonnegative(),
+  lastModified: z8.number().nonnegative()
+});
+var documentHandleSchema = z8.object({
+  fileId: z8.string().min(1),
+  jobId: z8.string().min(1),
+  name: z8.string().min(1),
+  mediaType: z8.literal("application/pdf"),
+  size: z8.number().int().nonnegative(),
+  mtime: z8.number().nonnegative(),
+  root: z8.enum(["downloads", "desktop", "documents"]),
+  access: z8.literal("native-local-document"),
+  expiresAt: z8.string()
+});
+var jobEventTypeSchema = z8.enum([
+  "job.created",
+  "job.ready_for_agent",
+  "job.claimed",
+  "job.progress",
+  "job.lease_renewed",
+  "job.waiting_for_user",
+  "job.user_resumed",
+  "job.lease_expired",
+  "job.completed",
+  "job.failed",
+  "job.cancelled"
+]);
+var jobEventSchema = z8.object({
+  id: z8.string().min(1),
+  jobId: z8.string().min(1),
+  commandId: z8.string().nullish(),
+  type: jobEventTypeSchema,
+  timestamp: z8.string(),
+  payload: z8.unknown().optional()
+});
+var linkeGringoJobSchema = z8.object({
+  id: z8.string().min(1),
+  type: jobTypeSchema,
+  status: jobStatusSchema,
+  attempt: z8.number().int().nonnegative().default(0),
+  maxAttempts: z8.number().int().positive().default(3),
+  claimedBy: agentIdentitySchema.nullish(),
+  leaseExpiresAt: z8.string().nullish(),
+  expiresAt: z8.string(),
+  progress: z8.number().min(0).max(100).default(0),
+  currentPhase: jobProgressPhaseSchema.nullish(),
+  progressMessage: z8.string().nullish(),
+  resultId: z8.string().nullish(),
+  fileHandleId: z8.string().nullish(),
+  fileHandle: documentHandleSchema.optional(),
+  targetRole: z8.string().nullish(),
+  result: z8.unknown().optional(),
+  error: z8.string().nullish(),
+  createdAt: z8.string(),
+  updatedAt: z8.string(),
+  metadata: z8.record(z8.unknown()).optional()
+});
+
+// ../core/src/domain/job-state-machine.ts
+var InvalidJobTransitionError = class extends Error {
+  currentStatus;
+  commandType;
+  constructor(currentStatus, commandType, message) {
+    super(`Transi\xE7\xE3o de estado inv\xE1lida para o job [${currentStatus} -> ${commandType}]: ${message}`);
+    this.name = "InvalidJobTransitionError";
+    this.currentStatus = currentStatus;
+    this.commandType = commandType;
+  }
+};
+var DEFAULT_LEASE_DURATION_MS = 6e4;
+function generateEventId() {
+  return `evt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function transitionJob(job, command, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  const timestamp = command.timestamp || nowIso;
+  const eventId = generateEventId();
+  if (command.type === "cancel") {
+    if (job.status === "completed" || job.status === "failed" || job.status === "cancelled") {
+      throw new InvalidJobTransitionError(
+        job.status,
+        command.type,
+        "N\xE3o \xE9 poss\xEDvel cancelar um job que j\xE1 est\xE1 em estado terminal."
+      );
+    }
+    const nextJob = {
+      ...job,
+      status: "cancelled",
+      claimedBy: null,
+      leaseExpiresAt: null,
+      updatedAt: timestamp
+    };
+    const event = {
+      id: eventId,
+      jobId: job.id,
+      commandId: command.commandId,
+      type: "job.cancelled",
+      timestamp,
+      payload: { actor: command.actor, reason: command.reason }
+    };
+    return { nextJob, event };
+  }
+  if (command.type === "fail") {
+    if (job.status === "completed" || job.status === "failed" || job.status === "cancelled") {
+      throw new InvalidJobTransitionError(
+        job.status,
+        command.type,
+        "N\xE3o \xE9 poss\xEDvel marcar falha em um job que j\xE1 est\xE1 em estado terminal."
+      );
+    }
+    const nextJob = {
+      ...job,
+      status: "failed",
+      claimedBy: null,
+      leaseExpiresAt: null,
+      progressMessage: command.error,
+      updatedAt: timestamp
+    };
+    const event = {
+      id: eventId,
+      jobId: job.id,
+      commandId: command.commandId,
+      type: "job.failed",
+      timestamp,
+      payload: { error: command.error, actor: command.actor }
+    };
+    return { nextJob, event };
+  }
+  switch (job.status) {
+    case "created": {
+      if (command.type !== "ready_for_agent") {
+        throw new InvalidJobTransitionError(
+          job.status,
+          command.type,
+          "Jobs rec\xE9m-criados devem transitar para ready_for_agent."
+        );
+      }
+      const nextJob = {
+        ...job,
+        status: "waiting_for_agent",
+        updatedAt: timestamp
+      };
+      const event = {
+        id: eventId,
+        jobId: job.id,
+        commandId: command.commandId,
+        type: "job.ready_for_agent",
+        timestamp
+      };
+      return { nextJob, event };
+    }
+    case "waiting_for_agent": {
+      if (command.type !== "claim") {
+        throw new InvalidJobTransitionError(
+          job.status,
+          command.type,
+          "Jobs aguardando agente s\xF3 aceitam o comando claim."
+        );
+      }
+      const leaseMs = command.leaseDurationMs || DEFAULT_LEASE_DURATION_MS;
+      const leaseExpiresAt = new Date(new Date(timestamp).getTime() + leaseMs).toISOString();
+      const nextAttempt = job.attempt + 1;
+      const nextJob = {
+        ...job,
+        status: "running",
+        attempt: nextAttempt,
+        claimedBy: command.agent,
+        leaseExpiresAt,
+        updatedAt: timestamp
+      };
+      const event = {
+        id: eventId,
+        jobId: job.id,
+        commandId: command.commandId,
+        type: "job.claimed",
+        timestamp,
+        payload: { agent: command.agent, leaseExpiresAt, attempt: nextAttempt }
+      };
+      return { nextJob, event };
+    }
+    case "running": {
+      if ("agent" in command) {
+        if (!job.claimedBy || job.claimedBy.agentId !== command.agent.agentId) {
+          throw new InvalidJobTransitionError(
+            job.status,
+            command.type,
+            `Comando rejeitado: o job est\xE1 sob lease do agente [${job.claimedBy?.agentId || "desconhecido"}], mas foi chamado por [${command.agent.agentId}].`
+          );
+        }
+      }
+      if (command.type === "report_progress") {
+        const leaseMs = command.leaseDurationMs || DEFAULT_LEASE_DURATION_MS;
+        const leaseExpiresAt = new Date(new Date(timestamp).getTime() + leaseMs).toISOString();
+        const nextProgress = typeof command.progress === "number" ? Math.max(0, Math.min(100, command.progress)) : job.progress;
+        const nextJob = {
+          ...job,
+          progress: nextProgress,
+          currentPhase: command.phase ?? job.currentPhase,
+          progressMessage: command.message ?? job.progressMessage,
+          leaseExpiresAt,
+          updatedAt: timestamp
+        };
+        const event = {
+          id: eventId,
+          jobId: job.id,
+          commandId: command.commandId,
+          type: "job.progress",
+          timestamp,
+          payload: {
+            phase: nextJob.currentPhase,
+            progress: nextJob.progress,
+            message: nextJob.progressMessage,
+            leaseExpiresAt
+          }
+        };
+        return { nextJob, event };
+      }
+      if (command.type === "request_user_action") {
+        const nextJob = {
+          ...job,
+          status: "waiting_for_user",
+          leaseExpiresAt: null,
+          progressMessage: command.reason,
+          updatedAt: timestamp
+        };
+        const event = {
+          id: eventId,
+          jobId: job.id,
+          commandId: command.commandId,
+          type: "job.waiting_for_user",
+          timestamp,
+          payload: { reason: command.reason, prompt: command.prompt }
+        };
+        return { nextJob, event };
+      }
+      if (command.type === "complete") {
+        const nextJob = {
+          ...job,
+          status: "completed",
+          progress: 100,
+          resultId: command.resultId,
+          claimedBy: null,
+          leaseExpiresAt: null,
+          updatedAt: timestamp
+        };
+        const event = {
+          id: eventId,
+          jobId: job.id,
+          commandId: command.commandId,
+          type: "job.completed",
+          timestamp,
+          payload: { resultId: command.resultId, agent: command.agent }
+        };
+        return { nextJob, event };
+      }
+      if (command.type === "expire_lease") {
+        if (job.attempt >= job.maxAttempts) {
+          const nextJob2 = {
+            ...job,
+            status: "failed",
+            claimedBy: null,
+            leaseExpiresAt: null,
+            progressMessage: "Limite m\xE1ximo de tentativas excedido ap\xF3s expira\xE7\xE3o de leases.",
+            updatedAt: timestamp
+          };
+          const event2 = {
+            id: eventId,
+            jobId: job.id,
+            commandId: command.commandId,
+            type: "job.failed",
+            timestamp,
+            payload: { reason: "MAX_ATTEMPTS_EXCEEDED", attempt: job.attempt }
+          };
+          return { nextJob: nextJob2, event: event2 };
+        }
+        const nextJob = {
+          ...job,
+          status: "waiting_for_agent",
+          claimedBy: null,
+          leaseExpiresAt: null,
+          updatedAt: timestamp
+        };
+        const event = {
+          id: eventId,
+          jobId: job.id,
+          commandId: command.commandId,
+          type: "job.lease_expired",
+          timestamp,
+          payload: { previousAttempt: job.attempt, maxAttempts: job.maxAttempts, reason: command.reason }
+        };
+        return { nextJob, event };
+      }
+      throw new InvalidJobTransitionError(
+        job.status,
+        command.type,
+        `Comando [${command.type}] n\xE3o permitido enquanto o job est\xE1 running.`
+      );
+    }
+    case "waiting_for_user": {
+      if (command.type !== "user_resume") {
+        throw new InvalidJobTransitionError(
+          job.status,
+          command.type,
+          "Jobs aguardando usu\xE1rio s\xF3 aceitam o comando user_resume."
+        );
+      }
+      const nextJob = {
+        ...job,
+        status: "running",
+        updatedAt: timestamp
+      };
+      const event = {
+        id: eventId,
+        jobId: job.id,
+        commandId: command.commandId,
+        type: "job.user_resumed",
+        timestamp,
+        payload: { actor: command.actor, reason: command.reason, payload: command.payload }
+      };
+      return { nextJob, event };
+    }
+    case "completed":
+    case "failed":
+    case "cancelled": {
+      throw new InvalidJobTransitionError(
+        job.status,
+        command.type,
+        `O job j\xE1 est\xE1 em estado terminal [${job.status}] e n\xE3o pode receber novas transi\xE7\xF5es.`
+      );
+    }
+  }
+}
+
+// ../core/src/domain/job-results.ts
+import { z as z9 } from "zod";
+var jobResultEnvelopeSchema = z9.object({
+  id: z9.string().min(1),
+  jobId: z9.string().min(1),
+  schemaVersion: z9.string().default("1.0"),
+  submissionId: z9.string().min(1),
+  submittedBy: agentIdentitySchema,
+  createdAt: z9.string(),
+  payload: z9.unknown()
+});
+var diagnosticResultPayloadSchema = z9.object({
+  profile: profileSchema,
+  review: profileReviewSchema
+});
+var interviewResultPayloadSchema = z9.object({
+  interviewPlan: interviewPlanSchema
+});
+var factConfirmationResultPayloadSchema = z9.object({
+  confirmedFacts: z9.array(confirmedFactSchema)
+});
+var rewriteResultPayloadSchema = z9.object({
+  profileAnalysis: profileAnalysisSchema
+});
+
 // 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"])')
+var simulateRecruiterSearchInputSchema = z10.object({
+  headline: z10.string().describe("Headline atual ou proposta do candidato"),
+  summary: z10.string().default("").describe("Resumo ou se\xE7\xE3o About do perfil"),
+  skills: z10.array(z10.string()).default([]).describe("Lista de compet\xEAncias t\xE9cnicas registradas"),
+  experienceBullets: z10.array(z10.string()).default([]).describe("Bullets das experi\xEAncias profissionais"),
+  targetRole: z10.string().default("Senior Software Engineer").describe("Cargo-alvo da busca (ex: Senior Backend Engineer)"),
+  requiredKeywords: z10.array(z10.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"];
@@ -1086,13 +1565,13 @@ ${missingCount > 0 ? `
 }
 
 // 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")')
+import { z as z11 } from "zod";
+var convertToXyzBulletInputSchema = z11.object({
+  rawBullet: z11.string().describe('Bullet original descritivo ou passivo (ex: "Desenvolvi microsservi\xE7os em Go para pagamentos")'),
+  roleContext: z11.string().default("Senior Software Engineer").describe('Contexto da empresa, cargo ou projeto (ex: "Fintech de pagamentos, alta escala")'),
+  action: z11.string().optional().describe('A\xE7\xE3o de impacto com verbo no passado (ex: "Architected and deployed distributed payment services")'),
+  metric: z11.string().optional().describe('M\xE9trica quantitativa [Y] (ex: "reducing p99 latency by 35% and scaling to 12,000 RPS")'),
+  method: z11.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(/[.,;]+$/, "");
@@ -1190,12 +1669,12 @@ Pergunte ao candidato qual m\xE9trica real mais se aproxima da sua entrega (${ha
 }
 
 // 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)")
+import { z as z12 } from "zod";
+var generateHeadlineInputSchema = z12.object({
+  targetRole: z12.string().default("Senior Software Engineer").describe("Cargo pretendido em ingl\xEAs (ex: Staff Distributed Systems Engineer)"),
+  coreTechnologies: z12.array(z12.string()).min(1).max(5).default(["TypeScript", "React", "Node.js"]).describe("3 a 4 tecnologias centrais e mais procuradas da sua stack"),
+  keyDifferentiator: z12.string().optional().describe("Diferencial ou escopo t\xE9cnico (ex: High Scale, Fintech, Cloud Architecture)"),
+  seniorityOrScope: z12.string().default("US Remote").describe("Senioridade ou disponibilidade (ex: US Remote, Global Teams, Staff)")
 });
 async function handleGenerateHeadline(input) {
   const coreTechs = Array.isArray(input.coreTechnologies) ? input.coreTechnologies : ["TypeScript", "React", "Node.js"];
@@ -1255,7 +1734,7 @@ ${proposals.map(
 }
 
 // src/tools/get-pending-job.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // src/tools/format-job.ts
 function formatJobResponse(job) {
@@ -1449,8 +1928,8 @@ ${instructions}`
 }
 
 // src/tools/get-pending-job.ts
-var getPendingJobInputSchema = z11.object({
-  jobId: z11.string().optional().describe("ID espec\xEDfico do job a ser buscado (opcional. Se omitido, pega o pr\xF3ximo da fila)")
+var getPendingJobInputSchema = z13.object({
+  jobId: z13.string().optional().describe("ID espec\xEDfico do job a ser buscado (opcional. Se omitido, pega o pr\xF3ximo da fila)")
 });
 async function handleGetPendingJob(input = {}) {
   const job = await getRemoteOrLocalPendingJob(input.jobId);
@@ -1473,12 +1952,12 @@ async function handleGetPendingJob(input = {}) {
 }
 
 // src/tools/submit-job-result.ts
-import { z as z12 } from "zod";
-var submitJobResultInputSchema = z12.object({
-  jobId: z12.string().describe("ID do job a ser conclu\xEDdo"),
-  result: z12.any().describe("JSON com os dados estruturados exigidos pelo front-end (ex: ParseAndDiagnoseResult, InterviewPlan, ProfileAnalysis)"),
-  status: z12.enum(["completed", "failed"]).default("completed").describe("Status final do job"),
-  error: z12.string().optional().describe('Mensagem de erro caso o status seja "failed"')
+import { z as z14 } from "zod";
+var submitJobResultInputSchema = z14.object({
+  jobId: z14.string().describe("ID do job a ser conclu\xEDdo"),
+  result: z14.any().describe("JSON com os dados estruturados exigidos pelo front-end (ex: ParseAndDiagnoseResult, InterviewPlan, ProfileAnalysis)"),
+  status: z14.enum(["completed", "failed"]).default("completed").describe("Status final do job"),
+  error: z14.string().optional().describe('Mensagem de erro caso o status seja "failed"')
 });
 async function handleSubmitJobResult(input) {
   try {
@@ -1538,13 +2017,13 @@ O front-end em \`localhost:5173\` acabou de receber a resposta formatada e atual
 }
 
 // src/tools/watch-linkegringo.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 import http from "http";
-var watchLinkeGringoInputSchema = z13.object({
-  timeoutSeconds: z13.number().optional().describe(
+var watchLinkeGringoInputSchema = z15.object({
+  timeoutSeconds: z15.number().optional().describe(
     "Tempo m\xE1ximo em segundos para aguardar a chegada de um novo job da interface web do LinkeGringo (padr\xE3o: 60s, m\xE1x: 300s). Se j\xE1 houver um job na fila, retorna imediatamente."
   ),
-  bridgeUrl: z13.string().optional().describe("URL base do bridge HTTP local do LinkeGringo (padr\xE3o: http://127.0.0.1:5174)")
+  bridgeUrl: z15.string().optional().describe("URL base do bridge HTTP local do LinkeGringo (padr\xE3o: http://127.0.0.1:5174)")
 });
 async function waitForNextJob(bridgeUrl, timeoutMs) {
   const localPending = bridgeJobStore.getPendingJob();
@@ -1675,129 +2154,551 @@ A interface web est\xE1 conectada ao Bridge. Assim que o usu\xE1rio clicar em **
   return formatJobResponse(job);
 }
 
-// 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(
-    "get_pending_job",
-    {
-      description: "Obt\xE9m os dados completos de um job pelo ID (ou o pr\xF3ximo da fila). Use APENAS quando for notificado de um job espec\xEDfico (ex: por watcher em background). N\xC3O use esta ferramenta para iniciar escuta ou checar jobs antes de iniciar o watch.",
-      inputSchema: getPendingJobInputSchema.shape
-    },
-    async (args) => {
-      return await handleGetPendingJob(args);
-    }
-  );
-  server.registerTool(
-    "submit_job_result",
-    {
-      description: "Envia o resultado estruturado do processamento de um job de volta para o navegador do LinkeGringo, desbloqueando a tela do usu\xE1rio instantaneamente. Sempre chame esta ferramenta imediatamente ap\xF3s processar um job recebido por watch_linkegringo ou get_pending_job.",
-      inputSchema: submitJobResultInputSchema.shape
-    },
-    async (args) => {
-      return await handleSubmitJobResult(args);
-    }
-  );
-  server.registerTool(
-    "watch_linkegringo",
-    {
-      description: 'Inicia a escuta ativa (watch) por jobs enviados pela interface web do LinkeGringo (http://127.0.0.1:5174). Use esta ferramenta SEMPRE que o usu\xE1rio disser "iniciar watch", "escutar", "conectar ao LinkeGringo" ou similar. N\xC3O chame get_pending_job antes desta ferramenta. Bloqueia aguardando e retorna o job assim que ele for submetido no navegador.',
-      inputSchema: watchLinkeGringoInputSchema.shape
-    },
-    async (args) => {
-      return await handleWatchLinkeGringo(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."*
+// src/tools/list-jobs.ts
+import { z as z16 } from "zod";
+var listJobsInputSchema = z16.object({
+  status: jobStatusSchema.optional().describe("Filtra jobs pelo status atual (ex: waiting_for_agent, running, completed)"),
+  type: jobTypeSchema.optional().describe("Filtra jobs pelo tipo (ex: diagnostic, interview, rewrite)")
+});
+async function handleListJobs(input = {}) {
+  try {
+    const jobs = await listRemoteJobs(input);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Encontrados ${jobs.length} job(s)${input.status ? ` com status "${input.status}"` : ""}.`
+        }
+      ],
+      structuredData: {
+        total: jobs.length,
+        jobs: jobs.map((j) => ({
+          id: j.id,
+          type: j.type,
+          status: j.status,
+          targetRole: j.targetRole,
+          fileHandleId: j.fileHandleId,
+          createdAt: j.createdAt,
+          leaseExpiresAt: j.leaseExpiresAt
+        }))
+      }
+    };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Erro ao listar jobs: ${err.message}`
+        }
+      ]
+    };
+  }
+}
 
-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/tools/claim-job.ts
+import { z as z17 } from "zod";
+var claimJobInputSchema = z17.object({
+  jobId: z17.string().min(1).describe("ID \xFAnico do job a ser assumido (ex: job_123)"),
+  agent: agentIdentitySchema.describe("Identidade do agente assumindo o job (agentId e sessionId)"),
+  leaseDurationMs: z17.number().int().positive().optional().describe("Dura\xE7\xE3o do lease exclusivo em milissegundos (padr\xE3o: 60000ms / 60s)")
+});
+async function handleClaimJob(input) {
+  try {
+    const job = await claimRemoteJob(input.jobId, input.agent, input.leaseDurationMs);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Job ${job.id} assumido com sucesso pelo agente ${input.agent.agentId}. Status atual: ${job.status}. Lease expira em: ${job.leaseExpiresAt}.`
+        }
+      ],
+      structuredData: {
+        success: true,
+        job
+      }
+    };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Falha ao dar claim no job ${input.jobId}: ${err.message}`
+        }
+      ]
+    };
+  }
 }
 
-// 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 = [];
-  const antigravityPath = path.join(home, ".gemini", "config", "mcp_config.json");
-  configs.push({
+// src/tools/report-progress.ts
+import { z as z18 } from "zod";
+var reportProgressInputSchema = z18.object({
+  jobId: z18.string().min(1).describe("ID do job cujo progresso est\xE1 sendo atualizado"),
+  agent: agentIdentitySchema.describe("Identidade do agente atual com lease no job"),
+  phase: jobProgressPhaseSchema.optional().describe("Fase atual do trabalho (ex: loading_document, extracting_facts, diagnosing, writing_result)"),
+  progress: z18.number().min(0).max(100).optional().describe("Porcentagem de progresso num\xE9rico de 0 a 100"),
+  message: z18.string().optional().describe("Mensagem descritiva e concisa exibida para o usu\xE1rio na interface web"),
+  leaseDurationMs: z18.number().int().positive().optional().describe("Tempo adicional de renova\xE7\xE3o do lease em ms (padr\xE3o: 60000ms)")
+});
+async function handleReportProgress(input) {
+  try {
+    const job = await reportRemoteProgress(input.jobId, input.agent, {
+      phase: input.phase,
+      progress: input.progress,
+      message: input.message,
+      leaseDurationMs: input.leaseDurationMs
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Progresso do job ${job.id} atualizado: ${input.progress ?? job.progress}% (${input.phase ?? job.currentPhase ?? "em execu\xE7\xE3o"}). Lease renovado at\xE9 ${job.leaseExpiresAt}.`
+        }
+      ],
+      structuredData: {
+        success: true,
+        jobId: job.id,
+        progress: job.progress,
+        phase: job.currentPhase ?? input.phase,
+        leaseExpiresAt: job.leaseExpiresAt
+      }
+    };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Falha ao reportar progresso no job ${input.jobId}: ${err.message}`
+        }
+      ]
+    };
+  }
+}
+
+// src/tools/inspect-document.ts
+import { z as z19 } from "zod";
+var inspectDocumentInputSchema = z19.object({
+  fileId: z19.string().min(1).describe("Capability token opaco do documento registrado (ex: doc_123)")
+});
+async function handleInspectDocument(input) {
+  try {
+    const document = await inspectRemoteDocument(input.fileId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Documento inspecionado com sucesso: "${document.name}" (${(document.size / 1024).toFixed(1)} KB, ${document.mediaType}). Modo de acesso: ${document.access}. Origem: ${document.root}.`
+        }
+      ],
+      structuredData: {
+        fileId: document.fileId,
+        jobId: document.jobId,
+        name: document.name,
+        mediaType: document.mediaType,
+        size: document.size,
+        mtime: document.mtime,
+        root: document.root,
+        access: document.access,
+        expiresAt: document.expiresAt
+      }
+    };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Falha ao inspecionar documento ${input.fileId}: ${err.message}`
+        }
+      ]
+    };
+  }
+}
+
+// src/tools/request-user-action.ts
+import { z as z20 } from "zod";
+var requestUserActionInputSchema = z20.object({
+  jobId: z20.string().min(1).describe("ID do job que requer interven\xE7\xE3o humana"),
+  agent: agentIdentitySchema.describe("Identidade do agente"),
+  reason: z20.string().min(1).describe('Motivo da pausa (ex: "needs_fact_confirmation", "unclear_company_name")'),
+  prompt: z20.string().optional().describe("Instru\xE7\xE3o ou pergunta clara exibida para o usu\xE1rio na interface web")
+});
+async function handleRequestUserAction(input) {
+  try {
+    const job = await requestRemoteUserAction(input.jobId, input.agent, {
+      reason: input.reason,
+      prompt: input.prompt
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Job ${job.id} colocado em pausa aguardando a\xE7\xE3o do usu\xE1rio (status: waiting_for_user). Motivo: ${input.reason}. O usu\xE1rio responder\xE1 na interface web.`
+        }
+      ],
+      structuredData: {
+        success: true,
+        jobId: job.id,
+        status: job.status,
+        reason: input.reason
+      }
+    };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Falha ao solicitar interven\xE7\xE3o do usu\xE1rio no job ${input.jobId}: ${err.message}`
+        }
+      ]
+    };
+  }
+}
+
+// src/tools/submit-diagnostic.ts
+import { z as z21 } from "zod";
+var submitDiagnosticInputSchema = z21.object({
+  jobId: z21.string().min(1).describe("ID do job de diagn\xF3stico a ser finalizado"),
+  agent: agentIdentitySchema.describe("Identidade do agente"),
+  submissionId: z21.string().optional().describe("ID de submiss\xE3o para deduplica\xE7\xE3o idempotente (opcional)"),
+  payload: diagnosticResultPayloadSchema.describe(
+    "Resultado estruturado com Profile extra\xEDdo e ProfileReview detalhado"
+  )
+});
+async function handleSubmitDiagnostic(input) {
+  try {
+    const submissionId = input.submissionId || `sub_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const { job, resultId } = await submitRemoteJobResult(input.jobId, input.agent, {
+      submissionId,
+      schemaVersion: "1.0",
+      payload: input.payload
+    });
+    const score = input.payload.review.overallScore;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Diagn\xF3stico do job ${job.id} submetido com sucesso! Result ID: ${resultId}. Score Geral: ${score}/100. A interface web foi atualizada instantaneamente.`
+        }
+      ],
+      structuredData: {
+        success: true,
+        jobId: job.id,
+        resultId,
+        score
+      }
+    };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Falha ao submeter diagn\xF3stico para o job ${input.jobId}: ${err.message}`
+        }
+      ]
+    };
+  }
+}
+
+// src/tools/submit-interview.ts
+import { z as z22 } from "zod";
+var submitInterviewInputSchema = z22.object({
+  jobId: z22.string().min(1).describe("ID do job de entrevista a ser finalizado"),
+  agent: agentIdentitySchema.describe("Identidade do agente"),
+  submissionId: z22.string().optional().describe("ID de submiss\xE3o para deduplica\xE7\xE3o idempotente (opcional)"),
+  payload: interviewResultPayloadSchema.describe(
+    "Plano de entrevista estruturado contendo as perguntas estrat\xE9gicas para destravar o perfil"
+  )
+});
+async function handleSubmitInterview(input) {
+  try {
+    const submissionId = input.submissionId || `sub_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const { job, resultId } = await submitRemoteJobResult(input.jobId, input.agent, {
+      submissionId,
+      schemaVersion: "1.0",
+      payload: input.payload
+    });
+    const questionCount = input.payload.interviewPlan.questions?.length ?? 0;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Plano de entrevista para o job ${job.id} submetido com sucesso! Result ID: ${resultId}. Total de perguntas: ${questionCount}. O usu\xE1rio agora responder\xE1 as perguntas na interface web.`
+        }
+      ],
+      structuredData: {
+        success: true,
+        jobId: job.id,
+        resultId,
+        questionCount
+      }
+    };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Falha ao submeter plano de entrevista para o job ${input.jobId}: ${err.message}`
+        }
+      ]
+    };
+  }
+}
+
+// src/tools/submit-rewrite.ts
+import { z as z23 } from "zod";
+var submitRewriteInputSchema = z23.object({
+  jobId: z23.string().min(1).describe("ID do job de reescrita a ser finalizado"),
+  agent: agentIdentitySchema.describe("Identidade do agente"),
+  submissionId: z23.string().optional().describe("ID de submiss\xE3o para deduplica\xE7\xE3o idempotente (opcional)"),
+  payload: rewriteResultPayloadSchema.describe(
+    "An\xE1lise completa e perfil reescrito (ProfileAnalysis) contendo headlines, about, experi\xEAncias expandidas em Google XYZ e compara\xE7\xE3o de notas"
+  )
+});
+async function handleSubmitRewrite(input) {
+  try {
+    const submissionId = input.submissionId || `sub_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const { job, resultId } = await submitRemoteJobResult(input.jobId, input.agent, {
+      submissionId,
+      schemaVersion: "1.0",
+      payload: input.payload
+    });
+    const finalScore = input.payload.profileAnalysis.overallScore;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Perfil reescrito do job ${job.id} submetido com sucesso! Result ID: ${resultId}. Novo Score Geral: ${finalScore}/100. A interface web desbloqueou a tela final de resultados.`
+        }
+      ],
+      structuredData: {
+        success: true,
+        jobId: job.id,
+        resultId,
+        finalScore
+      }
+    };
+  } catch (err) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Falha ao submeter perfil reescrito para o job ${input.jobId}: ${err.message}`
+        }
+      ]
+    };
+  }
+}
+
+// src/server.ts
+function createLinkeGringoMcpServer() {
+  const server = new McpServer({
+    name: "linkegringo-mcp",
+    version: "1.0.0"
+  });
+  server.registerTool(
+    "list_jobs",
+    {
+      description: "Lista jobs cadastrados no LinkeGringo Bridge local (porta 5174). Permite filtrar por status (ex: waiting_for_agent, running, completed) ou tipo (diagnostic, interview, rewrite).",
+      inputSchema: listJobsInputSchema.shape
+    },
+    async (args) => {
+      return await handleListJobs(args);
+    }
+  );
+  server.registerTool(
+    "claim_job",
+    {
+      description: "Assume a execu\xE7\xE3o exclusiva (lease at\xF4mico) de um job pendente por 60 segundos. Garante que apenas um agente processe a tarefa por vez.",
+      inputSchema: claimJobInputSchema.shape
+    },
+    async (args) => {
+      return await handleClaimJob(args);
+    }
+  );
+  server.registerTool(
+    "report_progress",
+    {
+      description: "Atualiza a porcentagem (0-100), a fase atual e uma mensagem para o usu\xE1rio no navegador, renovando simultaneamente o lease exclusivo por mais 60s.",
+      inputSchema: reportProgressInputSchema.shape
+    },
+    async (args) => {
+      return await handleReportProgress(args);
+    }
+  );
+  server.registerTool(
+    "inspect_document",
+    {
+      description: "Consulta os metadados do documento PDF cadastrado via capability token (fileId). N\xE3o exp\xF5e paths locais arbitr\xE1rios do sistema de arquivos.",
+      inputSchema: inspectDocumentInputSchema.shape
+    },
+    async (args) => {
+      return await handleInspectDocument(args);
+    }
+  );
+  server.registerTool(
+    "request_user_action",
+    {
+      description: "Pausa o processamento do job e solicita confirma\xE7\xE3o ou dados do usu\xE1rio (Human-in-the-Loop) diretamente na interface web do LinkeGringo.",
+      inputSchema: requestUserActionInputSchema.shape
+    },
+    async (args) => {
+      return await handleRequestUserAction(args);
+    }
+  );
+  server.registerTool(
+    "submit_diagnostic",
+    {
+      description: "Submete o resultado final de um job de diagn\xF3stico estruturado com Profile e ProfileReview validados com Zod estrito.",
+      inputSchema: submitDiagnosticInputSchema.shape
+    },
+    async (args) => {
+      return await handleSubmitDiagnostic(args);
+    }
+  );
+  server.registerTool(
+    "submit_interview",
+    {
+      description: "Submete o resultado final de um job de entrevista com o InterviewPlan estruturado contendo perguntas estrat\xE9gicas.",
+      inputSchema: submitInterviewInputSchema.shape
+    },
+    async (args) => {
+      return await handleSubmitInterview(args);
+    }
+  );
+  server.registerTool(
+    "submit_rewrite",
+    {
+      description: "Submete o resultado final de um job de reescrita contendo ProfileAnalysis com Headlines calibradas, About e bullets Google XYZ.",
+      inputSchema: submitRewriteInputSchema.shape
+    },
+    async (args) => {
+      return await handleSubmitRewrite(args);
+    }
+  );
+  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(
+    "get_pending_job",
+    {
+      description: "Obt\xE9m os dados completos de um job pelo ID (ou o pr\xF3ximo da fila). Suporta retrocompatibilidade.",
+      inputSchema: getPendingJobInputSchema.shape
+    },
+    async (args) => {
+      return await handleGetPendingJob(args);
+    }
+  );
+  server.registerTool(
+    "submit_job_result",
+    {
+      description: "Envia o resultado gen\xE9rico de um job de volta para o navegador do LinkeGringo (retrocompatibilidade).",
+      inputSchema: submitJobResultInputSchema.shape
+    },
+    async (args) => {
+      return await handleSubmitJobResult(args);
+    }
+  );
+  server.registerTool(
+    "watch_linkegringo",
+    {
+      description: "Inicia a escuta ativa (watch) por jobs enviados pela interface web do LinkeGringo (http://127.0.0.1:5174). Bloqueia aguardando e retorna o job assim que ele for submetido no navegador.",
+      inputSchema: watchLinkeGringoInputSchema.shape
+    },
+    async (args) => {
+      return await handleWatchLinkeGringo(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 = [];
+  const antigravityPath = path.join(home, ".gemini", "config", "mcp_config.json");
+  configs.push({
     id: "antigravity",
     client: "Google Antigravity",
     configPath: antigravityPath,
@@ -1916,63 +2817,877 @@ function runInstaller(args = process.argv) {
       console.warn(`\u26A0\uFE0F [Workspace Local] Erro ao configurar: ${err.message}
 `);
     }
-    return results;
+    return results;
+  }
+  const detectedTargets = targets.filter((t) => t.detected);
+  const shouldInstallAll = options.all || detectedTargets.length === 0;
+  for (const target of targets) {
+    if (options.client && !target.id.includes(options.client)) {
+      continue;
+    }
+    if (!shouldInstallAll && !target.detected) {
+      results.push({
+        client: target.client,
+        configPath: target.configPath,
+        status: "skipped",
+        message: "Cliente n\xE3o detectado nesta m\xE1quina (use --all para for\xE7ar)"
+      });
+      console.log(`\u23ED\uFE0F  [${target.client}] N\xE3o detectado nesta m\xE1quina (pulado. Use --all para criar)`);
+      continue;
+    }
+    try {
+      const res = installMcpServerConfig(target.configPath);
+      results.push({
+        client: target.client,
+        configPath: target.configPath,
+        status: res.status
+      });
+      const tag = target.detected ? "(Detectado)" : "(Padr\xE3o)";
+      console.log(`\u2705 [${target.client}] ${tag}`);
+      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 seu cliente de IA para ativar.\n");
+  return results;
+}
+
+// src/bridge/server.ts
+import http2 from "http";
+
+// src/bridge/db.ts
+import { createRequire } from "module";
+import path2 from "path";
+import fs2 from "fs";
+import os2 from "os";
+var require2 = createRequire(import.meta.url);
+var { DatabaseSync } = require2("node:sqlite");
+function getDatabasePath(customPath) {
+  if (customPath) return customPath;
+  const dir = path2.join(os2.homedir(), ".linkegringo");
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  return path2.join(dir, "linkegringo.db");
+}
+function initDatabase(db) {
+  try {
+    db.exec("PRAGMA foreign_keys = ON;");
+    db.exec("PRAGMA synchronous = NORMAL;");
+  } catch {
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS jobs (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      status TEXT NOT NULL,
+      attempt INTEGER NOT NULL DEFAULT 0,
+      max_attempts INTEGER NOT NULL DEFAULT 3,
+      claimed_by TEXT,
+      lease_expires_at TEXT,
+      expires_at TEXT NOT NULL,
+      progress INTEGER NOT NULL DEFAULT 0,
+      current_phase TEXT,
+      progress_message TEXT,
+      result_id TEXT,
+      file_handle_id TEXT,
+      target_role TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      metadata TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS job_events (
+      id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      command_id TEXT,
+      type TEXT NOT NULL,
+      payload TEXT,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY(job_id) REFERENCES jobs(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS commands (
+      command_id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      result TEXT,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS job_results (
+      id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      schema_version TEXT NOT NULL,
+      submission_id TEXT NOT NULL UNIQUE,
+      submitted_by TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY(job_id) REFERENCES jobs(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS file_handles (
+      id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      media_type TEXT NOT NULL,
+      size INTEGER NOT NULL,
+      mtime INTEGER NOT NULL,
+      root TEXT NOT NULL,
+      path TEXT NOT NULL,
+      expires_at TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS agents (
+      agent_id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      client_name TEXT,
+      client_version TEXT,
+      capabilities TEXT,
+      last_seen_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+    CREATE INDEX IF NOT EXISTS idx_jobs_status_lease ON jobs(status, lease_expires_at);
+    CREATE INDEX IF NOT EXISTS idx_job_events_job_id ON job_events(job_id);
+    CREATE INDEX IF NOT EXISTS idx_commands_job_id ON commands(job_id);
+    CREATE INDEX IF NOT EXISTS idx_file_handles_job_id ON file_handles(job_id);
+    CREATE INDEX IF NOT EXISTS idx_agents_last_seen ON agents(last_seen_at);
+  `);
+}
+function createDatabase(dbPath) {
+  const targetPath = dbPath || getDatabasePath();
+  const db = new DatabaseSync(targetPath);
+  initDatabase(db);
+  return db;
+}
+
+// src/bridge/job-store.ts
+function parseJobRow(row) {
+  return {
+    id: row.id,
+    type: row.type,
+    status: row.status,
+    attempt: row.attempt,
+    maxAttempts: row.max_attempts,
+    claimedBy: row.claimed_by ? JSON.parse(row.claimed_by) : null,
+    leaseExpiresAt: row.lease_expires_at,
+    expiresAt: row.expires_at,
+    progress: row.progress,
+    currentPhase: row.current_phase || null,
+    progressMessage: row.progress_message,
+    resultId: row.result_id,
+    fileHandleId: row.file_handle_id,
+    targetRole: row.target_role,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+  };
+}
+function parseEventRow(row) {
+  return {
+    id: row.id,
+    jobId: row.job_id,
+    commandId: row.command_id,
+    type: row.type,
+    timestamp: row.created_at,
+    payload: row.payload ? JSON.parse(row.payload) : void 0
+  };
+}
+var JobStore = class {
+  constructor(db, onEventRecorded) {
+    this.db = db;
+    this.onEventRecorded = onEventRecorded;
+  }
+  db;
+  onEventRecorded;
+  getRawDb() {
+    return this.db;
+  }
+  // --- Transações e Idempotência ---
+  getCachedCommand(commandId) {
+    if (!commandId) return null;
+    const stmt = this.db.prepare("SELECT result FROM commands WHERE command_id = ?");
+    const row = stmt.get(commandId);
+    if (row && row.result) {
+      return JSON.parse(row.result);
+    }
+    return null;
+  }
+  saveCommand(commandId, jobId, type, result) {
+    if (!commandId) return;
+    const stmt = this.db.prepare(
+      "INSERT OR REPLACE INTO commands (command_id, job_id, type, result, created_at) VALUES (?, ?, ?, ?, ?)"
+    );
+    stmt.run(commandId, jobId, type, JSON.stringify(result), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  // --- Operações de Job ---
+  createJob(input) {
+    if (input.commandId) {
+      const cached = this.getCachedCommand(input.commandId);
+      if (cached) return cached;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    const jobId = input.id || `job_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const expiresInMs = input.expiresInMs || 24 * 60 * 60 * 1e3;
+    const expiresAt = new Date(now.getTime() + expiresInMs).toISOString();
+    let job = {
+      id: jobId,
+      type: input.type,
+      status: "created",
+      attempt: 0,
+      maxAttempts: 3,
+      claimedBy: null,
+      leaseExpiresAt: null,
+      expiresAt,
+      progress: 0,
+      currentPhase: null,
+      progressMessage: null,
+      resultId: null,
+      fileHandleId: input.fileHandleId || null,
+      targetRole: input.targetRole || null,
+      createdAt: nowIso,
+      updatedAt: nowIso,
+      metadata: input.metadata
+    };
+    const insertJobStmt = this.db.prepare(`
+      INSERT INTO jobs (
+        id, type, status, attempt, max_attempts, claimed_by, lease_expires_at,
+        expires_at, progress, current_phase, progress_message, result_id,
+        file_handle_id, target_role, created_at, updated_at, metadata
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    insertJobStmt.run(
+      job.id,
+      job.type,
+      job.status,
+      job.attempt,
+      job.maxAttempts,
+      job.claimedBy ? JSON.stringify(job.claimedBy) : null,
+      job.leaseExpiresAt ?? null,
+      job.expiresAt,
+      job.progress,
+      job.currentPhase ?? null,
+      job.progressMessage ?? null,
+      job.resultId ?? null,
+      job.fileHandleId ?? null,
+      job.targetRole ?? null,
+      job.createdAt,
+      job.updatedAt,
+      job.metadata ? JSON.stringify(job.metadata) : null
+    );
+    this.recordEvent({
+      id: `evt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      jobId: job.id,
+      commandId: input.commandId,
+      type: "job.created",
+      timestamp: nowIso,
+      payload: { type: job.type, targetRole: job.targetRole }
+    });
+    if (input.autoReady !== false) {
+      const transition = transitionJob(job, { type: "ready_for_agent", commandId: input.commandId }, nowIso);
+      job = transition.nextJob;
+      this.updateJobRow(job);
+      this.recordEvent(transition.event);
+    }
+    this.saveCommand(input.commandId, job.id, "create_job", job);
+    return job;
+  }
+  getJob(id) {
+    const stmt = this.db.prepare("SELECT * FROM jobs WHERE id = ?");
+    const row = stmt.get(id);
+    return row ? parseJobRow(row) : null;
+  }
+  listJobs(filter) {
+    let query = "SELECT * FROM jobs WHERE 1=1";
+    const params = [];
+    if (filter?.status) {
+      query += " AND status = ?";
+      params.push(filter.status);
+    }
+    if (filter?.type) {
+      query += " AND type = ?";
+      params.push(filter.type);
+    }
+    query += " ORDER BY created_at DESC";
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map(parseJobRow);
+  }
+  claimJob(jobId, agent, options) {
+    if (options?.commandId) {
+      const cached = this.getCachedCommand(options.commandId);
+      if (cached) return cached;
+    }
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job [${jobId}] n\xE3o encontrado para claim.`);
+    }
+    const transition = transitionJob(
+      job,
+      {
+        type: "claim",
+        agent,
+        leaseDurationMs: options?.leaseDurationMs,
+        commandId: options?.commandId
+      }
+    );
+    this.updateJobRow(transition.nextJob);
+    this.recordEvent(transition.event);
+    this.registerAgent(agent);
+    this.saveCommand(options?.commandId, jobId, "claim_job", transition.nextJob);
+    return transition.nextJob;
+  }
+  reportProgress(jobId, agent, params) {
+    if (params.commandId) {
+      const cached = this.getCachedCommand(params.commandId);
+      if (cached) return cached;
+    }
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job [${jobId}] n\xE3o encontrado para reportProgress.`);
+    }
+    const previousProgress = job.progress;
+    const previousPhase = job.currentPhase;
+    const previousMessage = job.progressMessage;
+    const transition = transitionJob(
+      job,
+      {
+        type: "report_progress",
+        agent,
+        phase: params.phase,
+        progress: params.progress,
+        message: params.message,
+        leaseDurationMs: params.leaseDurationMs,
+        commandId: params.commandId
+      }
+    );
+    this.updateJobRow(transition.nextJob);
+    const delta = Math.abs(transition.nextJob.progress - previousProgress);
+    const phaseChanged = transition.nextJob.currentPhase !== previousPhase;
+    const msgChanged = Boolean(params.message && params.message !== previousMessage);
+    const shouldEmitEvent = delta >= 5 || phaseChanged || msgChanged;
+    if (shouldEmitEvent) {
+      this.recordEvent(transition.event);
+    }
+    this.registerAgent(agent);
+    this.saveCommand(params.commandId, jobId, "report_progress", transition.nextJob);
+    return transition.nextJob;
+  }
+  requestUserAction(jobId, agent, params) {
+    if (params.commandId) {
+      const cached = this.getCachedCommand(params.commandId);
+      if (cached) return cached;
+    }
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job [${jobId}] n\xE3o encontrado para requestUserAction.`);
+    }
+    const transition = transitionJob(
+      job,
+      {
+        type: "request_user_action",
+        agent,
+        reason: params.reason,
+        prompt: params.prompt,
+        commandId: params.commandId
+      }
+    );
+    this.updateJobRow(transition.nextJob);
+    this.recordEvent(transition.event);
+    this.saveCommand(params.commandId, jobId, "request_user_action", transition.nextJob);
+    return transition.nextJob;
+  }
+  resumeJob(jobId, params) {
+    if (params.commandId) {
+      const cached = this.getCachedCommand(params.commandId);
+      if (cached) return cached;
+    }
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job [${jobId}] n\xE3o encontrado para resume.`);
+    }
+    const transition = transitionJob(
+      job,
+      {
+        type: "user_resume",
+        actor: "user",
+        reason: params.reason,
+        payload: params.payload,
+        commandId: params.commandId
+      }
+    );
+    this.updateJobRow(transition.nextJob);
+    this.recordEvent(transition.event);
+    this.saveCommand(params.commandId, jobId, "resume_job", transition.nextJob);
+    return transition.nextJob;
+  }
+  completeJob(jobId, agent, result) {
+    if (result.commandId) {
+      const cached = this.getCachedCommand(result.commandId);
+      if (cached) return cached;
+    }
+    const existingResultStmt = this.db.prepare("SELECT id, job_id FROM job_results WHERE submission_id = ?");
+    const existing = existingResultStmt.get(result.submissionId);
+    if (existing) {
+      const existingJob = this.getJob(existing.job_id);
+      return { job: existingJob, resultId: existing.id };
+    }
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job [${jobId}] n\xE3o encontrado para completeJob.`);
+    }
+    const resultId = `res_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const transition = transitionJob(
+      job,
+      {
+        type: "complete",
+        agent,
+        resultId,
+        commandId: result.commandId
+      },
+      nowIso
+    );
+    const insertResultStmt = this.db.prepare(`
+      INSERT INTO job_results (
+        id, job_id, schema_version, submission_id, submitted_by, payload, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    insertResultStmt.run(
+      resultId,
+      job.id,
+      result.schemaVersion || "1.0",
+      result.submissionId,
+      JSON.stringify(agent),
+      JSON.stringify(result.payload),
+      nowIso
+    );
+    this.updateJobRow(transition.nextJob);
+    this.recordEvent(transition.event);
+    const response = { job: transition.nextJob, resultId };
+    this.saveCommand(result.commandId, jobId, "complete_job", response);
+    return response;
+  }
+  failJob(jobId, error, actor, commandId) {
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job [${jobId}] n\xE3o encontrado para failJob.`);
+    }
+    const transition = transitionJob(job, { type: "fail", error, actor, commandId });
+    this.updateJobRow(transition.nextJob);
+    this.recordEvent(transition.event);
+    return transition.nextJob;
+  }
+  cancelJob(jobId, actor, reason, commandId) {
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job [${jobId}] n\xE3o encontrado para cancelJob.`);
+    }
+    const transition = transitionJob(job, { type: "cancel", actor, reason, commandId });
+    this.updateJobRow(transition.nextJob);
+    this.recordEvent(transition.event);
+    return transition.nextJob;
   }
-  const detectedTargets = targets.filter((t) => t.detected);
-  const shouldInstallAll = options.all || detectedTargets.length === 0;
-  for (const target of targets) {
-    if (options.client && !target.id.includes(options.client)) {
-      continue;
+  // --- Recuperação de Falhas e Expiração ---
+  expireStaleLeases() {
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.db.prepare(`
+      SELECT * FROM jobs
+      WHERE status = 'running'
+        AND lease_expires_at IS NOT NULL
+        AND lease_expires_at < ?
+    `);
+    const rows = stmt.all(nowIso);
+    let recovered = 0;
+    for (const row of rows) {
+      const job = parseJobRow(row);
+      try {
+        const transition = transitionJob(job, { type: "expire_lease", reason: "Lease expired" }, nowIso);
+        this.updateJobRow(transition.nextJob);
+        this.recordEvent(transition.event);
+        recovered++;
+      } catch (err) {
+        console.error(`Erro ao expirar lease do job ${job.id}:`, err);
+      }
     }
-    if (!shouldInstallAll && !target.detected) {
-      results.push({
-        client: target.client,
-        configPath: target.configPath,
-        status: "skipped",
-        message: "Cliente n\xE3o detectado nesta m\xE1quina (use --all para for\xE7ar)"
-      });
-      console.log(`\u23ED\uFE0F  [${target.client}] N\xE3o detectado nesta m\xE1quina (pulado. Use --all para criar)`);
-      continue;
+    return recovered;
+  }
+  cleanupExpiredJobs() {
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.db.prepare(`
+      DELETE FROM jobs
+      WHERE expires_at < ? AND status IN ('completed', 'failed', 'cancelled')
+    `);
+    const result = stmt.run(nowIso);
+    return Number(result.changes);
+  }
+  // --- Event Log & SSE Replay ---
+  recordEvent(event) {
+    const stmt = this.db.prepare(`
+      INSERT INTO job_events (id, job_id, command_id, type, payload, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      event.id,
+      event.jobId,
+      event.commandId || null,
+      event.type,
+      event.payload ? JSON.stringify(event.payload) : null,
+      event.timestamp
+    );
+    this.onEventRecorded?.(event);
+  }
+  getEventsSince(jobId, lastEventId) {
+    if (!lastEventId) {
+      const stmt2 = this.db.prepare(`
+        SELECT * FROM job_events
+        WHERE job_id = ?
+        ORDER BY rowid ASC
+      `);
+      const rows2 = stmt2.all(jobId);
+      return rows2.map(parseEventRow);
     }
-    try {
-      const res = installMcpServerConfig(target.configPath);
-      results.push({
-        client: target.client,
-        configPath: target.configPath,
-        status: res.status
-      });
-      const tag = target.detected ? "(Detectado)" : "(Padr\xE3o)";
-      console.log(`\u2705 [${target.client}] ${tag}`);
-      console.log(`   Arquivo: ${target.configPath} (${res.status === "created" ? "Criado" : "Atualizado"})
+    const refStmt = this.db.prepare("SELECT rowid FROM job_events WHERE id = ?");
+    const ref = refStmt.get(lastEventId);
+    const refRowId = ref?.rowid ?? 0;
+    const stmt = this.db.prepare(`
+      SELECT * FROM job_events
+      WHERE job_id = ? AND rowid > ?
+      ORDER BY rowid ASC
+    `);
+    const rows = stmt.all(jobId, refRowId);
+    return rows.map(parseEventRow);
+  }
+  getJobResult(resultId) {
+    const stmt = this.db.prepare("SELECT * FROM job_results WHERE id = ?");
+    const row = stmt.get(resultId);
+    if (!row) return null;
+    return {
+      id: row.id,
+      jobId: row.job_id,
+      schemaVersion: row.schema_version,
+      submissionId: row.submission_id,
+      submittedBy: JSON.parse(row.submitted_by),
+      createdAt: row.created_at,
+      payload: JSON.parse(row.payload)
+    };
+  }
+  // --- File Handles ---
+  saveFileHandle(handle, realPath) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO file_handles (
+        id, job_id, name, media_type, size, mtime, root, path, expires_at, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      handle.fileId,
+      handle.jobId,
+      handle.name,
+      handle.mediaType,
+      handle.size,
+      handle.mtime,
+      handle.root,
+      realPath,
+      handle.expiresAt,
+      (/* @__PURE__ */ new Date()).toISOString()
+    );
+  }
+  getFileHandle(fileId) {
+    const stmt = this.db.prepare("SELECT * FROM file_handles WHERE id = ?");
+    const row = stmt.get(fileId);
+    if (!row) return null;
+    return {
+      fileId: row.id,
+      jobId: row.job_id,
+      name: row.name,
+      mediaType: row.media_type,
+      size: row.size,
+      mtime: row.mtime,
+      root: row.root,
+      access: "native-local-document",
+      expiresAt: row.expires_at,
+      path: row.path,
+      localPath: row.path
+    };
+  }
+  // --- Observabilidade de Agentes (Ponto 6 & 7) ---
+  registerAgent(agent, capabilities) {
+    const now = Date.now();
+    const stmt = this.db.prepare(`
+      INSERT INTO agents (
+        agent_id, session_id, client_name, client_version, capabilities, last_seen_at, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(agent_id) DO UPDATE SET
+        session_id = excluded.session_id,
+        client_name = excluded.client_name,
+        client_version = excluded.client_version,
+        capabilities = excluded.capabilities,
+        last_seen_at = excluded.last_seen_at
+    `);
+    stmt.run(
+      agent.agentId,
+      agent.sessionId,
+      agent.clientName || null,
+      agent.clientVersion || null,
+      capabilities ? JSON.stringify(capabilities) : null,
+      now,
+      now
+    );
+  }
+  listActiveAgents(maxAgeMs = 5 * 60 * 1e3) {
+    const cutoff = Date.now() - maxAgeMs;
+    const stmt = this.db.prepare("SELECT * FROM agents WHERE last_seen_at >= ? ORDER BY last_seen_at DESC");
+    const rows = stmt.all(cutoff);
+    return rows.map((r) => ({
+      agentId: r.agent_id,
+      sessionId: r.session_id,
+      clientName: r.client_name || void 0,
+      clientVersion: r.client_version || void 0,
+      lastSeenAt: r.last_seen_at
+    }));
+  }
+  // --- Auxiliares Internos ---
+  updateJobRow(job) {
+    const stmt = this.db.prepare(`
+      UPDATE jobs SET
+        type = ?,
+        status = ?,
+        attempt = ?,
+        max_attempts = ?,
+        claimed_by = ?,
+        lease_expires_at = ?,
+        expires_at = ?,
+        progress = ?,
+        current_phase = ?,
+        progress_message = ?,
+        result_id = ?,
+        file_handle_id = ?,
+        target_role = ?,
+        updated_at = ?,
+        metadata = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      job.type,
+      job.status,
+      job.attempt,
+      job.maxAttempts,
+      job.claimedBy ? JSON.stringify(job.claimedBy) : null,
+      job.leaseExpiresAt ?? null,
+      job.expiresAt,
+      job.progress,
+      job.currentPhase ?? null,
+      job.progressMessage ?? null,
+      job.resultId ?? null,
+      job.fileHandleId ?? null,
+      job.targetRole ?? null,
+      job.updatedAt,
+      job.metadata ? JSON.stringify(job.metadata) : null,
+      job.id
+    );
+  }
+};
+
+// src/bridge/sse.ts
+import { EventEmitter as EventEmitter2 } from "events";
+var SseBroker = class extends EventEmitter2 {
+  activeStreams = /* @__PURE__ */ new Map();
+  getSubscriberCount(jobId) {
+    if (!jobId) return this.activeStreams.size;
+    let count = 0;
+    for (const key of this.activeStreams.keys()) {
+      if (key.startsWith(`${jobId}:`)) count++;
+    }
+    return count;
+  }
+  publish(jobId, event) {
+    this.emit(`job:${jobId}`, event);
+    this.emit("global", { jobId, event });
+  }
+  formatSseMessage(event) {
+    const lines = [
+      `id: ${event.id}`,
+      `event: ${event.type}`,
+      `data: ${JSON.stringify(event)}`,
+      "",
+      ""
+    ];
+    return lines.join("\n");
+  }
+  handleJobEvents(req, res, jobId, store) {
+    const parsedUrl = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const lastEventId = req.headers["last-event-id"] || parsedUrl.searchParams.get("lastEventId") || void 0;
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      "Connection": "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+      "X-Accel-Buffering": "no"
+    });
+    res.flushHeaders?.();
+    res.write(`: connected to job ${jobId}
+
 `);
+    try {
+      const pastEvents = store.getEventsSince(jobId, lastEventId);
+      for (const evt of pastEvents) {
+        res.write(this.formatSseMessage(evt));
+      }
     } 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.error(`Erro ao buscar hist\xF3rico de eventos para o job ${jobId}:`, err);
+    }
+    const streamId = `${jobId}:${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const onEvent = (event) => {
+      try {
+        res.write(this.formatSseMessage(event));
+      } catch (err) {
+        cleanup();
+      }
+    };
+    const heartbeat = setInterval(() => {
+      try {
+        res.write(`: heartbeat ${(/* @__PURE__ */ new Date()).toISOString()}
+
 `);
+      } catch {
+        cleanup();
+      }
+    }, 15e3);
+    const cleanup = () => {
+      clearInterval(heartbeat);
+      this.off(`job:${jobId}`, onEvent);
+      this.activeStreams.delete(streamId);
+    };
+    this.on(`job:${jobId}`, onEvent);
+    this.activeStreams.set(streamId, { res, cleanup });
+    req.on("close", cleanup);
+  }
+  closeAll() {
+    for (const [id, stream] of this.activeStreams.entries()) {
+      try {
+        stream.res.end();
+      } catch {
+      }
+      stream.cleanup();
     }
+    this.activeStreams.clear();
   }
-  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 seu cliente de IA para ativar.\n");
-  return results;
+};
+var sseBroker = new SseBroker();
+
+// src/bridge/file-resolver.ts
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+function getDefaultScanRoots() {
+  const home = os3.homedir();
+  return [
+    { root: "downloads", dirPath: path3.join(home, "Downloads") },
+    { root: "desktop", dirPath: path3.join(home, "Desktop") },
+    { root: "documents", dirPath: path3.join(home, "Documents") }
+  ];
+}
+function scoreFileMatch(fileName, fileSize, fileMtime, fingerprint) {
+  let score = 0;
+  if (fileName === fingerprint.name) {
+    score += 40;
+  } else if (fileName.toLowerCase() === fingerprint.name.toLowerCase()) {
+    score += 35;
+  }
+  if (fileSize === fingerprint.size) {
+    score += 40;
+  }
+  if (Math.abs(fileMtime - fingerprint.lastModified) <= 3e3) {
+    score += 20;
+  }
+  return score;
+}
+function scanForCandidate(fingerprint, roots = getDefaultScanRoots()) {
+  const candidates = [];
+  for (const { root, dirPath } of roots) {
+    if (!fs3.existsSync(dirPath)) continue;
+    try {
+      const entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        const isPdf = entry.name.toLowerCase().endsWith(".pdf");
+        const isNameMatch = entry.name.toLowerCase() === fingerprint.name.toLowerCase();
+        if (!isPdf && !isNameMatch) continue;
+        const fullPath = path3.join(dirPath, entry.name);
+        try {
+          const stat = fs3.statSync(fullPath);
+          const score = scoreFileMatch(entry.name, stat.size, stat.mtimeMs, fingerprint);
+          if (score >= 60) {
+            candidates.push({
+              filePath: fullPath,
+              name: entry.name,
+              root,
+              size: stat.size,
+              mtime: stat.mtimeMs,
+              score
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (candidates.length === 0) {
+    return null;
+  }
+  candidates.sort((a, b) => b.score - a.score || b.mtime - a.mtime);
+  return candidates[0];
+}
+function resolveLocalDocument(store, jobId, fingerprint, customRoots) {
+  const match = scanForCandidate(fingerprint, customRoots);
+  if (!match) {
+    throw new Error(
+      `N\xE3o foi poss\xEDvel localizar o arquivo "${fingerprint.name}" (${fingerprint.size} bytes) nas pastas Downloads, Desktop ou Documents do usu\xE1rio local.`
+    );
+  }
+  const fileId = `doc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString();
+  const handle = {
+    fileId,
+    jobId,
+    name: match.name,
+    mediaType: "application/pdf",
+    size: match.size,
+    mtime: match.mtime,
+    root: match.root,
+    access: "native-local-document",
+    expiresAt
+  };
+  store.saveFileHandle(handle, match.filePath);
+  return handle;
 }
 
 // src/bridge/server.ts
-import http2 from "http";
 function setCorsHeaders(res) {
   res.setHeader("Access-Control-Allow-Origin", "*");
   res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Last-Event-ID");
   res.setHeader("Access-Control-Max-Age", "86400");
 }
 function sendJson(res, statusCode, data) {
@@ -2001,7 +3716,17 @@ async function parseBody(req) {
   });
 }
 function createBridgeHttpServer(options = {}) {
-  const activeSseClients = /* @__PURE__ */ new Map();
+  const store = options.jobStore || new JobStore(createDatabase(options.dbPath), (event) => {
+    sseBroker.publish(event.jobId, event);
+  });
+  const leaseWatchTimer = setInterval(() => {
+    try {
+      store.expireStaleLeases();
+    } catch (err) {
+      console.error("[LinkeGringo Bridge] Erro ao expirar leases:", err);
+    }
+  }, 1e4);
+  const activeSseWatchers = /* @__PURE__ */ new Map();
   const server = http2.createServer(async (req, res) => {
     setCorsHeaders(res);
     if (req.method === "OPTIONS") {
@@ -2013,32 +3738,43 @@ function createBridgeHttpServer(options = {}) {
     const pathname = parsedUrl.pathname;
     try {
       if (req.method === "GET" && (pathname === "/health" || pathname === "/api/health")) {
+        const activeJobs = store.listJobs();
+        const activeAgents = store.listActiveAgents();
         sendJson(res, 200, {
           status: "ok",
           server: "linkegringo-mcp-bridge",
-          watcherConnected: bridgeJobStore.hasActiveWatcher(),
+          watcherConnected: bridgeJobStore.hasActiveWatcher() || activeAgents.length > 0,
           watcherCount: bridgeJobStore.getWatcherCount(),
-          pendingCount: bridgeJobStore.getPendingCount(),
-          totalJobs: bridgeJobStore.getAllJobs().length
+          pendingCount: bridgeJobStore.getPendingCount() + store.listJobs({ status: "waiting_for_agent" }).length,
+          totalJobs: bridgeJobStore.getAllJobs().length + activeJobs.length,
+          activeJobsCount: activeJobs.length,
+          activeAgentsCount: activeAgents.length,
+          subscribersCount: sseBroker.getSubscriberCount()
         });
         return;
       }
       if (req.method === "GET" && pathname === "/api/bridge/status") {
-        const pendingJob = bridgeJobStore.getPendingJob();
+        const pendingLegacy = bridgeJobStore.getPendingJob();
+        const waitingJobs = store.listJobs({ status: "waiting_for_agent" });
+        const runningJobs = store.listJobs({ status: "running" });
+        const activeAgents = store.listActiveAgents();
         sendJson(res, 200, {
           ok: true,
           status: "ready",
           server: "linkegringo-mcp-bridge",
-          watcherConnected: bridgeJobStore.hasActiveWatcher(),
+          watcherConnected: bridgeJobStore.hasActiveWatcher() || activeAgents.length > 0,
           watcherCount: bridgeJobStore.getWatcherCount(),
-          pendingCount: bridgeJobStore.getPendingCount(),
-          activeJobId: pendingJob ? pendingJob.id : null,
-          totalJobs: bridgeJobStore.getAllJobs().length
+          pendingCount: bridgeJobStore.getPendingCount() + waitingJobs.length,
+          activeJobId: pendingLegacy ? pendingLegacy.id : runningJobs[0]?.id || waitingJobs[0]?.id || null,
+          totalJobs: bridgeJobStore.getAllJobs().length + store.listJobs().length,
+          activeAgents,
+          waitingCount: waitingJobs.length,
+          runningCount: runningJobs.length
         });
         return;
       }
       if (req.method === "POST" && pathname === "/api/bridge/disconnect") {
-        for (const [id, client] of activeSseClients.entries()) {
+        for (const [id, client] of activeSseWatchers.entries()) {
           try {
             client.res.write(
               `data: ${JSON.stringify({ type: "disconnect", message: "Desconectado pelo usu\xE1rio na interface web." })}
@@ -2050,16 +3786,31 @@ function createBridgeHttpServer(options = {}) {
           }
           client.cleanup();
         }
-        activeSseClients.clear();
+        activeSseWatchers.clear();
+        sseBroker.closeAll();
+        const runningJobs = store.listJobs({ status: "running" });
+        const waitingJobs = store.listJobs({ status: "waiting_for_agent" });
+        for (const j of [...runningJobs, ...waitingJobs]) {
+          try {
+            store.cancelJob(j.id, "user", "Cancelado via interface");
+          } catch {
+          }
+        }
         const { canceledCount, clearedCount } = bridgeJobStore.resetQueue();
         sendJson(res, 200, {
           ok: true,
           message: "Conex\xE3o cancelada e fila de jobs limpa com sucesso.",
-          canceledCount,
+          canceledCount: canceledCount + runningJobs.length + waitingJobs.length,
           clearedCount
         });
         return;
       }
+      const jobEventsMatch = pathname.match(/^\/api\/jobs\/([a-zA-Z0-9_-]+)\/events$/);
+      if (req.method === "GET" && jobEventsMatch) {
+        const jobId = jobEventsMatch[1];
+        sseBroker.handleJobEvents(req, res, jobId, store);
+        return;
+      }
       if (req.method === "GET" && pathname === "/api/jobs/stream") {
         res.writeHead(200, {
           "Content-Type": "text/event-stream",
@@ -2091,20 +3842,25 @@ function createBridgeHttpServer(options = {}) {
         bridgeJobStore.on("job:created", onJobCreated);
         bridgeJobStore.on("job:completed", onJobCompleted);
         bridgeJobStore.on("job:failed", onJobFailed);
-        const heartbeat = setInterval(() => {
-          res.write(`: heartbeat
+        const onGlobalEvent = ({ jobId, event }) => {
+          res.write(`data: ${JSON.stringify({ type: event.type, jobId, event })}
 
 `);
+        };
+        sseBroker.on("global", onGlobalEvent);
+        const hb = setInterval(() => {
+          res.write(": heartbeat\n\n");
         }, 15e3);
         const cleanup = () => {
-          clearInterval(heartbeat);
+          clearInterval(hb);
           bridgeJobStore.unregisterWatcher(watcherId);
           bridgeJobStore.off("job:created", onJobCreated);
           bridgeJobStore.off("job:completed", onJobCompleted);
           bridgeJobStore.off("job:failed", onJobFailed);
-          activeSseClients.delete(watcherId);
+          sseBroker.off("global", onGlobalEvent);
+          activeSseWatchers.delete(watcherId);
         };
-        activeSseClients.set(watcherId, { res, cleanup });
+        activeSseWatchers.set(watcherId, { res, cleanup });
         req.on("close", cleanup);
         return;
       }
@@ -2114,64 +3870,243 @@ function createBridgeHttpServer(options = {}) {
           sendJson(res, 400, { ok: false, error: 'Campo "type" \xE9 obrigat\xF3rio.' });
           return;
         }
-        const job = bridgeJobStore.createJob(body.type, body.payload || {});
-        options.onJobCreated?.(job);
+        if (body.payload !== void 0 || body.type.includes("_")) {
+          const legacyJob = bridgeJobStore.createJob(body.type, body.payload || {});
+          options.onJobCreated?.(legacyJob);
+          sendJson(res, 201, { ok: true, job: legacyJob });
+          return;
+        }
+        const job = store.createJob({
+          id: body.id,
+          type: body.type,
+          targetRole: body.targetRole,
+          fileHandleId: body.fileHandleId,
+          metadata: body.metadata,
+          commandId: body.commandId
+        });
         sendJson(res, 201, { ok: true, job });
         return;
       }
+      if (req.method === "POST" && pathname === "/api/files/resolve") {
+        const body = await parseBody(req);
+        if (!body.fingerprint?.name || typeof body.fingerprint?.size !== "number") {
+          sendJson(res, 400, {
+            ok: false,
+            error: 'Fingerprint inv\xE1lido. "name" e "size" num\xE9rico s\xE3o obrigat\xF3rios.'
+          });
+          return;
+        }
+        try {
+          const handle = resolveLocalDocument(store, body.jobId || "temp_job", body.fingerprint);
+          sendJson(res, 200, { ok: true, handle });
+        } catch (err) {
+          sendJson(res, 404, { ok: false, error: err.message });
+        }
+        return;
+      }
+      const docMatch = pathname.match(/^\/api\/documents\/([a-zA-Z0-9_-]+)$/);
+      if (req.method === "GET" && docMatch) {
+        const docId = docMatch[1];
+        const record = store.getFileHandle(docId);
+        if (!record) {
+          sendJson(res, 404, { ok: false, error: `Documento n\xE3o encontrado: ${docId}` });
+          return;
+        }
+        sendJson(res, 200, {
+          ok: true,
+          document: {
+            fileId: record.fileId,
+            jobId: record.jobId,
+            name: record.name,
+            mediaType: record.mediaType,
+            size: record.size,
+            mtime: record.mtime,
+            root: record.root,
+            access: "native-local-document",
+            expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString()
+          }
+        });
+        return;
+      }
       if (req.method === "GET" && pathname === "/api/jobs") {
-        sendJson(res, 200, { ok: true, jobs: bridgeJobStore.getAllJobs() });
+        const status = parsedUrl.searchParams.get("status");
+        const type = parsedUrl.searchParams.get("type");
+        const jobs = store.listJobs({ status, type });
+        sendJson(res, 200, { ok: true, jobs });
         return;
       }
       if (req.method === "GET" && pathname === "/api/jobs/pending") {
         const id = parsedUrl.searchParams.get("id") || void 0;
-        const job = bridgeJobStore.getPendingJob(id);
-        sendJson(res, 200, { ok: true, job: job || null });
-        return;
-      }
-      const jobMatch = pathname.match(/^\/api\/jobs\/([a-zA-Z0-9_-]+)$/);
-      if (req.method === "GET" && jobMatch) {
-        const jobId = jobMatch[1];
-        const wait = parsedUrl.searchParams.get("wait") === "true";
-        const timeout = parseInt(parsedUrl.searchParams.get("timeout") || "30000", 10);
-        let job = bridgeJobStore.getJob(jobId);
-        if (!job) {
-          sendJson(res, 404, { ok: false, error: `Job n\xE3o encontrado: ${jobId}` });
+        if (id) {
+          const specificLegacy = bridgeJobStore.getJob(id);
+          if (specificLegacy) {
+            sendJson(res, 200, { ok: true, job: specificLegacy });
+            return;
+          }
+          const specific = store.getJob(id);
+          sendJson(res, 200, { ok: true, job: specific });
           return;
         }
-        if (wait && (job.status === "pending" || job.status === "processing")) {
-          try {
-            job = await bridgeJobStore.waitForJob(jobId, timeout);
-          } catch {
-            job = bridgeJobStore.getJob(jobId) || job;
-          }
+        const legacyPending = bridgeJobStore.getPendingJob();
+        if (legacyPending) {
+          sendJson(res, 200, { ok: true, job: legacyPending });
+          return;
         }
-        sendJson(res, 200, { ok: true, job });
+        const waiting = store.listJobs({ status: "waiting_for_agent" });
+        sendJson(res, 200, { ok: true, job: waiting[0] || null });
         return;
       }
-      const completeMatch = pathname.match(/^\/api\/jobs\/([a-zA-Z0-9_-]+)\/complete$/);
-      if (req.method === "POST" && completeMatch) {
-        const jobId = completeMatch[1];
-        const body = await parseBody(req);
-        try {
-          const job = bridgeJobStore.completeJob(jobId, body.result);
-          sendJson(res, 200, { ok: true, job });
-        } catch (err) {
-          sendJson(res, 404, { ok: false, error: err.message });
-        }
+      if (req.method === "GET" && pathname === "/api/agents") {
+        const agents = store.listActiveAgents();
+        sendJson(res, 200, { ok: true, agents });
         return;
       }
-      const failMatch = pathname.match(/^\/api\/jobs\/([a-zA-Z0-9_-]+)\/fail$/);
-      if (req.method === "POST" && failMatch) {
-        const jobId = failMatch[1];
-        const body = await parseBody(req);
-        try {
-          const job = bridgeJobStore.failJob(jobId, body.error || "Erro desconhecido");
-          sendJson(res, 200, { ok: true, job });
-        } catch (err) {
-          sendJson(res, 404, { ok: false, error: err.message });
+      const jobRouteMatch = pathname.match(/^\/api\/jobs\/([a-zA-Z0-9_-]+)(?:\/([a-zA-Z0-9_-]+))?$/);
+      if (jobRouteMatch) {
+        const jobId = jobRouteMatch[1];
+        const subAction = jobRouteMatch[2];
+        if (req.method === "GET" && !subAction) {
+          const wait = parsedUrl.searchParams.get("wait") === "true";
+          const timeout = parseInt(parsedUrl.searchParams.get("timeout") || "30000", 10);
+          const legacyJob = bridgeJobStore.getJob(jobId);
+          if (legacyJob) {
+            if (wait && (legacyJob.status === "pending" || legacyJob.status === "processing")) {
+              try {
+                const waited = await bridgeJobStore.waitForJob(jobId, timeout);
+                sendJson(res, 200, { ok: true, job: waited });
+                return;
+              } catch {
+                sendJson(res, 200, { ok: true, job: bridgeJobStore.getJob(jobId) || legacyJob });
+                return;
+              }
+            }
+            sendJson(res, 200, { ok: true, job: legacyJob });
+            return;
+          }
+          let job = store.getJob(jobId);
+          if (!job) {
+            sendJson(res, 404, { ok: false, error: `Job n\xE3o encontrado: ${jobId}` });
+            return;
+          }
+          if (wait && (job.status === "waiting_for_agent" || job.status === "running")) {
+            const startWait = Date.now();
+            await new Promise((resolve) => {
+              const checkInterval = setInterval(() => {
+                const current = store.getJob(jobId);
+                if (!current || current.status === "completed" || current.status === "failed" || current.status === "cancelled") {
+                  clearInterval(checkInterval);
+                  resolve();
+                } else if (Date.now() - startWait >= timeout) {
+                  clearInterval(checkInterval);
+                  resolve();
+                }
+              }, 50);
+            });
+            job = store.getJob(jobId) || job;
+          }
+          const resultRecord = job.resultId ? store.getJobResult(job.resultId) : null;
+          const fullJob = {
+            ...job,
+            result: resultRecord?.payload ?? resultRecord
+          };
+          sendJson(res, 200, { ok: true, job: fullJob, result: resultRecord });
+          return;
+        }
+        if (req.method === "POST" && subAction === "claim") {
+          const body = await parseBody(req);
+          if (!body.agent?.agentId || !body.agent?.sessionId) {
+            sendJson(res, 400, { ok: false, error: "Identidade do agente (agentId e sessionId) \xE9 obrigat\xF3ria." });
+            return;
+          }
+          const updated = store.claimJob(jobId, body.agent, {
+            leaseDurationMs: body.leaseDurationMs,
+            commandId: body.commandId
+          });
+          sendJson(res, 200, { ok: true, job: updated });
+          return;
+        }
+        if (req.method === "POST" && subAction === "progress") {
+          const body = await parseBody(req);
+          if (!body.agent) {
+            sendJson(res, 400, { ok: false, error: "Identidade do agente \xE9 obrigat\xF3ria." });
+            return;
+          }
+          const updated = store.reportProgress(jobId, body.agent, {
+            phase: body.phase,
+            progress: body.progress,
+            message: body.message,
+            leaseDurationMs: body.leaseDurationMs,
+            commandId: body.commandId
+          });
+          sendJson(res, 200, { ok: true, job: updated });
+          return;
+        }
+        if (req.method === "POST" && subAction === "user-action") {
+          const body = await parseBody(req);
+          const updated = store.requestUserAction(jobId, body.agent, {
+            reason: body.reason,
+            prompt: body.prompt,
+            commandId: body.commandId
+          });
+          sendJson(res, 200, { ok: true, job: updated });
+          return;
+        }
+        if (req.method === "POST" && subAction === "resume") {
+          const body = await parseBody(req);
+          const updated = store.resumeJob(jobId, {
+            actor: "user",
+            reason: body.reason || "user_confirmed",
+            payload: body.payload,
+            commandId: body.commandId
+          });
+          sendJson(res, 200, { ok: true, job: updated });
+          return;
+        }
+        if (req.method === "POST" && subAction === "complete") {
+          const body = await parseBody(req);
+          const payload = body.result?.payload !== void 0 ? body.result.payload : body.result;
+          const legacyJob = bridgeJobStore.getJob(jobId);
+          if (legacyJob) {
+            const completed2 = bridgeJobStore.completeJob(jobId, payload);
+            sendJson(res, 200, { ok: true, job: completed2 });
+            return;
+          }
+          const agent = body.agent || {
+            agentId: "mcp-agent",
+            sessionId: "session_mcp"
+          };
+          const submissionId = body.submissionId || `sub_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+          const completed = store.completeJob(jobId, agent, {
+            submissionId,
+            schemaVersion: body.schemaVersion || "1.0",
+            payload,
+            commandId: body.commandId
+          });
+          sendJson(res, 200, { ok: true, job: completed.job, resultId: completed.resultId });
+          return;
+        }
+        if (req.method === "GET" && subAction === "result") {
+          const job = store.getJob(jobId);
+          if (!job || !job.resultId) {
+            sendJson(res, 404, { ok: false, error: "Resultado do job n\xE3o encontrado ou ainda n\xE3o dispon\xEDvel." });
+            return;
+          }
+          const resultEnvelope = store.getJobResult(job.resultId);
+          sendJson(res, 200, { ok: true, result: resultEnvelope });
+          return;
+        }
+        if (req.method === "POST" && subAction === "fail") {
+          const body = await parseBody(req);
+          const legacyJob = bridgeJobStore.getJob(jobId);
+          if (legacyJob) {
+            const failed2 = bridgeJobStore.failJob(jobId, body.error || "Erro desconhecido");
+            sendJson(res, 200, { ok: true, job: failed2 });
+            return;
+          }
+          const failed = store.failJob(jobId, body.error || "Erro desconhecido", body.actor, body.commandId);
+          sendJson(res, 200, { ok: true, job: failed });
+          return;
         }
-        return;
       }
       if (req.method === "POST" && pathname === "/api/jobs/clear") {
         bridgeJobStore.clear();
@@ -2183,6 +4118,9 @@ function createBridgeHttpServer(options = {}) {
       sendJson(res, 500, { ok: false, error: err?.message || "Erro interno no servidor bridge" });
     }
   });
+  server.on("close", () => {
+    clearInterval(leaseWatchTimer);
+  });
   return server;
 }
 var activeBridgeServer = null;
@@ -2365,8 +4303,236 @@ function startBridgeWatcher(options = {}) {
   };
 }
 
+// src/client/bridge-client.ts
+var BridgeClient = class {
+  bridgeUrl;
+  defaultTimeoutMs;
+  constructor(config = {}) {
+    this.bridgeUrl = (config.bridgeUrl || typeof process !== "undefined" && process.env?.LINKEGRINGO_BRIDGE_URL || "http://127.0.0.1:5174").replace(/\/$/, "");
+    this.defaultTimeoutMs = config.defaultTimeoutMs || 3e5;
+  }
+  /**
+   * Checa se o bridge HTTP local está online e responsivo.
+   */
+  async checkHealth() {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 2e3);
+      const res = await fetch(`${this.bridgeUrl}/health`, { signal: controller.signal });
+      clearTimeout(timer);
+      if (!res.ok) return false;
+      const data = await res.json();
+      return data.status === "ok";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Resolve um arquivo local por fingerprint determinístico sem copiá-lo.
+   */
+  async resolveFile(fingerprint, jobId) {
+    const res = await fetch(`${this.bridgeUrl}/api/files/resolve`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ fingerprint, jobId })
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Falha ao resolver arquivo local (${res.status})`);
+    }
+    const data = await res.json();
+    return data.handle;
+  }
+  /**
+   * Obtém detalhes públicos do DocumentHandle a partir do capability token opaco.
+   */
+  async getDocument(fileId) {
+    const res = await fetch(`${this.bridgeUrl}/api/documents/${encodeURIComponent(fileId)}`);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Documento n\xE3o encontrado: ${fileId}`);
+    }
+    const data = await res.json();
+    return data.document;
+  }
+  /**
+   * Cria um novo job na máquina de estados do Bridge.
+   */
+  async createJob(params) {
+    const res = await fetch(`${this.bridgeUrl}/api/jobs`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Falha ao criar job no Bridge (${res.status})`);
+    }
+    const data = await res.json();
+    return data.job;
+  }
+  /**
+   * Consulta o estado atual de um job.
+   */
+  async getJob(jobId) {
+    const res = await fetch(`${this.bridgeUrl}/api/jobs/${encodeURIComponent(jobId)}`);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Job n\xE3o encontrado: ${jobId}`);
+    }
+    const data = await res.json();
+    if (data.result && !data.job.result) {
+      data.job.result = data.result.payload ?? data.result;
+    }
+    return data.job;
+  }
+  /**
+   * Retoma um job em espera de confirmação do usuário (Human-in-the-Loop).
+   */
+  async resumeJob(jobId, paramsOrReason = "user_resumed", maybePayload) {
+    const params = typeof paramsOrReason === "string" ? { actor: "user", reason: paramsOrReason, payload: maybePayload } : { actor: paramsOrReason.actor || "user", reason: paramsOrReason.reason, payload: paramsOrReason.payload ?? maybePayload };
+    const res = await fetch(`${this.bridgeUrl}/api/jobs/${encodeURIComponent(jobId)}/resume`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `Falha ao retomar job ${jobId}`);
+    }
+    const data = await res.json();
+    return data.job;
+  }
+  /**
+   * Subscreve ao stream SSE de eventos do job (`/api/jobs/:id/events`).
+   * Suporta re-conexão automática com Last-Event-ID no browser nativo via EventSource.
+   */
+  subscribeJobEvents(jobId, onEvent, onError) {
+    if (typeof EventSource !== "undefined") {
+      const url = `${this.bridgeUrl}/api/jobs/${encodeURIComponent(jobId)}/events`;
+      const eventSource = new EventSource(url);
+      eventSource.onmessage = (e) => {
+        try {
+          const parsed = JSON.parse(e.data);
+          onEvent(parsed);
+        } catch (err) {
+          console.warn("[BridgeClient] Erro ao deserializar evento SSE:", err);
+        }
+      };
+      eventSource.onerror = (e) => {
+        if (onError) onError(e);
+      };
+      return () => {
+        eventSource.close();
+      };
+    }
+    let active = true;
+    let lastEventSeq = 0;
+    const poll = async () => {
+      while (active) {
+        try {
+          const job = await this.getJob(jobId);
+          if (job.status === "completed" || job.status === "failed" || job.status === "cancelled") {
+            break;
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+    };
+    poll();
+    return () => {
+      active = false;
+    };
+  }
+  /**
+   * Aguarda a resolução completa do job via streaming de eventos SSE,
+   * despachando atualizações reativas de progresso e ações do usuário.
+   */
+  async waitForJobResult(jobId, options = {}) {
+    const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+      let isSettled = false;
+      const cleanup = () => {
+        isSettled = true;
+        unsubscribe();
+        if (timeoutTimer) clearTimeout(timeoutTimer);
+      };
+      const timeoutTimer = setTimeout(() => {
+        if (!isSettled) {
+          cleanup();
+          reject(
+            new Error(
+              `Tempo limite de ${Math.round(timeoutMs / 1e3)}s excedido aguardando resposta do Agente de IA para o job ${jobId}.`
+            )
+          );
+        }
+      }, timeoutMs);
+      const handleEvent = async (event) => {
+        if (isSettled) return;
+        if (options.onEvent) {
+          options.onEvent(event);
+        }
+        if (event.type === "job.progress") {
+          const p = event.payload;
+          if (options.onProgress) {
+            options.onProgress(p.phase || "running", p.progress || 0, p.message);
+          }
+        } else if (event.type === "job.waiting_for_user") {
+          const p = event.payload;
+          if (options.onUserAction) {
+            options.onUserAction(p.reason || "waiting_for_user", p.prompt);
+          }
+        } else if (event.type === "job.completed") {
+          cleanup();
+          try {
+            const p = event.payload;
+            if (p?.result?.payload) {
+              resolve(p.result.payload);
+              return;
+            }
+            const finishedJob = await this.getJob(jobId);
+            if (finishedJob.result) {
+              const res = finishedJob.result?.payload ?? finishedJob.result;
+              resolve(res);
+            } else if (finishedJob.resultId) {
+              const res = await fetch(`${this.bridgeUrl}/api/jobs/${encodeURIComponent(jobId)}`);
+              const data = await res.json();
+              resolve(data.result?.payload ?? data.job?.result ?? data);
+            } else {
+              resolve(finishedJob);
+            }
+          } catch (err) {
+            reject(err);
+          }
+        } else if (event.type === "job.failed") {
+          cleanup();
+          const p = event.payload;
+          reject(new Error(p?.error || "O Agente de IA reportou uma falha ao processar o job."));
+        }
+      };
+      const unsubscribe = this.subscribeJobEvents(jobId, handleEvent, (err) => {
+        console.warn("[BridgeClient] Conex\xE3o SSE inst\xE1vel, aguardando reconex\xE3o...", err);
+      });
+      this.getJob(jobId).then((job) => {
+        if (isSettled) return;
+        if (job.status === "completed") {
+          cleanup();
+          const res = job.result?.payload ?? job.result;
+          resolve(res);
+        } else if (job.status === "failed") {
+          cleanup();
+          reject(new Error(job.error || "O job falhou."));
+        }
+      }).catch(() => {
+      });
+    });
+  }
+};
+
 // src/index.ts
-import fs2 from "fs";
+import fs4 from "fs";
 import { fileURLToPath } from "url";
 async function main() {
   if (process.argv.includes("install") || process.argv.includes("setup") || process.argv.includes("--install")) {
@@ -2393,7 +4559,7 @@ function isDirectExecution() {
   if (!process.argv[1]) return false;
   try {
     const currentFilePath = fileURLToPath(import.meta.url);
-    const scriptPath = fs2.existsSync(process.argv[1]) ? fs2.realpathSync(process.argv[1]) : process.argv[1];
+    const scriptPath = fs4.existsSync(process.argv[1]) ? fs4.realpathSync(process.argv[1]) : process.argv[1];
     return currentFilePath === scriptPath || process.argv[1].endsWith("index.js") || process.argv[1].endsWith("linkegringo-mcp") || process.argv[1].endsWith("mcp") || process.argv[1].endsWith("linkegringo");
   } catch {
     return true;
@@ -2406,8 +4572,12 @@ if (isDirectExecution()) {
   });
 }
 export {
+  BridgeClient,
+  DEFAULT_BRIDGE_URL,
   auditProfileInputSchema,
   bridgeJobStore,
+  claimJobInputSchema,
+  claimRemoteJob,
   completeRemoteOrLocalJob,
   convertToXyzBulletInputSchema,
   createBridgeHttpServer,
@@ -2416,25 +4586,46 @@ export {
   failRemoteOrLocalJob,
   formatGoogleXyzBullet,
   generateHeadlineInputSchema,
+  getBridgeUrl,
   getExperienceBulletCount,
   getMcpConfigsForSystem,
   getPendingJobInputSchema,
   getRemoteOrLocalPendingJob,
   handleAuditProfile,
+  handleClaimJob,
   handleConvertToXyzBullet,
   handleGenerateHeadline,
   handleGetPendingJob,
+  handleInspectDocument,
+  handleListJobs,
+  handleReportProgress,
+  handleRequestUserAction,
   handleSimulateRecruiterSearch,
+  handleSubmitDiagnostic,
+  handleSubmitInterview,
   handleSubmitJobResult,
+  handleSubmitRewrite,
   handleWatchLinkeGringo,
+  inspectDocumentInputSchema,
+  inspectRemoteDocument,
   installMcpServerConfig,
+  listJobsInputSchema,
+  listRemoteJobs,
   parseArgs,
+  reportProgressInputSchema,
+  reportRemoteProgress,
+  requestRemoteUserAction,
+  requestUserActionInputSchema,
   runInstaller,
   simulateRecruiterSearchInputSchema,
   startBridgeServer,
   startBridgeWatcher,
   stopBridgeServer,
+  submitDiagnosticInputSchema,
+  submitInterviewInputSchema,
   submitJobResultInputSchema,
+  submitRemoteJobResult,
+  submitRewriteInputSchema,
   waitForNextJob,
   watchLinkeGringoInputSchema
 };