hobots 2.2.0 → 2.4.0

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { Breadcrumb, EventUser, EventType, EventPayload, TransactionPayload, HeartbeatPayload, StepStatus, RunLogLevel, StepData, RunItemStatus, RunProgress, RunAttachmentContentType } from './protocol.cjs';
-export { BreadcrumbLevel, Envelope, EnvelopeItem, ExceptionData, InstanceInfo, PollRequest, PollResponse, RunAttachmentConfirmRequest, RunAttachmentConfirmResponse, RunAttachmentCreateRequest, RunAttachmentCreateResponse, RunDescriptor, RunError, RunItemInput, RunItemsCreateRequest, RunItemsCreateResponse, RunLogEntry, RunStatus, RunUpdateRequest, RunUpdateResponse, RunUpdateStatus, StackFrame } from './protocol.cjs';
+import { Breadcrumb, EventUser, EventType, MachineSnapshot, EventPayload, TransactionPayload, HeartbeatPayload, StepStatus, RunLogLevel, StepData, RunItemStatus, RunProgress, RunAttachmentContentType, EnvironmentInput } from './protocol.cjs';
+export { BreadcrumbLevel, Envelope, EnvelopeItem, ExceptionData, InstanceInfo, MachineProcess, PollRequest, PollResponse, RunAttachmentConfirmRequest, RunAttachmentConfirmResponse, RunAttachmentCreateRequest, RunAttachmentCreateResponse, RunDescriptor, RunError, RunItemInput, RunItemsCreateRequest, RunItemsCreateResponse, RunLogEntry, RunStatus, RunUpdateRequest, RunUpdateResponse, RunUpdateStatus, StackFrame } from './protocol.cjs';
 
 /** Aceita tudo que o handler pode ter em mãos: bytes ou um caminho de arquivo (só Node). */
 type AttachInput = Uint8Array | ArrayBuffer | string;
@@ -47,15 +47,46 @@ interface Logger {
     error: (...args: unknown[]) => void;
 }
 
