hobots 3.3.0 → 4.0.0

package/dist/index.js

@@ -57,7 +57,7 @@ function scrubSecrets(text) {
 
 // src/utils.ts
 var SDK_NAME = "hobots";
-var SDK_VERSION = true ? "3.3.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "4.0.0" : "0.0.0-dev";
 function isNode() {
   return typeof process !== "undefined" && typeof process.versions?.node === "string";
 }
@@ -312,6 +312,7 @@ var Transport = class {
     try {
       response = await fetchWithRetry(
         () => fetch(this.endpoint, {
+          redirect: "error",
           method: "POST",
           headers: { "content-type": "application/json", authorization: `Bearer ${this.key}` },
           body: JSON.stringify(envelope),
@@ -489,7 +490,6 @@ function envBaseUrl() {
 function isLoopbackHost(hostname2) {
   return hostname2 === "localhost" || hostname2.endsWith(".localhost") || hostname2.startsWith("127.") || hostname2 === "[::1]" || hostname2 === "::1" || hostname2 === "0.0.0.0";
 }
-var warnedInsecureBaseUrl = false;
 function validateBaseUrl(raw, prefix) {
   let url;
   try {
@@ -503,11 +503,8 @@ function validateBaseUrl(raw, prefix) {
   if (url.username || url.password) {
     throw new Error(`${prefix} HOBOTS_API_URL n\xE3o pode conter credenciais na URL \u2014 a autentica\xE7\xE3o \xE9 s\xF3 pelo Client Secret`);
   }
-  if (url.protocol === "http:" && !isLoopbackHost(url.hostname) && !warnedInsecureBaseUrl) {
-    warnedInsecureBaseUrl = true;
-    console.warn(
-      `${prefix} HOBOTS_API_URL usa http para o host remoto "${url.hostname}" \u2014 o Client Secret trafega sem TLS`
-    );
+  if (url.protocol === "http:" && !isLoopbackHost(url.hostname)) {
+    throw new Error(`${prefix} HOBOTS_API_URL usa http para o host remoto "${url.hostname}" \u2014 o Client Secret trafegaria sem TLS; use https`);
   }
   return raw.replace(/\/+$/, "");
 }
@@ -517,7 +514,7 @@ function resolveConfig(options = {}, prefix = "[hobots]") {
   const origin = fromOption ? "clientSecret" : `env ${CLIENT_SECRET_ENV}`;
   if (!key) {
     throw new Error(
-      `${prefix} Client Secret ausente \u2014 defina a env ${CLIENT_SECRET_ENV} (ou passe clientSecret nas op\xE7\xF5es da task); copie o Client Secret do agente em Configura\xE7\xF5es \u2192 Agentes`
+      `${prefix} Client Secret ausente \u2014 defina a env ${CLIENT_SECRET_ENV} (ou passe clientSecret nas op\xE7\xF5es do register/start); copie o Client Secret do agente em Configura\xE7\xF5es \u2192 Agentes`
     );
   }
   if (!SECRET_PATTERN.test(key)) {
@@ -530,7 +527,7 @@ function resolveConfig(options = {}, prefix = "[hobots]") {
     key,
     baseUrl,
     ingestEndpoint: `${baseUrl}/v1/ingest`,
-    tasksBaseUrl: `${baseUrl}/v1/tasks`
+    runsBaseUrl: `${baseUrl}/v1/runs`
   };
 }
 
@@ -871,6 +868,7 @@ var TasksApi = class {
     let response;
     try {
       response = await fetch(`${this.baseUrl}/poll`, {
+        redirect: "error",
         method: "POST",
         headers: this.headers(),
         body: JSON.stringify(request),
@@ -893,7 +891,8 @@ var TasksApi = class {
     const { signal: timeoutSignal, cleanup } = withTimeoutSignal(UPDATE_TIMEOUT_MS, signal);
     let response;
     try {
-      response = await fetch(`${this.baseUrl}/runs`, {
+      response = await fetch(`${this.baseUrl}`, {
+        redirect: "error",
         method: "POST",
         headers: this.headers(),
         body: JSON.stringify(request),
@@ -906,12 +905,11 @@ var TasksApi = class {
       throw new TasksApiError(`cria\xE7\xE3o da run falhou (HTTP ${response.status})`, response.status);
     }
     const body = await response.json().catch(() => null);
-    if (typeof body?.id !== "string" || typeof body.task !== "string") {
-      throw new TasksApiError("resposta inv\xE1lida da cria\xE7\xE3o de run (id/task ausentes)", 0);
+    if (typeof body?.id !== "string") {
+      throw new TasksApiError("resposta inv\xE1lida da cria\xE7\xE3o de run (id ausente)", 0);
     }
     return {
       id: body.id,
-      task: body.task,
       params: body.params && typeof body.params === "object" && !Array.isArray(body.params) ? body.params : {},
       form: null,
       source: typeof body.source === "string" ? body.source : "agent",
@@ -926,9 +924,9 @@ var TasksApi = class {
     }
     const valid = [];
     for (const run of runs.slice(0, Math.max(0, max))) {
-      if (typeof run?.id !== "string" || typeof run.task !== "string") continue;
+      if (typeof run?.id !== "string") continue;
       const params = run.params && typeof run.params === "object" && !Array.isArray(run.params) ? run.params : {};
-      valid.push({ ...run, id: run.id, task: run.task, params });
+      valid.push({ ...run, id: run.id, params });
     }
     if (valid.length < runs.length) {
       this.logger.warn(`poll retornou ${runs.length - valid.length} run(s) inv\xE1lida(s)/excedente(s) \u2014 descartadas`);
@@ -943,7 +941,8 @@ var TasksApi = class {
     let response;
     try {
       response = await fetchWithRetry(
-        () => fetch(`${this.baseUrl}/runs/${encodeURIComponent(runId)}`, {
+        () => fetch(`${this.baseUrl}/${encodeURIComponent(runId)}`, {
+          redirect: "error",
           method: "PATCH",
           headers: this.headers(),
           body: JSON.stringify(update),
@@ -964,7 +963,8 @@ var TasksApi = class {
    * que a run já foi cancelada/finalizada, o que é aceitável nesse caminho.
    */
   async updateRunOnce(runId, update, timeoutMs = 2e3) {
-    await fetch(`${this.baseUrl}/runs/${encodeURIComponent(runId)}`, {
+    await fetch(`${this.baseUrl}/${encodeURIComponent(runId)}`, {
+      redirect: "error",
       method: "PATCH",
       headers: this.headers(),
       body: JSON.stringify(update),
@@ -980,7 +980,8 @@ var TasksApi = class {
     let response;
     try {
       response = await fetchWithRetry(
-        () => fetch(`${this.baseUrl}/runs/${encodeURIComponent(runId)}/items`, {
+        () => fetch(`${this.baseUrl}/${encodeURIComponent(runId)}/items`, {
+          redirect: "error",
           method: "POST",
           headers: this.headers(),
           body: JSON.stringify(request),
@@ -1009,7 +1010,8 @@ var TasksApi = class {
       () => withRequestTimeout(
         UPDATE_TIMEOUT_MS,
         signal,
-        (timeoutSignal) => fetch(`${this.baseUrl}/runs/${encodeURIComponent(runId)}/attachments`, {
+        (timeoutSignal) => fetch(`${this.baseUrl}/${encodeURIComponent(runId)}/attachments`, {
+          redirect: "error",
           method: "POST",
           headers: this.headers(),
           body: JSON.stringify(request),
@@ -1042,6 +1044,7 @@ var TasksApi = class {
         UPLOAD_TIMEOUT_MS,
         signal,
         (timeoutSignal) => fetch(url, {
+          redirect: "error",
           method: "PUT",
           headers,
           // BodyInit não aceita Uint8Array<ArrayBufferLike> em todos os lib.dom; o buffer é o mesmo
@@ -1058,8 +1061,9 @@ var TasksApi = class {
   /** Marca o anexo como enviado (ou falho). Best-effort — a leitura não depende disso. */
   async confirmAttachment(runId, attachmentId, request) {
     const response = await fetch(
-      `${this.baseUrl}/runs/${encodeURIComponent(runId)}/attachments/${encodeURIComponent(attachmentId)}`,
+      `${this.baseUrl}/${encodeURIComponent(runId)}/attachments/${encodeURIComponent(attachmentId)}`,
       {
+        redirect: "error",
         method: "PATCH",
         headers: this.headers(),
         body: JSON.stringify(request),
@@ -1142,22 +1146,22 @@ var ItemHandle = class {
   sink;
   reported = false;
   status;
-  succeeded(payload) {
-    this.record("succeeded", void 0, payload);
+  succeeded(payload, options) {
+    this.record("succeeded", void 0, payload, options?.image);
   }
-  failed(message, payload) {
-    this.record("failed", message, payload);
+  failed(message, payload, options) {
+    this.record("failed", message, payload, options?.image);
     if (this.step && this.step.status !== "error") this.step.setStatus("error", message);
   }
-  occurrence(message, payload) {
-    this.record("occurrence", message, payload);
+  occurrence(message, payload, options) {
+    this.record("occurrence", message, payload, options?.image);
     if (this.step && this.step.status === "ok") this.step.setStatus("warning", message);
   }
-  record(status, message, payload) {
+  record(status, message, payload, image3) {
     this.reported = true;
     this.status = status;
     const merged = { ...this.basePayload ?? {}, ...payload ?? {} };
-    this.sink.report(status, message, Object.keys(merged).length > 0 ? merged : void 0, this.id);
+    this.sink.report(status, message, Object.keys(merged).length > 0 ? merged : void 0, this.id, image3);
   }
 };
 function resolveId(options, element, index) {
@@ -1237,6 +1241,27 @@ var MAX_ATTACHMENTS_PER_LOG_ENTRY = WIRE_LIMITS.MAX_ATTACHMENTS_PER_LOG_ENTRY;
 var MAX_CONCURRENT_UPLOADS = 3;
 var MAX_CAPTION_CHARS = WIRE_LIMITS.MAX_CAPTION_CHARS;
 var ATTACHMENT_DRAIN_MS = 15e3;
+var IMAGE_BRAND = /* @__PURE__ */ Symbol.for("hobots.image");
+var ImageAttachment = class {
+  constructor(input, caption, contentType) {
+    this.input = input;
+    this.caption = caption;
+    this.contentType = contentType;
+  }
+  input;
+  caption;
+  contentType;
+  [IMAGE_BRAND] = true;
+};
+function image(input, options = {}) {
+  return new ImageAttachment(input, options.caption, options.contentType);
+}
+function isImageAttachment(value) {
+  return typeof value === "object" && value !== null && value[IMAGE_BRAND] === true;
+}
+function toImageAttachment(value) {
+  return isImageAttachment(value) ? value : new ImageAttachment(value);
+}
 async function readImageFile(path) {
   if (!isNode()) {
     throw new Error("caminho de arquivo s\xF3 \xE9 suportado em Node");
@@ -1286,8 +1311,16 @@ function joinLogArgs(message, rest) {
   if (rest.length === 0) return safeString(message);
   return [message, ...rest].map(safeString).join(" ");
 }
-function printRunLog(task, level, message) {
-  const line = colorize(`[hobots:${task}] ${level.toUpperCase()}`, LOG_LEVEL_COLOR[level]);
+function splitLogArgs(message, rest) {
+  const args = [message, ...rest];
+  const last = args[args.length - 1];
+  if (!isImageAttachment(last)) return { text: joinLogArgs(message, rest) };
+  const text = args.slice(0, -1);
+  if (text.length === 0) return { text: last.caption !== void 0 ? safeString(last.caption) : "captura de tela", image: last };
+  return { text: joinLogArgs(text[0], text.slice(1)), image: last };
+}
+function printRunLog(level, message) {
+  const line = colorize(`[hobots] ${level.toUpperCase()}`, LOG_LEVEL_COLOR[level]);
   const method2 = level === "warning" ? "warn" : level === "success" ? "info" : level;
   console[method2](line, message);
 }
@@ -1333,7 +1366,7 @@ function scrubPayloadValue(value, depth) {
   return out;
 }
 var RunReporter = class {
-  constructor(api, runId, task, logger, tx, flushIntervalMs, cancelCheckIntervalMs, params = {}) {
+  constructor(api, runId, logger, tx, flushIntervalMs, cancelCheckIntervalMs, params = {}) {
     this.api = api;
     this.runId = runId;
     this.logger = logger;
@@ -1342,18 +1375,23 @@ var RunReporter = class {
       MAX_CANCEL_CHECK_INTERVAL_MS,
       Math.max(MIN_CANCEL_CHECK_INTERVAL_MS, cancelCheckIntervalMs ?? DEFAULT_CANCEL_CHECK_INTERVAL_MS)
     );
+    const logAt = (level) => (message, ...rest) => {
+      const { text, image: image3 } = splitLogArgs(message, rest);
+      this.log(level, text, image3);
+    };
     const log = {
-      debug: (message, ...rest) => this.log("debug", joinLogArgs(message, rest)),
-      info: (message, ...rest) => this.log("info", joinLogArgs(message, rest)),
-      warn: (message, ...rest) => this.log("warning", joinLogArgs(message, rest)),
-      error: (message, ...rest) => this.log("error", joinLogArgs(message, rest)),
-      success: (message, ...rest) => this.log("success", joinLogArgs(message, rest))
+      debug: logAt("debug"),
+      info: logAt("info"),
+      warn: logAt("warning"),
+      error: logAt("error"),
+      success: logAt("success")
     };
     tx.setLifecycleSink((level, message) => this.push(level, message));
+    tx.setAttachmentSink((image3, ts) => this.queueAttachment(image3, ts));
     const checkCanceled = () => this.checkCanceled();
     tx.setStepGuard(checkCanceled);
     const eachSink = {
-      report: (status, message, payload, id) => this.addItem(status, message, payload, id),
+      report: (status, message, payload, id, image3) => this.addItem(status, message, payload, id, image3),
       startStep: (op, description) => tx.startChild(op, description),
       declareTotal: (total) => {
         if (this.progressTotal == null) this.setProgress(this.progressCurrent, total);
@@ -1366,19 +1404,19 @@ var RunReporter = class {
     const items = {
       add: (item) => {
         checkCanceled();
-        this.addItem(item.status, item.message, item.payload, item.id);
+        this.addItem(item.status, item.message, item.payload, item.id, item.image);
       },
       succeeded: (payload, options) => {
         checkCanceled();
-        this.addItem("succeeded", void 0, payload, options?.id);
+        this.addItem("succeeded", void 0, payload, options?.id, options?.image);
       },
       failed: (message, payload, options) => {
         checkCanceled();
-        this.addItem("failed", message, payload, options?.id);
+        this.addItem("failed", message, payload, options?.id, options?.image);
       },
       occurrence: (message, payload, options) => {
         checkCanceled();
-        this.addItem("occurrence", message, payload, options?.id);
+        this.addItem("occurrence", message, payload, options?.id, options?.image);
       },
       each: (list, handler, options = {}) => eachItem(list, handler, options, eachSink)
     };
@@ -1410,7 +1448,6 @@ var RunReporter = class {
     const sleep2 = (ms) => cancelableSleep(ms, signal);
     this.context = {
       runId,
-      task,
       params,
       log,
       items,
@@ -1419,7 +1456,6 @@ var RunReporter = class {
       signal,
       throwIfCanceled: checkCanceled,
       sleep: sleep2,
-      attach: (image, options) => this.attach(image, options),
       retry: (fn, options) => retryWithBackoff(fn, { ...options, signal, wait: sleep2 })
     };
   }
@@ -1510,15 +1546,21 @@ var RunReporter = class {
     this.clearFlushTimer();
     return this.takeLogs().slice(-MAX_LOGS_PER_PATCH);
   }
-  log(level, message) {
+  /**
+   * Linha de log da run com eco no terminal. `image` (opcional) vira o anexo da linha:
+   * o id entra na entrada ANTES de qualquer I/O — é isso que mantém a ordem dos logs
+   * intacta e o handler livre da latência do upload.
+   */
+  log(level, message, image3) {
     if (this.dead) return;
     const scrubbed = scrubSecrets(safeString(message));
-    printRunLog(this.context.task, level, scrubbed);
-    this.push(level, scrubbed, true);
+    const ts = nowISO();
+    const attachmentId = image3 === void 0 ? void 0 : this.queueAttachment(image3, ts);
+    printRunLog(level, attachmentId ? `${scrubbed} [imagem]` : scrubbed);
+    this.push(level, scrubbed, true, attachmentId ? [attachmentId] : void 0, ts);
   }
   /** Bufferiza uma entrada de log sem eco no terminal (cap, truncate, flush). */
-  push(level, message, alreadyScrubbed = false, attachments) {
-    const ts = nowISO();
+  push(level, message, alreadyScrubbed = false, attachments, ts = nowISO()) {
     if (this.dead) return ts;
     const scrubbed = alreadyScrubbed ? message : scrubSecrets(message);
     this.buffer.push({
@@ -1668,7 +1710,7 @@ var RunReporter = class {
    * de status, o servidor aceita itens mesmo com a run cancelada (trabalho já feito),
    * então um reporter morto não descarta: só um kill() de exit path descarta.
    */
-  addItem(status, message, payload, id) {
+  addItem(status, message, payload, id, image3) {
     if (this.itemsClosed || this.itemsUnsupported) return;
     if (this.itemCount >= MAX_ITEMS_PER_RUN) {
       if (!this.itemsQuotaExceeded) {
@@ -1693,13 +1735,16 @@ var RunReporter = class {
         scrubbedPayload = void 0;
       }
     }
+    const ts = nowISO();
+    const attachmentId = image3 === void 0 ? void 0 : this.queueAttachment(image3, ts);
     this.itemsBuffer.push({
       id: id ? truncate(String(id), 255) : uuid4(),
       seq: this.itemSeq++,
       status,
       ...message ? { message: truncate(scrubSecrets(safeString(message)), MAX_ITEM_MESSAGE_CHARS) } : {},
       ...scrubbedPayload ? { payload: scrubbedPayload } : {},
-      ts: nowISO()
+      ts,
+      ...attachmentId ? { attachments: [attachmentId] } : {}
     });
     if (this.itemsBuffer.length >= ITEMS_FLUSH_AT_BUFFERED) {
       this.flushItems();
@@ -1779,59 +1824,51 @@ var RunReporter = class {
   }
   // ── Anexos ───────────────────────────────────────────────────────────────────
   /**
-   * Registra a linha de log com o id do anexo (síncrono, na ordem certa) e dispara
-   * o upload em segundo plano. Nunca lança: todo caminho de erro vira `{ ok: false }`
-   * com um aviso no log da run. É o `hobots.attach()`; o hint `attachment` de
-   * `hobots.captureException` também cai aqui via run-context-store.
+   * Pendura uma imagem num evento da run (log, item ou step): faz as checagens que não
+   * dependem de I/O (reporter morto, instalação sem anexos, cota), reserva o id e dispara
+   * o upload em segundo plano. Devolve o id — já referenciável pelo evento — ou undefined
+   * quando a imagem foi descartada (sempre com aviso no log da run). Nunca lança: todo
+   * caminho de erro do upload vira aviso. O hint `attachment` de `hobots.captureException`
+   * também cai aqui via `log()`.
    */
-  async attach(image, options = {}) {
-    const id = uuid4();
-    const level = options.level ?? "info";
-    const rawCaption = options.caption !== void 0 ? safeString(options.caption) : void 0;
-    const rawMessage = options.message !== void 0 ? safeString(options.message) : void 0;
-    const caption = rawCaption ? truncate(scrubSecrets(rawCaption), MAX_CAPTION_CHARS) : void 0;
-    const message = rawMessage ?? rawCaption ?? "captura de tela";
-    if (this.dead) return { id, ok: false, reason: "canceled" };
-    if (this.attachmentsUnsupported) {
-      this.log(level, message);
-      return { id, ok: false, reason: "unsupported" };
-    }
+  queueAttachment(imageIn, ts) {
+    if (this.dead) return void 0;
+    const image3 = toImageAttachment(imageIn);
+    if (this.attachmentsUnsupported) return void 0;
     if (this.attachmentCount >= MAX_ATTACHMENTS_PER_RUN) {
-      this.log(level, message);
-      this.log("warning", `anexo descartado: limite de ${MAX_ATTACHMENTS_PER_RUN} por execu\xE7\xE3o atingido`);
-      return { id, ok: false, reason: "quota" };
+      if (this.attachmentCount === MAX_ATTACHMENTS_PER_RUN) {
+        this.attachmentCount++;
+        this.log("warning", `imagem descartada: limite de ${MAX_ATTACHMENTS_PER_RUN} por execu\xE7\xE3o atingido`);
+      }
+      return void 0;
     }
     this.attachmentCount++;
-    const scrubbed = scrubSecrets(message);
-    printRunLog(this.context.task, level, `${scrubbed} [imagem]`);
-    const logTs = this.push(level, scrubbed, true, [id]);
-    let settle;
-    const result = new Promise((resolve2) => {
-      settle = resolve2;
-    });
-    const work = this.uploadAttachment(id, image, { caption, logTs, contentType: options.contentType }).then((reason) => settle(reason ? { id, ok: false, reason } : { id, ok: true })).catch(() => settle({ id, ok: false, reason: "upload-failed" }));
+    const id = uuid4();
+    const rawCaption = image3.caption !== void 0 ? safeString(image3.caption) : void 0;
+    const caption = rawCaption ? truncate(scrubSecrets(rawCaption), MAX_CAPTION_CHARS) : void 0;
+    const work = this.uploadAttachment(id, image3.input, { caption, logTs: ts, contentType: image3.contentType }).then(() => void 0).catch(() => void 0);
     this.pendingAttachments.add(work);
     void work.finally(() => this.pendingAttachments.delete(work));
-    return result;
+    return id;
   }
   /** Retorna o motivo da falha, ou undefined em sucesso. */
-  async uploadAttachment(id, image, meta) {
+  async uploadAttachment(id, image3, meta) {
     let bytes;
     try {
-      bytes = await toBytes(image);
+      bytes = await toBytes(image3);
     } catch (error) {
-      this.log("warning", `anexo n\xE3o p\xF4de ser lido: ${String(error)}`);
+      this.log("warning", `imagem n\xE3o p\xF4de ser lida: ${String(error)}`);
       return "read-failed";
     }
     const contentType = sniffContentType(bytes) ?? meta.contentType;
     if (!contentType) {
-      this.log("warning", "anexo descartado: formato n\xE3o reconhecido (aceitos: PNG, JPEG, WEBP)");
+      this.log("warning", "imagem descartada: formato n\xE3o reconhecido (aceitos: PNG, JPEG, WEBP)");
       return "unsupported-format";
     }
     if (bytes.byteLength > MAX_ATTACHMENT_BYTES) {
       this.log(
         "warning",
-        `anexo descartado: ${Math.round(bytes.byteLength / 1024)} KB excede o limite de ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB`
+        `imagem descartada: ${Math.round(bytes.byteLength / 1024)} KB excede o limite de ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB`
       );
       return "too-large";
     }
@@ -1862,11 +1899,11 @@ var RunReporter = class {
         return "unsupported";
       }
       if (error instanceof TasksApiError && error.status === 429) {
-        this.log("warning", "anexo descartado: limite de anexos por execu\xE7\xE3o atingido no servidor");
+        this.log("warning", "imagem descartada: limite de anexos por execu\xE7\xE3o atingido no servidor");
         return "quota";
       }
       if (this.abortController.signal.aborted) return "canceled";
-      this.log("warning", `falha ao enviar o anexo: ${String(error)}`);
+      this.log("warning", `falha ao enviar a imagem: ${String(error)}`);
       void this.api.confirmAttachment(this.runId, id, { status: "failed" }).catch(() => {
       });
       return "upload-failed";
@@ -2030,23 +2067,39 @@ var Step = class {
   /**
    * Desfecho da step. `message` (opcional) é o motivo legível — vai em `data.message`
    * e aparece na Central (performance e banner da execução) e no log de FINISH.
+   * `options.image` pendura um print do estado da tela em `data.attachments`.
    */
-  setStatus(status, message) {
+  setStatus(status, message, options) {
     this.status = status;
     if (message) this.setData("message", stepMessage(message));
+    if (options?.image !== void 0) this.attachImage(options.image);
     return this;
   }
   /**
    * Marca a step como `error` guardando o motivo em `data.error` ({ type, message }).
    * Aceita qualquer valor lançado; `message` sobrescreve a mensagem do erro.
+   * `options.image` pendura um print do estado da tela em `data.attachments`.
    */
-  setError(error, message) {
+  setError(error, message, options) {
     this.status = "error";
     const type = error instanceof Error ? error.name : typeof error === "object" && error !== null ? "Error" : void 0;
     const raw = message ?? (error instanceof Error ? error.message || error.name : String(error));
     this.setData("error", { ...type ? { type } : {}, message: stepMessage(raw) });
+    if (options?.image !== void 0) this.attachImage(options.image);
     return this;
   }
+  /**
+   * Dispara o upload pela run (sink do RunReporter) e referencia o anexo em
+   * `data.attachments` (chave reservada; teto igual ao das linhas de log). Fora de uma
+   * run não há onde pendurar a imagem — descarta com aviso único.
+   */
+  attachImage(image3) {
+    const current = Array.isArray(this.data?.attachments) ? this.data.attachments : [];
+    if (current.length >= MAX_ATTACHMENTS_PER_LOG_ENTRY) return;
+    const id = this.transaction.attachImage(image3);
+    if (!id) return;
+    this.setData("attachments", [...current, id]);
+  }
   /** Motivo registrado via setStatus(…, message) ou setError — usado no log de FINISH. */
   reason() {
     const error = this.data?.error;
@@ -2107,6 +2160,8 @@ var Transaction = class {
   tags = {};
   finished = false;
   lifecycleSink;
+  attachmentSink;
+  warnedNoAttachmentSink = false;
   // instalado pelo RunReporter: abrir uma step é um ponto de parada cooperativo (lança RunCanceled)
   stepGuard;
   // eventos emitidos antes do sink existir (o START da transaction sai no construtor,
@@ -2137,6 +2192,19 @@ var Transaction = class {
     this.lifecycleBacklog = [];
     for (const [level, message] of backlog) sink(level, message);
   }
+  /** Conecta o pipeline de anexos da run — é o que dá imagem às steps. */
+  setAttachmentSink(sink) {
+    this.attachmentSink = sink;
+  }
+  /** Imagem de uma step → id do anexo pela run; sem run, descarta com aviso único. */
+  attachImage(image3) {
+    if (this.attachmentSink) return this.attachmentSink(image3, nowISO());
+    if (!this.warnedNoAttachmentSink) {
+      this.warnedNoAttachmentSink = true;
+      console.warn("[hobots] imagem de step descartada \u2014 s\xF3 \xE9 suportada dentro de uma execu\xE7\xE3o");
+    }
+    return void 0;
+  }
   /**
    * Conecta a checagem de cancelamento chamada antes de cada step nova — é assim que
    * `hobots.transaction.startChild()` (e `step.startChild()`) param uma run cancelada.
@@ -2199,13 +2267,12 @@ var Transaction = class {
 // src/tasks/runner.ts
 var DEFAULT_RETRY_DELAY_MS = 5e3;
 async function executeRun(input) {
-  const { run, task, api, client, logger, tracker } = input;
-  const options = task.options;
-  const tx = new Transaction(client, `run:${run.task}`, "hobots.task", run.id);
+  const { run, handler, api, client, logger, tracker } = input;
+  const options = handler.options;
+  const tx = new Transaction(client, "run", "hobots.run", run.id);
   const reporter = new RunReporter(
     api,
     run.id,
-    run.task,
     logger,
     tx,
     options.logFlushIntervalMs,
@@ -2221,9 +2288,9 @@ async function executeRun(input) {
       tx.finish();
       return;
     }
-    logger.debug(`executando run ${run.id} (${run.task})`);
+    logger.debug(`executando run ${run.id}`);
     try {
-      await runWithRunContext({ reporter }, () => invokeWithRetry(task, run, reporter, logger));
+      await runWithRunContext({ reporter }, () => invokeWithRetry(handler, run, reporter, logger));
       await reporter.finalizeAttachments();
       await reporter.finalizeItems();
       warnIncompleteProgress(reporter);
@@ -2251,11 +2318,11 @@ function warnIncompleteProgress(reporter) {
     `execu\xE7\xE3o conclu\xEDda com progresso incompleto: ${snapshot.current}/${snapshot.total} \u2014 o handler terminou sem processar (ou sem avan\xE7ar) todos os itens previstos`
   );
 }
-function invokeWithRetry(task, run, reporter, logger) {
-  const { retries, retryDelayMs } = task.options;
+function invokeWithRetry(agent, run, reporter, logger) {
+  const { retries, retryDelayMs } = agent.options;
   const total = retries + 1;
   const ctx = reporter.context;
-  return retryWithBackoff(() => invokeWithTimeout(task, run, reporter, logger), {
+  return retryWithBackoff(() => invokeWithTimeout(agent, run, reporter, logger), {
     retries,
     delayMs: (attempt) => resolveDelay(retryDelayMs, attempt, DEFAULT_RETRY_DELAY_MS),
     shouldRetry: () => !reporter.isDead,
@@ -2269,9 +2336,9 @@ function invokeWithRetry(task, run, reporter, logger) {
 }
 var TIMEOUT_SENTINEL = /* @__PURE__ */ Symbol("task-timeout");
 var CANCEL_SENTINEL = /* @__PURE__ */ Symbol("task-canceled");
-async function invokeWithTimeout(task, run, reporter, logger) {
-  const { timeoutMs, cancelGraceMs } = task.options;
-  const handler = task.handler;
+async function invokeWithTimeout(agent, run, reporter, logger) {
+  const { timeoutMs, cancelGraceMs } = agent.options;
+  const handler = agent.handler;
   const invocation = Promise.resolve().then(() => handler(run.params, reporter.context));
   const races = [];
   if (timeoutMs && timeoutMs > 0) {
@@ -2328,7 +2395,7 @@ var TaskAgent = class {
     this.logger = options.logger;
     this.api = options.api;
     this.client = options.client;
-    this.registry = options.registry;
+    this.handler = options.handler;
     this.tracker = options.tracker;
     this.pollIntervalMs = Math.max(MIN_POLL_INTERVAL_MS, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
     this.backoff = new Backoff(this.logger, "poll", this.pollIntervalMs);
@@ -2338,7 +2405,7 @@ var TaskAgent = class {
   pollIntervalMs;
   api;
   client;
-  registry;
+  handler;
   tracker;
   backoff;
   state = "idle";
@@ -2354,10 +2421,10 @@ var TaskAgent = class {
       throw new Error("[hobots] start do agente durante o stop \u2014 aguarde o stop terminar");
     }
     this.state = "started";
-    this.logger.debug(`polling iniciado (tasks: ${this.registry.remoteTasks().map((task) => task.slug).join(", ")})`);
+    this.logger.debug(`polling iniciado (concorr\xEAncia ${this.handler.options.concurrency})`);
     this.schedule(0);
   }
-  /** Uma task registrada depois do boot entra no próximo poll — que é antecipado para já. */
+  /** Antecipa o próximo poll para já. */
   wake() {
     if (this.state !== "started") return;
     if (this.timer) {
@@ -2388,21 +2455,14 @@ var TaskAgent = class {
       void this.tick();
     }, delayMs);
   }
-  /** Slots livres por task remota — a soma vira o `max` do poll e as tasks com slot viram o filtro. */
+  /** Slots livres do agente — vira o `max` do poll (nunca reivindica trabalho para deixar parado). */
   freeSlots() {
-    const tasks = [];
-    let max = 0;
-    for (const task of this.registry.remoteTasks()) {
-      const free = task.options.concurrency - this.tracker.activeFor(task.slug);
-      if (free <= 0) continue;
-      tasks.push(task.slug);
-      max += free;
-    }
-    return { tasks, max: Math.min(MAX_CLAIM_PER_POLL, max) };
+    const free = this.handler.options.concurrency - this.tracker.activeCount;
+    return Math.min(MAX_CLAIM_PER_POLL, Math.max(0, free));
   }
   async tick() {
     if (this.state !== "started") return;
-    const { tasks, max } = this.freeSlots();
+    const max = this.freeSlots();
     if (max === 0) {
       this.schedule(this.pollIntervalMs);
       return;
@@ -2412,11 +2472,9 @@ var TaskAgent = class {
       const response = await this.api.poll(
         {
           // identidade canônica do agente no painel — o mesmo instanceId do heartbeat,
-          // então os dois canais convergem em um agente. `instance.tasks` lista TODAS as
-          // tasks (register + start); o filtro `tasks` abaixo só as que este poll pode rodar.
+          // então os dois canais convergem em um agente
           instance: this.options.instanceInfo(),
-          max,
-          tasks
+          max
         },
         this.pollAbort.signal
       );
@@ -2440,17 +2498,7 @@ var TaskAgent = class {
     this.activeRuns.add(promise);
   }
   async executeClaimed(run) {
-    const task = this.registry.get(run.task);
-    if (!task || task.mode !== "remote") {
-      const tx = new Transaction(this.client, `run:${run.task}`, "hobots.task", run.id);
-      const reporter = new RunReporter(this.api, run.id, run.task, this.logger, tx);
-      reporter.reportFailure(toRunError(Object.assign(new Error(`tarefa n\xE3o registrada no agente: ${run.task}`), { name: "HandlerNotFound" })));
-      await reporter.finalize();
-      tx.setStatus("error");
-      tx.finish();
-      return;
-    }
-    await executeRun({ run, task, api: this.api, client: this.client, logger: this.logger, tracker: this.tracker });
+    await executeRun({ run, handler: this.handler, api: this.api, client: this.client, logger: this.logger, tracker: this.tracker });
   }
 };
 
@@ -2458,11 +2506,11 @@ var TaskAgent = class {
 var KEY_RE = /^[a-zA-Z0-9_.-]{1,100}$/;
 var MAX_COLUMNS = WIRE_LIMITS.MAX_ITEM_COLUMNS;
 var MAX_LABEL_CHARS = WIRE_LIMITS.MAX_ITEM_COLUMN_LABEL_CHARS;
-function normalizeItemColumns(slug, input, logger) {
+function normalizeItemColumns(input, logger) {
   if (input === void 0 || input === null) return void 0;
   const columns = input.columns;
   if (typeof input !== "object" || !Array.isArray(columns)) {
-    logger.warn(`task "${slug}": items.columns precisa ser uma lista \u2014 declara\xE7\xE3o de colunas ignorada`);
+    logger.warn(`items.columns precisa ser uma lista \u2014 declara\xE7\xE3o de colunas ignorada`);
     return void 0;
   }
   const result = [];
@@ -2472,15 +2520,15 @@ function normalizeItemColumns(slug, input, logger) {
     const rawLabel = typeof entry === "object" && entry !== null ? entry.label : void 0;
     const key = typeof rawKey === "string" ? rawKey.trim() : "";
     if (!KEY_RE.test(key)) {
-      logger.warn(`task "${slug}": coluna de item inv\xE1lida ignorada (${JSON.stringify(rawKey)}) \u2014 use letras, n\xFAmeros, ponto, h\xEDfen e underline`);
+      logger.warn(`coluna de item inv\xE1lida ignorada (${JSON.stringify(rawKey)}) \u2014 use letras, n\xFAmeros, ponto, h\xEDfen e underline`);
       continue;
     }
     if (seen.has(key)) {
-      logger.warn(`task "${slug}": coluna de item "${key}" repetida ignorada`);
+      logger.warn(`coluna de item "${key}" repetida ignorada`);
       continue;
     }
     if (result.length >= MAX_COLUMNS) {
-      logger.warn(`task "${slug}": no m\xE1ximo ${MAX_COLUMNS} colunas de item \u2014 "${key}" em diante ignoradas`);
+      logger.warn(`no m\xE1ximo ${MAX_COLUMNS} colunas de item \u2014 "${key}" em diante ignoradas`);
       break;
     }
     seen.add(key);
@@ -2492,15 +2540,15 @@ function normalizeItemColumns(slug, input, logger) {
 
 // src/tasks/local.ts
 var LocalRunner = class {
-  constructor(task, deps) {
-    this.task = task;
+  constructor(handler, deps) {
+    this.handler = handler;
     this.deps = deps;
-    this.backoff = new Backoff(deps.logger, `cria\xE7\xE3o da run "${task.slug}"`);
+    this.backoff = new Backoff(deps.logger, "cria\xE7\xE3o da run");
     this.done = new Promise((resolve2) => {
       this.resolveDone = resolve2;
     });
   }
-  task;
+  handler;
   deps;
   abort = new AbortController();
   backoff;
@@ -2511,17 +2559,17 @@ var LocalRunner = class {
     try {
       const run = await this.createRun();
       if (!run) return;
-      this.deps.logger.debug(`run ${run.id} aberta para "${this.task.slug}" (modo start)`);
+      this.deps.logger.debug(`run ${run.id} aberta (modo start)`);
       await executeRun({
         run,
-        task: this.task,
+        handler: this.handler,
         api: this.deps.api,
         client: this.deps.client,
         logger: this.deps.logger,
         tracker: this.deps.tracker
       });
     } catch (error) {
-      this.deps.logger.error(`erro inesperado na task "${this.task.slug}":`, error);
+      this.deps.logger.error("erro inesperado na execu\xE7\xE3o do agente:", error);
     } finally {
       this.resolveDone();
     }
@@ -2534,7 +2582,7 @@ var LocalRunner = class {
     for (; ; ) {
       if (this.abort.signal.aborted) return void 0;
       try {
-        return await this.deps.api.createRun({ task: this.task.slug, instance: this.deps.instanceInfo() }, this.abort.signal);
+        return await this.deps.api.createRun({ instance: this.deps.instanceInfo() }, this.abort.signal);
       } catch (error) {
         if (this.abort.signal.aborted) return void 0;
         await abortableSleep(this.backoff.next(error), this.abort.signal);
@@ -2544,45 +2592,6 @@ var LocalRunner = class {
 };
 
 // src/tasks/registry.ts
-var TaskRegistry = class {
-  tasks = /* @__PURE__ */ new Map();
-  add(task) {
-    if (this.tasks.has(task.slug)) {
-      throw new Error(`[hobots] task "${task.slug}" j\xE1 registrada \u2014 cada slug s\xF3 pode ter um handler (register ou start)`);
-    }
-    this.tasks.set(task.slug, task);
-  }
-  get(slug) {
-    return this.tasks.get(slug);
-  }
-  get size() {
-    return this.tasks.size;
-  }
-  /** Tasks que chegam pelo poll (register). */
-  remoteTasks() {
-    return [...this.tasks.values()].filter((task) => task.mode === "remote");
-  }
-  /** Tasks abertas pelo próprio bot (start). */
-  localTasks() {
-    return [...this.tasks.values()].filter((task) => task.mode === "local");
-  }
-  /** Todos os slugs, para a presença da instância (`instance.tasks`). */
-  allSlugs() {
-    return [...this.tasks.keys()];
-  }
-  /** Colunas de itens declaradas no código, por slug (`instance.task_items`); undefined se nenhuma task declarou. */
-  itemDeclarations() {
-    let result;
-    for (const task of this.tasks.values()) {
-      if (!task.options.itemColumns) continue;
-      (result ??= {})[task.slug] = { attributes: task.options.itemColumns };
-    }
-    return result;
-  }
-  clear() {
-    this.tasks.clear();
-  }
-};
 var RunTracker = class {
   constructor(api) {
     this.api = api;
@@ -2603,12 +2612,6 @@ var RunTracker = class {
   get activeCount() {
     return this.reporters.size;
   }
-  /** Runs ativas de uma task (concorrência por task no poll). */
-  activeFor(slug) {
-    let count = 0;
-    for (const reporter of this.reporters) if (reporter.context.task === slug) count++;
-    return count;
-  }
   /** A única run ativa, quando há exatamente uma — o que `hobots.*` usa fora de um contexto async. */
   singleActive() {
     if (this.reporters.size !== 1) return void 0;
@@ -2697,40 +2700,13 @@ var DEFAULT_RETRIES2 = 1;
 var DEFAULT_RETRY_DELAY_MS2 = 5e3;
 var DEFAULT_CANCEL_GRACE_MS = 1e4;
 var MAX_CONCURRENCY = 5;
-var MAX_SLUG_CHARS = 255;
-var PROCESS_LEVEL_KEYS = [
-  "clientSecret",
-  "instanceId",
-  "environment",
-  "release",
-  "tags",
-  "debug",
-  "machineMetrics",
-  "captureUnhandled",
-  "installExitHandlers"
-];
 var runtime;
 var warnedNoRuntime = false;
 function hostname() {
   if (!isNode()) return void 0;
   return process.env.HOSTNAME || process.env.COMPUTERNAME || void 0;
 }
-function sameValue(a, b) {
-  if (a === b) return true;
-  if (a && b && typeof a === "object" && typeof b === "object") return JSON.stringify(a) === JSON.stringify(b);
-  return false;
-}
-function ensureRuntime(options) {
-  if (runtime) {
-    for (const key of PROCESS_LEVEL_KEYS) {
-      if (options[key] !== void 0 && !sameValue(options[key], runtime.options[key])) {
-        runtime.logger.warn(
-          `op\xE7\xE3o "${key}" divergente ignorada \u2014 o primeiro register()/start() define as op\xE7\xF5es do processo`
-        );
-      }
-    }
-    return runtime;
-  }
+function createRuntime(options, handler) {
   const config = resolveConfig({ clientSecret: options.clientSecret });
   const logger = makeLogger(options.debug ?? false);
   const environment = resolveEnvironmentOption(options.environment);
@@ -2738,19 +2714,19 @@ function ensureRuntime(options) {
     { environment, release: options.release, tags: options.tags, debug: options.debug },
     config
   );
-  const api = new TasksApi({ baseUrl: config.tasksBaseUrl, key: config.key, logger });
-  runtime = {
+  const api = new TasksApi({ baseUrl: config.runsBaseUrl, key: config.key, logger });
+  const rt = {
     options: { ...options, clientSecret: void 0 },
     config,
     client,
     logger,
     api,
-    registry: new TaskRegistry(),
+    handler,
     tracker: new RunTracker(api),
     sampler: void 0,
     heartbeat: void 0,
     agent: void 0,
-    locals: /* @__PURE__ */ new Map(),
+    local: void 0,
     instanceId: resolveInstanceId(options.instanceId),
     environment,
     pollIntervalMs: void 0,
@@ -2760,24 +2736,19 @@ function ensureRuntime(options) {
     uninstallGlobalHandlers: options.captureUnhandled !== false ? installGlobalHandlers(client) : void 0,
     uninstallShutdown: void 0
   };
-  runtime.options.clientSecret = options.clientSecret;
   logger.debug("inicializado", { endpoint: config.ingestEndpoint });
-  return runtime;
+  return rt;
 }
-function validateTask(slug, handler, fn) {
-  if (typeof slug !== "string" || slug.trim().length === 0 || slug.length > MAX_SLUG_CHARS) {
-    throw new Error(`[hobots] ${fn}(): o slug da task precisa ser uma string de 1 a ${MAX_SLUG_CHARS} caracteres`);
-  }
+function validateHandler(handler, fn) {
   if (typeof handler !== "function") {
-    throw new Error(`[hobots] ${fn}('${slug}'): o handler precisa ser uma fun\xE7\xE3o`);
+    throw new Error(`[hobots] ${fn}(): o handler precisa ser uma fun\xE7\xE3o \u2014 ${fn}(async (params) => { ... })`);
   }
-  return slug.trim();
 }
 function clampConcurrency(value) {
   if (value === void 0 || !Number.isFinite(value)) return 1;
   return Math.min(MAX_CONCURRENCY, Math.max(1, Math.floor(value)));
 }
-function resolveTaskOptions(slug, options, mode, logger) {
+function resolveRunOptions(options, mode, logger) {
   const retries = options.retries === void 0 || !Number.isFinite(options.retries) ? DEFAULT_RETRIES2 : Math.max(0, Math.floor(options.retries));
   return {
     retries,
@@ -2787,7 +2758,7 @@ function resolveTaskOptions(slug, options, mode, logger) {
     logFlushIntervalMs: options.logFlushIntervalMs,
     cancelCheckIntervalMs: options.cancelCheckIntervalMs,
     cancelGraceMs: options.cancelGraceMs ?? DEFAULT_CANCEL_GRACE_MS,
-    itemColumns: normalizeItemColumns(slug, options.items, logger)
+    itemColumns: normalizeItemColumns(options.items, logger)
   };
 }
 function instanceInfo(rt) {
@@ -2797,10 +2768,10 @@ function instanceInfo(rt) {
     host: hostname(),
     // ambiente da instância: junto do heartbeat, é como o servidor sabe onde o robô roda
     environment: rt.environment,
-    // TODAS as tasks (register + start) — o painel mostra o que o agente sabe fazer
-    tasks: rt.registry.allSlugs(),
+    // como esta instância trabalha — o painel mostra "sob demanda" / "sempre ligado"
+    mode: rt.handler.mode === "remote" ? "on_demand" : "always_on",
     // colunas da aba "itens" declaradas no código — a plataforma usa enquanto o usuário não personalizar
-    task_items: rt.registry.itemDeclarations(),
+    items: rt.handler.options.itemColumns ? { attributes: rt.handler.options.itemColumns } : void 0,
     // o servidor calcula a tolerância de offline (3×) a partir disto em agentes que fazem
     // poll; clampado à faixa aceita pelo schema (1s..15min)
     poll_interval_ms: rt.agent ? Math.min(Math.max(rt.agent.pollIntervalMs, 1e3), 9e5) : void 0,
@@ -2813,22 +2784,22 @@ function ensureAgent(rt) {
     api: rt.api,
     client: rt.client,
     logger: rt.logger,
-    registry: rt.registry,
+    handler: rt.handler,
     tracker: rt.tracker,
     instanceInfo: () => instanceInfo(rt),
     pollIntervalMs: rt.pollIntervalMs
   });
   return rt.agent;
 }
-function launchLocal(rt, task) {
-  const runner = new LocalRunner(task, {
+function launchLocal(rt) {
+  const runner = new LocalRunner(rt.handler, {
     api: rt.api,
     client: rt.client,
     logger: rt.logger,
     tracker: rt.tracker,
     instanceInfo: () => instanceInfo(rt)
   });
-  rt.locals.set(task.slug, runner);
+  rt.local = runner;
   void runner.run();
 }
 async function boot(rt) {
@@ -2850,8 +2821,8 @@ async function boot(rt) {
   if (rt.options.installExitHandlers !== false) {
     rt.uninstallShutdown = installShutdownHandlers(rt.tracker);
   }
-  if (rt.registry.remoteTasks().length > 0) ensureAgent(rt).start();
-  for (const task of rt.registry.localTasks()) launchLocal(rt, task);
+  if (rt.handler.mode === "remote") ensureAgent(rt).start();
+  else launchLocal(rt);
 }
 function scheduleBoot(rt) {
   if (rt.bootScheduled) return;
@@ -2860,34 +2831,23 @@ function scheduleBoot(rt) {
     rt.bootPromise = boot(rt).catch((error) => rt.logger.error("falha ao iniciar o SDK:", error));
   });
 }
-function addTask(fn, mode, task, handler, options) {
-  const slug = validateTask(task, handler, fn);
-  const rt = ensureRuntime(options);
-  if (mode === "remote" && options.pollIntervalMs !== void 0) {
-    if (rt.pollIntervalMs === void 0 && !rt.agent) rt.pollIntervalMs = options.pollIntervalMs;
-    else if (rt.pollIntervalMs !== options.pollIntervalMs) {
-      rt.logger.warn('op\xE7\xE3o "pollIntervalMs" divergente ignorada \u2014 o primeiro register() define o intervalo do poll');
-    }
-  }
-  const registered = { slug, mode, handler, options: resolveTaskOptions(slug, options, mode, rt.logger) };
-  rt.registry.add(registered);
-  if (!rt.booted) {
-    scheduleBoot(rt);
-    return;
-  }
-  if (mode === "remote") {
-    const agent = ensureAgent(rt);
-    agent.start();
-    agent.wake();
-  } else {
-    launchLocal(rt, registered);
+function startAgent(fn, mode, handler, options) {
+  validateHandler(handler, fn);
+  if (runtime) {
+    throw new Error(`[hobots] ${fn}(): o agente j\xE1 foi iniciado \u2014 register()/start() s\xF3 pode ser chamado uma vez por processo (chame hobots.close() antes de iniciar de novo)`);
   }
+  const logger = makeLogger(options.debug ?? false);
+  const agentHandler = { mode, handler, options: resolveRunOptions(options, mode, logger) };
+  const rt = createRuntime(options, agentHandler);
+  if (mode === "remote" && options.pollIntervalMs !== void 0) rt.pollIntervalMs = options.pollIntervalMs;
+  runtime = rt;
+  scheduleBoot(rt);
 }
-function register(task, handler, options = {}) {
-  addTask("register", "remote", task, handler, options);
+function register(handler, options = {}) {
+  startAgent("register", "remote", handler, options);
 }
-function start(task, handler, options = {}) {
-  addTask("start", "local", task, handler, options);
+function start(handler, options = {}) {
+  startAgent("start", "local", handler, options);
 }
 function currentReporter() {
   return currentRunReporter() ?? runtime?.tracker.singleActive();
@@ -2901,23 +2861,18 @@ function toRunLogLevel(type) {
 function forwardAttachment(rt, attachment, message, type) {
   const reporter = currentReporter();
   if (!reporter) {
-    rt.logger.warn("attachment descartado \u2014 s\xF3 \xE9 suportado dentro de uma execu\xE7\xE3o de task");
+    rt.logger.warn("attachment descartado \u2014 s\xF3 \xE9 suportado dentro de uma execu\xE7\xE3o");
     return;
   }
-  const withMeta = typeof attachment === "object" && "image" in attachment ? attachment : { image: attachment };
-  void reporter.attach(withMeta.image, {
-    message,
-    level: toRunLogLevel(type),
-    caption: withMeta.caption,
-    contentType: withMeta.contentType
-  });
+  const withMeta = typeof attachment === "object" && !isImageAttachment(attachment) && "image" in attachment ? image(attachment.image, { caption: attachment.caption, contentType: attachment.contentType }) : attachment;
+  reporter.log(toRunLogLevel(type), message, withMeta);
 }
 function captureException(error, hint) {
   const rt = runtime;
   if (!rt) {
     if (!warnedNoRuntime) {
       warnedNoRuntime = true;
-      console.warn("[hobots] captureException antes de registrar uma task (register/start) \u2014 evento descartado");
+      console.warn("[hobots] captureException antes de iniciar o agente (register/start) \u2014 evento descartado");
     }
     return void 0;
   }
@@ -2933,7 +2888,7 @@ async function close(timeoutMs = 3e4) {
   runtime = void 0;
   await rt.bootPromise;
   if (rt.agent) await rt.agent.stop(0);
-  for (const local of rt.locals.values()) local.stop();
+  rt.local?.stop();
   const idle = await rt.tracker.waitIdle(timeoutMs);
   if (!idle) {
     rt.logger.warn(`${rt.tracker.activeCount} run(s) ainda em execu\xE7\xE3o ap\xF3s ${timeoutMs}ms \u2014 abandonando a espera`);
@@ -2951,18 +2906,21 @@ var warned = /* @__PURE__ */ new Set();
 function warnOutsideRun(member) {
   if (warned.has(member)) return;
   warned.add(member);
-  const message = `hobots.${member} usado fora de uma execu\xE7\xE3o de task \u2014 ignorado (registre a task com register()/start() e use dentro do handler)`;
+  const message = `hobots.${member} usado fora de uma execu\xE7\xE3o \u2014 ignorado (inicie o agente com register()/start() e use dentro do handler)`;
   const logger = activeLogger();
   if (logger) logger.warn(message);
   else console.warn(`[hobots] ${message}`);
 }
-var FALLBACK_TASK = "hobots";
+var fallbackLogAt = (level) => (message, ...rest) => {
+  const { text, image: dropped } = splitLogArgs(message, rest);
+  printRunLog(level, dropped ? `${text} [imagem descartada]` : text);
+};
 var fallbackLog = {
-  debug: (message, ...rest) => printRunLog(FALLBACK_TASK, "debug", joinLogArgs(message, rest)),
-  info: (message, ...rest) => printRunLog(FALLBACK_TASK, "info", joinLogArgs(message, rest)),
-  warn: (message, ...rest) => printRunLog(FALLBACK_TASK, "warning", joinLogArgs(message, rest)),
-  error: (message, ...rest) => printRunLog(FALLBACK_TASK, "error", joinLogArgs(message, rest)),
-  success: (message, ...rest) => printRunLog(FALLBACK_TASK, "success", joinLogArgs(message, rest))
+  debug: fallbackLogAt("debug"),
+  info: fallbackLogAt("info"),
+  warn: fallbackLogAt("warning"),
+  error: fallbackLogAt("error"),
+  success: fallbackLogAt("success")
 };
 var noop = () => void 0;
 var fallbackEachSink = {
@@ -2972,7 +2930,7 @@ var fallbackEachSink = {
   advance: noop,
   checkCanceled: noop,
   isAborted: () => false,
-  logError: (message) => printRunLog(FALLBACK_TASK, "error", message)
+  logError: (message) => printRunLog("error", message)
 };
 var fallbackItems = {
   add: noop,
@@ -2999,7 +2957,6 @@ function method(value) {
 var hobots = Object.defineProperties({}, {
   // ── contexto da run atual (getters) ─────────────────────────────────────────
   runId: getter("runId", () => ""),
-  task: getter("task", () => ""),
   params: getter("params", () => ({})),
   log: getter("log", () => fallbackLog),
   items: getter("items", () => fallbackItems),
@@ -3008,24 +2965,22 @@ var hobots = Object.defineProperties({}, {
   signal: getter("signal", () => neverAborts),
   throwIfCanceled: method(() => resolve("throwIfCanceled")?.throwIfCanceled()),
   sleep: method((ms) => resolve("sleep")?.sleep(ms) ?? sleep(ms)),
-  attach: method(
-    (image, options) => resolve("attach")?.attach(image, options) ?? Promise.resolve({ id: "", ok: false, reason: "canceled" })
-  ),
   retry: method((fn, options) => {
     const reporter = currentReporter();
     return reporter ? reporter.context.retry(fn, options) : retryWithBackoff(fn, options);
   }),
   // ── processo ────────────────────────────────────────────────────────────────
-  register: method((task, handler, options) => {
-    register(task, handler, options);
+  register: method((handler, options) => {
+    register(handler, options);
     installGlobalHobots();
   }),
-  start: method((task, handler, options) => {
-    start(task, handler, options);
+  start: method((handler, options) => {
+    start(handler, options);
     installGlobalHobots();
   }),
   close: method((timeoutMs) => close(timeoutMs)),
-  captureException: method((error, hint) => captureException(error, hint))
+  captureException: method((error, hint) => captureException(error, hint)),
+  image: method(image)
 });
 function installGlobalHobots() {
   if (globalThis.hobots === hobots) return;
@@ -3036,6 +2991,7 @@ var start2 = hobots.start;
 var close2 = hobots.close;
 var captureException2 = hobots.captureException;
 var retry = hobots.retry;
+var image2 = hobots.image;
 
 // src/index.ts
 var src_default = hobots;
@@ -3044,6 +3000,7 @@ export {
   close2 as close,
   src_default as default,
   hobots,
+  image2 as image,
   register2 as register,
   retry,
   start2 as start