+/**
+ * Coleta CPU/memória/disco da máquina e do processo — só em Node (no browser é no-op).
+ *
+ * Os módulos `node:*` entram por import dinâmico (o bundle é `platform: neutral`), e
+ * `sample()` é síncrono e barato: `os.cpus()` + `statfsSync` + `process.memoryUsage()`.
+ * Nunca lança — telemetria de recurso não pode derrubar o bot nem o capture de um erro.
+ */
+declare class MachineSampler {
+    private readonly instanceId;
+    private readonly logger;
+    private os;
+    private fs;
+    private ready;
+    private prevCpu;
+    private prevProcessCpu;
+    private prevAt;
+    private lastCpuPercent;
+    private lastProcessCpuPercent;
+    constructor(instanceId: string, logger: Logger);
+    /** Carrega os módulos e tira a leitura-base de CPU (a primeira amostra ainda sai com cpu_percent null). */
+    start(): Promise<void>;
+    sample(): MachineSnapshot | undefined;
+    private cpuTotals;
+    /** Média desde a leitura anterior; leituras com menos de 1s de janela reutilizam a última média. */
+    private updateCpu;
+    private diskUsage;
+}
+
 declare class Client {
     #private;
     readonly logger: Logger;
     /** Eco de lifecycle (Transaction.emit) e afins só imprimem no terminal com debug ligado. */
     readonly debug: boolean;
     private readonly transport;
+    private machine;
     constructor(options: InitOptions, config?: ResolvedConfig);
     get options(): InitOptions;
     get config(): ResolvedConfig;
+    /** Sampler de recursos da máquina — cada evento passa a levar `contexts.machine`. */
+    attachMachineSampler(sampler: MachineSampler | undefined): void;
     /** Serialização explícita nunca inclui o secret. */
     toJSON(): Record<string, unknown>;
     captureException(error: unknown, hint: CaptureHint | undefined, scope: Scope): string;
@@ -64,6 +95,12 @@ declare class Client {
     private prepareEvent;
     sendTransaction(payload: TransactionPayload): void;
     sendHeartbeat(payload: HeartbeatPayload): void;
+    /**
+     * Ambiente do item: o dele, senão o do init(), senão produção. Centralizado
+     * porque evento, transaction e heartbeat precisam responder igual — o servidor
+     * normaliza apelidos legados, então aqui basta repassar.
+     */
+    private resolveEnvironment;
     flush(timeoutMs?: number): Promise<boolean>;
     close(timeoutMs?: number): Promise<boolean>;
 }
@@ -131,7 +168,7 @@ declare class Transaction {
 
 /** Opções de tasks dentro de `init({ tasks: ... })`. Credencial (clientSecret), identidade (instanceId) e debug vêm do init. */
 interface TasksOptions {
-    /** Intervalo entre polls sem trabalho. Default: 5_000 (mínimo 1_000) */
+    /** Intervalo entre polls sem trabalho. Default: 2_000 (mínimo 1_000) */
     pollIntervalMs?: number;
     /** Runs simultâneas (1..5). Default: 1 (sequencial) */
     concurrency?: number;
@@ -254,8 +291,16 @@ interface HeartbeatOptions {
 interface InitOptions {
     /** O Client Secret do agente (hb_…) — a mesma credencial para telemetria e tasks. Copie em Configurações → Agentes. */
     clientSecret: string;
-    /** Default: 'production' */
-    environment?: string;
+    /**
+       * Ambiente lógico onde este robô roda: 'development', 'testing', 'staging'
+       * (homologação) ou 'production'. Vai em todo evento e transaction E na
+       * identidade da instância — é por ele que as regras de alerta decidem se
+       * notificam. Default: 'production'.
+       *
+       * Um valor livre herdado continua valendo — o servidor normaliza apelidos
+       * como 'prod' e 'qa'.
+       */
+    environment?: EnvironmentInput;
     /** Versão do programa, ex.: 'robo-nfe@1.4.2' */
     release?: string;
     /** Identificador único e estável desta instância — a identidade do agente no painel (heartbeat e poll de tasks convergem nele) */
@@ -270,6 +315,12 @@ interface InitOptions {
     maxBreadcrumbs?: number;
     /** Registra handlers globais de erro (uncaughtException etc.). Default: true */
     captureUnhandled?: boolean;
+    /**
+     * Coleta CPU, memória, disco e recursos do processo: vai em cada heartbeat/poll (série da
+     * instância no app) e como `contexts.machine` em cada evento (como estava a máquina na hora
+     * do erro). Só em Node; sem custo de timer — pega carona no heartbeat. Default: true
+     */
+    machineMetrics?: boolean;
     /** Habilita heartbeat periódico (true usa defaults) */
     heartbeat?: boolean | HeartbeatOptions;
     /**
@@ -356,4 +407,4 @@ declare function close(timeoutMs?: number): Promise<boolean>;
 
 declare function scrubSecrets(text: string): string;
 
-export { type AttachInput, Breadcrumb, type BreadcrumbInput, type CaptureAttachment, type CaptureHint, Client, DEFAULT_BASE_URL, EventPayload, EventType, EventUser, type HeartbeatOptions, HeartbeatPayload, type InitOptions, RunAttachmentContentType, type RunContext, type RunItemOptions, RunItemStatus, type RunItems, RunLogLevel, RunProgress, type RunProgressReporter, Scope, Step, StepData, type TaskHandler, type TasksOptions, Transaction, TransactionPayload, addBreadcrumb, captureException, captureMessage, close, flush, getClient, init, register, scrubSecrets, setContext, setExtra, setTag, setTags, setUser, start, startTransaction, stop, withScope };
+export { type AttachInput, Breadcrumb, type BreadcrumbInput, type CaptureAttachment, type CaptureHint, Client, DEFAULT_BASE_URL, EventPayload, EventType, EventUser, type HeartbeatOptions, HeartbeatPayload, type InitOptions, MachineSnapshot, RunAttachmentContentType, type RunContext, type RunItemOptions, RunItemStatus, type RunItems, RunLogLevel, RunProgress, type RunProgressReporter, Scope, Step, StepData, type TaskHandler, type TasksOptions, Transaction, TransactionPayload, addBreadcrumb, captureException, captureMessage, close, flush, getClient, init, register, scrubSecrets, setContext, setExtra, setTag, setTags, setUser, start, startTransaction, stop, withScope };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Breadcrumb, EventUser, EventType, EventPayload, TransactionPayload, HeartbeatPayload, StepStatus, RunLogLevel, StepData, RunItemStatus, RunProgress, RunAttachmentContentType } from './protocol.js';
-export { BreadcrumbLevel, Envelope, EnvelopeItem, ExceptionData, InstanceInfo, PollRequest, PollResponse, RunAttachmentConfirmRequest, RunAttachmentConfirmResponse, RunAttachmentCreateRequest, RunAttachmentCreateResponse, RunDescriptor, RunError, RunItemInput, RunItemsCreateRequest, RunItemsCreateResponse, RunLogEntry, RunStatus, RunUpdateRequest, RunUpdateResponse, RunUpdateStatus, StackFrame } from './protocol.js';
+import { Breadcrumb, EventUser, EventType, MachineSnapshot, EventPayload, TransactionPayload, HeartbeatPayload, StepStatus, RunLogLevel, StepData, RunItemStatus, RunProgress, RunAttachmentContentType, EnvironmentInput } from './protocol.js';
+export { BreadcrumbLevel, Envelope, EnvelopeItem, ExceptionData, InstanceInfo, MachineProcess, PollRequest, PollResponse, RunAttachmentConfirmRequest, RunAttachmentConfirmResponse, RunAttachmentCreateRequest, RunAttachmentCreateResponse, RunDescriptor, RunError, RunItemInput, RunItemsCreateRequest, RunItemsCreateResponse, RunLogEntry, RunStatus, RunUpdateRequest, RunUpdateResponse, RunUpdateStatus, StackFrame } from './protocol.js';
 
 /** Aceita tudo que o handler pode ter em mãos: bytes ou um caminho de arquivo (só Node). */
 type AttachInput = Uint8Array | ArrayBuffer | string;
@@ -47,15 +47,46 @@ interface Logger {
     error: (...args: unknown[]) => void;
 }
 
+/**
+ * Coleta CPU/memória/disco da máquina e do processo — só em Node (no browser é no-op).
+ *
+ * Os módulos `node:*` entram por import dinâmico (o bundle é `platform: neutral`), e
+ * `sample()` é síncrono e barato: `os.cpus()` + `statfsSync` + `process.memoryUsage()`.
+ * Nunca lança — telemetria de recurso não pode derrubar o bot nem o capture de um erro.
+ */
+declare class MachineSampler {
+    private readonly instanceId;
+    private readonly logger;
+    private os;
+    private fs;
+    private ready;
+    private prevCpu;
+    private prevProcessCpu;
+    private prevAt;
+    private lastCpuPercent;
+    private lastProcessCpuPercent;
+    constructor(instanceId: string, logger: Logger);
+    /** Carrega os módulos e tira a leitura-base de CPU (a primeira amostra ainda sai com cpu_percent null). */
+    start(): Promise<void>;
+    sample(): MachineSnapshot | undefined;
+    private cpuTotals;
+    /** Média desde a leitura anterior; leituras com menos de 1s de janela reutilizam a última média. */
+    private updateCpu;
+    private diskUsage;
+}
+
 declare class Client {
     #private;
     readonly logger: Logger;
     /** Eco de lifecycle (Transaction.emit) e afins só imprimem no terminal com debug ligado. */
     readonly debug: boolean;
     private readonly transport;
+    private machine;
     constructor(options: InitOptions, config?: ResolvedConfig);
     get options(): InitOptions;
     get config(): ResolvedConfig;
+    /** Sampler de recursos da máquina — cada evento passa a levar `contexts.machine`. */
+    attachMachineSampler(sampler: MachineSampler | undefined): void;
     /** Serialização explícita nunca inclui o secret. */
     toJSON(): Record<string, unknown>;
     captureException(error: unknown, hint: CaptureHint | undefined, scope: Scope): string;
@@ -64,6 +95,12 @@ declare class Client {
     private prepareEvent;
     sendTransaction(payload: TransactionPayload): void;
     sendHeartbeat(payload: HeartbeatPayload): void;
+    /**
+     * Ambiente do item: o dele, senão o do init(), senão produção. Centralizado
+     * porque evento, transaction e heartbeat precisam responder igual — o servidor
+     * normaliza apelidos legados, então aqui basta repassar.
+     */
+    private resolveEnvironment;
     flush(timeoutMs?: number): Promise<boolean>;
     close(timeoutMs?: number): Promise<boolean>;
 }
@@ -131,7 +168,7 @@ declare class Transaction {
 
 /** Opções de tasks dentro de `init({ tasks: ... })`. Credencial (clientSecret), identidade (instanceId) e debug vêm do init. */
 interface TasksOptions {
-    /** Intervalo entre polls sem trabalho. Default: 5_000 (mínimo 1_000) */
+    /** Intervalo entre polls sem trabalho. Default: 2_000 (mínimo 1_000) */
     pollIntervalMs?: number;
     /** Runs simultâneas (1..5). Default: 1 (sequencial) */
     concurrency?: number;
@@ -254,8 +291,16 @@ interface HeartbeatOptions {
 interface InitOptions {
     /** O Client Secret do agente (hb_…) — a mesma credencial para telemetria e tasks. Copie em Configurações → Agentes. */
     clientSecret: string;
-    /** Default: 'production' */
-    environment?: string;
+    /**
+       * Ambiente lógico onde este robô roda: 'development', 'testing', 'staging'
+       * (homologação) ou 'production'. Vai em todo evento e transaction E na
+       * identidade da instância — é por ele que as regras de alerta decidem se
+       * notificam. Default: 'production'.
+       *
+       * Um valor livre herdado continua valendo — o servidor normaliza apelidos
+       * como 'prod' e 'qa'.
+       */
+    environment?: EnvironmentInput;
     /** Versão do programa, ex.: 'robo-nfe@1.4.2' */
     release?: string;
     /** Identificador único e estável desta instância — a identidade do agente no painel (heartbeat e poll de tasks convergem nele) */
@@ -270,6 +315,12 @@ interface InitOptions {
     maxBreadcrumbs?: number;
     /** Registra handlers globais de erro (uncaughtException etc.). Default: true */
     captureUnhandled?: boolean;
+    /**
+     * Coleta CPU, memória, disco e recursos do processo: vai em cada heartbeat/poll (série da
+     * instância no app) e como `contexts.machine` em cada evento (como estava a máquina na hora
+     * do erro). Só em Node; sem custo de timer — pega carona no heartbeat. Default: true
+     */
+    machineMetrics?: boolean;
     /** Habilita heartbeat periódico (true usa defaults) */
     heartbeat?: boolean | HeartbeatOptions;
     /**
@@ -356,4 +407,4 @@ declare function close(timeoutMs?: number): Promise<boolean>;
 
 declare function scrubSecrets(text: string): string;
 
-export { type AttachInput, Breadcrumb, type BreadcrumbInput, type CaptureAttachment, type CaptureHint, Client, DEFAULT_BASE_URL, EventPayload, EventType, EventUser, type HeartbeatOptions, HeartbeatPayload, type InitOptions, RunAttachmentContentType, type RunContext, type RunItemOptions, RunItemStatus, type RunItems, RunLogLevel, RunProgress, type RunProgressReporter, Scope, Step, StepData, type TaskHandler, type TasksOptions, Transaction, TransactionPayload, addBreadcrumb, captureException, captureMessage, close, flush, getClient, init, register, scrubSecrets, setContext, setExtra, setTag, setTags, setUser, start, startTransaction, stop, withScope };
+export { type AttachInput, Breadcrumb, type BreadcrumbInput, type CaptureAttachment, type CaptureHint, Client, DEFAULT_BASE_URL, EventPayload, EventType, EventUser, type HeartbeatOptions, HeartbeatPayload, type InitOptions, MachineSnapshot, RunAttachmentContentType, type RunContext, type RunItemOptions, RunItemStatus, type RunItems, RunLogLevel, RunProgress, type RunProgressReporter, Scope, Step, StepData, type TaskHandler, type TasksOptions, Transaction, TransactionPayload, addBreadcrumb, captureException, captureMessage, close, flush, getClient, init, register, scrubSecrets, setContext, setExtra, setTag, setTags, setUser, start, startTransaction, stop, withScope };

package/dist/index.js

@@ -103,7 +103,7 @@ function scrubSecrets(text) {
 
 // src/utils.ts
 var SDK_NAME = "hobots";
-var SDK_VERSION = true ? "2.2.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "2.4.0" : "0.0.0-dev";
 function isNode() {
   return typeof process !== "undefined" && typeof process.versions?.node === "string";
 }
@@ -396,6 +396,7 @@ var Client = class {
   #options;
   #config;
   transport;
+  machine;
   constructor(options, config = resolveConfig(options)) {
     this.#options = options;
     this.debug = !!options.debug;
@@ -415,6 +416,10 @@ var Client = class {
   get config() {
     return this.#config;
   }
+  /** Sampler de recursos da máquina — cada evento passa a levar `contexts.machine`. */
+  attachMachineSampler(sampler) {
+    this.machine = sampler;
+  }
   /** Serialização explícita nunca inclui o secret. */
   toJSON() {
     return { sdk: SDK_NAME, version: SDK_VERSION, baseUrl: this.#config.baseUrl };
@@ -446,15 +451,17 @@ var Client = class {
   prepareEvent(event, hint, scope2) {
     const tags = { ...this.options.tags, ...scope2.tags, ...event.tags, ...hint?.tags };
     const extra = { ...scope2.extra, ...event.extra, ...hint?.extra };
+    const sampled = this.machine?.sample();
+    const machine = sampled ? { machine: sampled } : {};
     return {
       ...event,
       type: hint?.type ?? event.type ?? scope2.type ?? "error",
       release: event.release ?? this.options.release,
-      environment: event.environment ?? this.options.environment ?? "production",
+      environment: this.resolveEnvironment(event.environment),
       tags: Object.keys(tags).length > 0 ? tags : void 0,
       extra: Object.keys(extra).length > 0 ? extra : void 0,
       user: event.user ?? scope2.user,
-      contexts: { ...runtimeContexts(), ...scope2.contexts, ...event.contexts },
+      contexts: { ...runtimeContexts(), ...machine, ...scope2.contexts, ...event.contexts },
       breadcrumbs: scope2.breadcrumbs.length > 0 ? [...scope2.breadcrumbs] : event.breadcrumbs,
       fingerprint: hint?.fingerprint ?? event.fingerprint ?? scope2.fingerprint
     };
@@ -465,7 +472,7 @@ var Client = class {
       payload: {
         ...payload,
         release: payload.release ?? this.options.release,
-        environment: payload.environment ?? this.options.environment ?? "production",
+        environment: this.resolveEnvironment(payload.environment),
         tags: { ...this.options.tags, ...payload.tags }
       }
     });
@@ -473,9 +480,22 @@ var Client = class {
   sendHeartbeat(payload) {
     this.transport.enqueue({
       type: "heartbeat",
-      payload: { ...payload, release: payload.release ?? this.options.release }
+      payload: {
+        ...payload,
+        release: payload.release ?? this.options.release,
+        // o ambiente viaja no beat: é assim que a instância se classifica no app
+        environment: this.resolveEnvironment(payload.environment)
+      }
     });
   }
+  /**
+   * Ambiente do item: o dele, senão o do init(), senão produção. Centralizado
+   * porque evento, transaction e heartbeat precisam responder igual — o servidor
+   * normaliza apelidos legados, então aqui basta repassar.
+   */
+  resolveEnvironment(value) {
+    return value ?? this.options.environment ?? "production";
+  }
   flush(timeoutMs) {
     return this.transport.flush(timeoutMs);
   }
@@ -489,8 +509,9 @@ var DEFAULT_INTERVAL_MS = 3e4;
 var MIN_REPORTED_INTERVAL_MS = 1e3;
 var MAX_REPORTED_INTERVAL_MS = 9e5;
 var Heartbeat = class {
-  constructor(client2, options = {}, instanceId) {
+  constructor(client2, options = {}, instanceId, sampler) {
     this.client = client2;
+    this.sampler = sampler;
     this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
     this.instanceId = instanceId;
     this.name = options.name ?? instanceId;
@@ -529,7 +550,9 @@ var Heartbeat = class {
       name: this.name,
       interval_ms: Math.min(Math.max(this.intervalMs, MIN_REPORTED_INTERVAL_MS), MAX_REPORTED_INTERVAL_MS),
       timestamp: nowISO(),
-      metadata: this.metadata
+      metadata: this.metadata,
+      // recursos da máquina a cada beat — a série da instância no app
+      machine: this.sampler?.sample()
     });
   }
 };
@@ -560,50 +583,184 @@ function hasInstalledGlobalHandlers() {
   return installed;
 }
 function installGlobalHandlers(client2, getScope) {
-  if (installed) return;
+  if (installed) return () => void 0;
   installed = true;
   if (isNode()) {
-    process.on(
-      "uncaughtException",
-      markInternal((error) => {
-        client2.captureException(error, { type: "fatal", tags: { mechanism: "uncaughtException" } }, getScope());
-        void client2.flush(2e3).then(async () => {
-          if (externalListenerCount("uncaughtException") === 0) {
-            await awaitEmergencyTasks(EMERGENCY_REPORT_CAP_MS);
-            console.error(error);
-            process.exit(1);
-          }
-        });
-      })
-    );
-    process.on(
-      "unhandledRejection",
-      markInternal((reason) => {
-        client2.captureException(reason, { type: "error", tags: { mechanism: "unhandledRejection" } }, getScope());
-        void client2.flush(2e3);
-      })
-    );
-    process.on(
-      "beforeExit",
-      markInternal(() => {
-        void client2.flush(2e3);
-      })
-    );
-    return;
+    const onUncaught = markInternal((error) => {
+      client2.captureException(error, { type: "fatal", tags: { mechanism: "uncaughtException" } }, getScope());
+      void client2.flush(2e3).then(async () => {
+        if (externalListenerCount("uncaughtException") === 0) {
+          await awaitEmergencyTasks(EMERGENCY_REPORT_CAP_MS);
+          console.error(error);
+          process.exit(1);
+        }
+      });
+    });
+    const onRejection = markInternal((reason) => {
+      client2.captureException(reason, { type: "error", tags: { mechanism: "unhandledRejection" } }, getScope());
+      void client2.flush(2e3);
+    });
+    const onBeforeExit = markInternal(() => {
+      void client2.flush(2e3);
+    });
+    process.on("uncaughtException", onUncaught);
+    process.on("unhandledRejection", onRejection);
+    process.on("beforeExit", onBeforeExit);
+    return () => {
+      process.off("uncaughtException", onUncaught);
+      process.off("unhandledRejection", onRejection);
+      process.off("beforeExit", onBeforeExit);
+      installed = false;
+    };
   }
   if (typeof window !== "undefined") {
-    window.addEventListener("error", (event) => {
+    const onError = (event) => {
       client2.captureException(event.error ?? event.message, { tags: { mechanism: "onerror" } }, getScope());
-    });
-    window.addEventListener("unhandledrejection", (event) => {
+    };
+    const onRejection = (event) => {
       client2.captureException(event.reason, { tags: { mechanism: "onunhandledrejection" } }, getScope());
-    });
-    window.addEventListener("pagehide", () => {
+    };
+    const onPageHide = () => {
       void client2.flush(1e3);
-    });
+    };
+    window.addEventListener("error", onError);
+    window.addEventListener("unhandledrejection", onRejection);
+    window.addEventListener("pagehide", onPageHide);
+    return () => {
+      window.removeEventListener("error", onError);
+      window.removeEventListener("unhandledrejection", onRejection);
+      window.removeEventListener("pagehide", onPageHide);
+      installed = false;
+    };
   }
+  return () => {
+    installed = false;
+  };
 }
 
+// src/machine.ts
+var MIN_CPU_WINDOW_MS = 1e3;
+var round1 = (value) => Math.round(value * 10) / 10;
+var clampPercent = (value) => Math.min(100, Math.max(0, value));
+var MachineSampler = class {
+  constructor(instanceId, logger) {
+    this.instanceId = instanceId;
+    this.logger = logger;
+  }
+  os;
+  fs;
+  ready = false;
+  prevCpu;
+  prevProcessCpu;
+  prevAt = 0;
+  lastCpuPercent = null;
+  lastProcessCpuPercent = null;
+  /** Carrega os módulos e tira a leitura-base de CPU (a primeira amostra ainda sai com cpu_percent null). */
+  async start() {
+    if (!isNode()) return;
+    try {
+      this.os = await import("os");
+      this.fs = await import("fs");
+      this.prevCpu = this.cpuTotals();
+      this.prevProcessCpu = process.cpuUsage();
+      this.prevAt = Date.now();
+      this.ready = true;
+    } catch (error) {
+      this.logger.debug("m\xE9tricas de m\xE1quina indispon\xEDveis neste runtime", error);
+    }
+  }
+  sample() {
+    if (!this.ready || !this.os) return void 0;
+    try {
+      const os = this.os;
+      const cpuCount = Math.max(1, os.cpus().length);
+      this.updateCpu(cpuCount);
+      const snapshot = {
+        sampled_at: nowISO(),
+        instance_id: this.instanceId,
+        hostname: os.hostname(),
+        os: process.platform,
+        arch: process.arch,
+        cpu_count: cpuCount,
+        cpu_percent: this.lastCpuPercent,
+        process: {
+          pid: process.pid,
+          uptime_s: Math.round(process.uptime()),
+          cpu_percent: this.lastProcessCpuPercent
+        },
+        source: "stdlib"
+      };
+      if (process.platform !== "win32") {
+        const load = os.loadavg()[0];
+        if (typeof load === "number" && Number.isFinite(load)) snapshot.load_1 = round1(load);
+      }
+      const memTotal = os.totalmem();
+      const memFree = os.freemem();
+      if (memTotal > 0) {
+        snapshot.mem_total_bytes = memTotal;
+        snapshot.mem_available_bytes = memFree;
+        snapshot.mem_percent = round1(clampPercent((memTotal - memFree) / memTotal * 100));
+      }
+      const disk = this.diskUsage();
+      if (disk) Object.assign(snapshot, disk);
+      const mem = process.memoryUsage();
+      snapshot.process.rss_bytes = mem.rss;
+      snapshot.process.heap_used_bytes = mem.heapUsed;
+      return snapshot;
+    } catch (error) {
+      this.logger.debug("falha ao coletar m\xE9tricas de m\xE1quina", error);
+      return void 0;
+    }
+  }
+  cpuTotals() {
+    let busy = 0;
+    let total = 0;
+    for (const cpu of this.os.cpus()) {
+      const t = cpu.times;
+      const cpuBusy = t.user + t.nice + t.sys + t.irq;
+      busy += cpuBusy;
+      total += cpuBusy + t.idle;
+    }
+    return { busy, total };
+  }
+  /** Média desde a leitura anterior; leituras com menos de 1s de janela reutilizam a última média. */
+  updateCpu(cpuCount) {
+    const now = Date.now();
+    const elapsedMs = now - this.prevAt;
+    if (elapsedMs < MIN_CPU_WINDOW_MS) return;
+    const cpu = this.cpuTotals();
+    if (this.prevCpu) {
+      const total = cpu.total - this.prevCpu.total;
+      if (total > 0) this.lastCpuPercent = round1(clampPercent((cpu.busy - this.prevCpu.busy) / total * 100));
+    }
+    this.prevCpu = cpu;
+    const usage = process.cpuUsage(this.prevProcessCpu);
+    const usedMicros = usage.user + usage.system;
+    this.lastProcessCpuPercent = round1(clampPercent(usedMicros / (elapsedMs * 1e3 * cpuCount) * 100));
+    this.prevProcessCpu = process.cpuUsage();
+    this.prevAt = now;
+  }
+  diskUsage() {
+    const statfs = this.fs?.statfsSync;
+    if (typeof statfs !== "function") return void 0;
+    try {
+      const path = process.cwd();
+      const stat = statfs(path);
+      const total = stat.bsize * stat.blocks;
+      const free = stat.bsize * stat.bavail;
+      if (total <= 0) return void 0;
+      return {
+        disk_path: path,
+        disk_total_bytes: total,
+        disk_free_bytes: free,
+        disk_percent: round1(clampPercent((total - free) / total * 100))
+      };
+    } catch {
+      return void 0;
+    }
+  }
+};
+
 // src/scope.ts
 var Scope = class _Scope {
   tags = {};
@@ -1787,7 +1944,7 @@ function installShutdownHandlers(agent2) {
 }
 
 // src/tasks/agent.ts
-var DEFAULT_POLL_INTERVAL_MS = 5e3;
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
 var MIN_POLL_INTERVAL_MS = 1e3;
 var MAX_CONCURRENCY = 5;
 var POLL_RETRY_DELAYS_MS = [1e3, 4e3, 16e3];
@@ -1918,11 +2075,17 @@ var TaskAgent = class {
             instance_id: this.instanceId,
             version: SDK_VERSION,
             host: hostname(),
+            // ambiente da instância: em agentes poll-only (sem heartbeat) este é o
+            // único canal por onde o servidor descobre onde o robô está rodando
+            environment: this.options.environment,
             tasks: [...this.registry.keys()],
             // o servidor calcula a tolerância de offline (3×) a partir disto em
             // agentes poll-only — sem o campo, um poll lento flaparia offline/online.
             // Clampado à faixa aceita pelo schema do poll (1s..15min).
-            poll_interval_ms: Math.min(Math.max(this.pollIntervalMs, 1e3), 9e5)
+            poll_interval_ms: Math.min(Math.max(this.pollIntervalMs, 1e3), 9e5),
+            // recursos da máquina — alimenta a série da instância em agentes sem heartbeat
+            // (o servidor grava no máx. 1 ponto/30s por instância)
+            machine: this.options.machineSampler?.sample()
           },
           max: Math.min(MAX_CONCURRENCY, this.concurrency - this.activeRuns.size),
           tasks: [...this.registry.keys()]
@@ -2070,7 +2233,9 @@ var DEFAULT_MAX_BREADCRUMBS = 100;
 var client;
 var scope = new Scope();
 var heartbeat;
+var machineSampler;
 var agent;
+var uninstallGlobalHandlers;
 var registry = /* @__PURE__ */ new Map();
 var warnedTasksDisabled = false;
 function init(options) {
@@ -2083,21 +2248,26 @@ function init(options) {
     void agent.stop(0);
     agent = void 0;
   }
+  uninstallGlobalHandlers?.();
+  uninstallGlobalHandlers = void 0;
   warnedTasksDisabled = false;
   const config = resolveConfig(options);
   client = new Client(options, config);
+  machineSampler = options.machineMetrics === false ? void 0 : new MachineSampler(options.instanceId, client.logger);
+  void machineSampler?.start();
+  client.attachMachineSampler(machineSampler);
   if (options.captureUnhandled !== false) {
-    installGlobalHandlers(client, () => scope);
+    uninstallGlobalHandlers = installGlobalHandlers(client, () => scope);
   }
   if (options.heartbeat) {
     const heartbeatOptions = options.heartbeat === true ? {} : options.heartbeat;
-    heartbeat = new Heartbeat(client, heartbeatOptions, options.instanceId);
+    heartbeat = new Heartbeat(client, heartbeatOptions, options.instanceId, machineSampler);
     heartbeat.start();
   }
   if (options.tasks) {
     const tasksOptions = options.tasks === true ? {} : options.tasks;
     agent = new TaskAgent(
-      { ...tasksOptions, config, instanceId: options.instanceId, debug: options.debug, client },
+      { ...tasksOptions, config, instanceId: options.instanceId, environment: options.environment, debug: options.debug, client, machineSampler },
       registry
     );
   }