hobots 4.5.0 → 5.1.0

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   WIRE_LIMITS
-} from "./chunk-HKCDMUA3.js";
+} from "./chunk-6YTOYIZM.js";
 
 // src/utils.ts
 var SDK_NAME = "hobots";
-var SDK_VERSION = true ? "4.5.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "5.1.0" : "0.0.0-dev";
 function isNode() {
   return typeof process !== "undefined" && typeof process.versions?.node === "string";
 }
@@ -57,8 +57,13 @@ function abortableSleep(ms, signal) {
 function jitter(baseMs) {
   return Math.floor(baseMs / 2 + Math.random() * (baseMs / 2));
 }
+var TRUNCATION_SUFFIX = "\u2026 [truncado]";
 function truncate(value, max) {
-  return value.length > max ? `${value.slice(0, max)}\u2026 [truncado]` : value;
+  return value.length > max ? `${value.slice(0, max)}${TRUNCATION_SUFFIX}` : value;
+}
+function clip(value, max) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, Math.max(0, max - TRUNCATION_SUFFIX.length))}${TRUNCATION_SUFFIX}`;
 }
 function safeString(value) {
   if (typeof value === "string") return value;
@@ -156,6 +161,8 @@ function colorize(text, color) {
 var INSTANCE_ID_ENV = "HOBOTS_INSTANCE_ID";
 var ENVIRONMENT_ENV = "HOBOTS_ENVIRONMENT";
 var RUN_ID_ENV = "HOBOTS_RUN_ID";
+var LOCAL_RUN_ENV = "HOBOTS_LOCAL_RUN";
+var RUN_PARAMS_ENV = "HOBOTS_RUN_PARAMS";
 var dotenvLoaded = false;
 function loadDotenv() {
   if (dotenvLoaded) return;
@@ -181,6 +188,24 @@ function resolveRunId(option) {
   if (typeof process === "undefined" || !process.env) return void 0;
   return process.env[RUN_ID_ENV]?.trim() || void 0;
 }
+function isLocalRun() {
+  if (typeof process === "undefined" || !process.env) return false;
+  return process.env[LOCAL_RUN_ENV]?.trim() === "1";
+}
+function resolveLocalRunParams() {
+  const raw = process.env[RUN_PARAMS_ENV]?.trim();
+  if (!raw) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`${RUN_PARAMS_ENV} inv\xE1lido: n\xE3o \xE9 JSON v\xE1lido`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${RUN_PARAMS_ENV} inv\xE1lido: esperado um objeto JSON`);
+  }
+  return parsed;
+}
 function resolveEnvironmentOption(option) {
   const fromOption = option?.trim();
   if (fromOption) return fromOption;
@@ -394,9 +419,18 @@ var MAX_FINGERPRINT_ITEMS = 10;
 var MAX_FINGERPRINT_ITEM_CHARS = 255;
 var MAX_TRANSACTION_NAME_CHARS = 500;
 var MAX_STEPS = 200;
+var MAX_STEP_DESCRIPTION_CHARS = 2048;
+var MAX_STEP_OP_CHARS = 255;
 function clipTags(tags) {
   return Object.fromEntries(Object.entries(tags).map(([key, value]) => [key, truncate(String(value), MAX_TAG_VALUE_CHARS)]));
 }
+function clipStep(step) {
+  return {
+    ...step,
+    ...step.op ? { op: clip(step.op, MAX_STEP_OP_CHARS) } : {},
+    ...step.description ? { description: clip(step.description, MAX_STEP_DESCRIPTION_CHARS) } : {}
+  };
+}
 function clipFingerprint(fingerprint) {
   if (fingerprint === void 0) return void 0;
   return fingerprint.slice(0, MAX_FINGERPRINT_ITEMS).map((item) => truncate(String(item), MAX_FINGERPRINT_ITEM_CHARS));
@@ -455,12 +489,13 @@ var Client = class {
   [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
     return `Client { baseUrl: '${this.#config.baseUrl}' }`;
   }
-  captureException(error, hint) {
+  /** `contexts` é interno ao SDK (ex.: `contexts.run` com o print do captureException) — o evento ainda pode sobrescrever. */
+  captureException(error, hint, contexts) {
     if (typeof error === "object" && error !== null) captured.add(error);
-    return this.captureEvent(eventFromException(error, hint?.type ?? "error"), hint);
+    return this.captureEvent(eventFromException(error, hint?.type ?? "error"), hint, contexts);
   }
-  captureEvent(event, hint) {
-    const final = this.prepareEvent(event, hint);
+  captureEvent(event, hint, contexts) {
+    const final = this.prepareEvent(contexts ? { ...event, contexts: { ...contexts, ...event.contexts } } : event, hint);
     this.transport.enqueue({ type: "event", payload: final });
     return final.event_id;
   }
@@ -483,14 +518,15 @@ var Client = class {
   sendTransaction(payload) {
     let steps = payload.steps;
     if (steps.length > MAX_STEPS) {
-      this.logger.warn(`transaction com ${steps.length} steps \u2014 enviando as primeiras ${MAX_STEPS}`);
+      this.logger.warn(`transaction com ${steps.length} etapas \u2014 enviando as primeiras ${MAX_STEPS}`);
       steps = steps.slice(0, MAX_STEPS);
     }
+    steps = steps.map(clipStep);
     this.transport.enqueue({
       type: "transaction",
       payload: {
         ...payload,
-        name: truncate(payload.name || "(sem nome)", MAX_TRANSACTION_NAME_CHARS),
+        name: clip(payload.name || "(sem nome)", MAX_TRANSACTION_NAME_CHARS),
         steps,
         release: payload.release ?? this.options.release,
         environment: this.resolveEnvironment(payload.environment),
@@ -1063,6 +1099,36 @@ var TasksApi = class {
       duplicates: typeof body?.duplicates === "number" ? body.duplicates : 0
     };
   }
+  /**
+   * Uma página dos ids já concluídos neste trabalho (`items.each` pula). Retry em falha
+   * de rede/5xx; 4xx é definitivo (404 = servidor sem o recurso).
+   */
+  async listDoneItems(runId, request) {
+    let response;
+    try {
+      response = await fetchWithRetry(
+        () => fetch(`${this.baseUrl}/${encodeURIComponent(runId)}/items/done`, {
+          redirect: "error",
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify(request),
+          signal: AbortSignal.timeout(UPDATE_TIMEOUT_MS)
+        }),
+        { logger: this.logger, label: `itens conclu\xEDdos da run ${runId}` }
+      );
+    } catch (error) {
+      throw new Error(`consulta de itens conclu\xEDdos da run ${runId} descartada ap\xF3s retries: ${String(error)}`);
+    }
+    if (!response.ok) {
+      throw new TasksApiError(`consulta de itens conclu\xEDdos rejeitada (HTTP ${response.status})`, response.status);
+    }
+    const body = await response.json().catch(() => null);
+    if (!Array.isArray(body?.ids)) throw new TasksApiError("consulta de itens conclu\xEDdos: resposta malformada", 0);
+    return {
+      ids: body.ids.map((id) => String(id)),
+      next: typeof body.next === "string" && body.next.length > 0 ? body.next : null
+    };
+  }
   /**
    * Registra o anexo e obtém a URL presignada de upload. 404/501/503 significam
    * "esta instalação não tem anexos" — o RunReporter degrada em silêncio a partir daí.
@@ -1249,6 +1315,20 @@ var Backoff = class {
 };
 
 // src/tasks/errors.ts
+var Occurrence = class extends Error {
+  payload;
+  /** Print do item (bytes/caminho ou `hobots.image(...)`) — o `each` pendura no item. */
+  image;
+  constructor(message, payload, options) {
+    super(message);
+    this.name = "Occurrence";
+    this.payload = payload;
+    this.image = options?.image;
+  }
+};
+function isOccurrence(error) {
+  return error instanceof Error && error.name === "Occurrence";
+}
 function runCanceledError() {
   return Object.assign(new Error("execu\xE7\xE3o cancelada"), { name: "RunCanceled" });
 }
@@ -1265,1507 +1345,1745 @@ function isCancellation(error) {
   return error instanceof Error && (error.name === "RunCanceled" || error.name === "AbortError");
 }
 
-// src/tasks/each.ts
-function thrownMessage(error) {
-  if (error instanceof Error) return error.message || error.name;
-  return safeString(error);
-}
-var ItemHandle = class {
-  constructor(index, id, step, basePayload, sink) {
-    this.index = index;
-    this.id = id;
-    this.step = step;
-    this.basePayload = basePayload;
-    this.sink = sink;
-  }
-  index;
-  id;
-  step;
-  basePayload;
-  sink;
-  reported = false;
-  status;
-  succeeded(payload, options) {
-    this.record("succeeded", void 0, payload, options?.image);
-  }
-  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, options) {
-    this.record("occurrence", message, payload, options?.image);
-    if (this.step && this.step.status === "ok") this.step.setStatus("warning", message);
-  }
-  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, image3);
+// src/tasks/attachments.ts
+var MAX_ATTACHMENT_BYTES = WIRE_LIMITS.MAX_ATTACHMENT_BYTES;
+var MAX_ATTACHMENTS_PER_RUN = WIRE_LIMITS.MAX_ATTACHMENTS_PER_RUN;
+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 resolveId(options, element, index) {
-  const raw = options.id?.(element, index);
-  if (raw === null || raw === void 0) return void 0;
-  const text = safeString(raw);
-  return text.length > 0 ? text : void 0;
+function image(input, options = {}) {
+  return new ImageAttachment(input, options.caption, options.contentType);
 }
-function knownLength(list) {
-  const length = list?.length;
-  return typeof length === "number" && Number.isInteger(length) && length >= 1 ? length : void 0;
+function isImageAttachment(value) {
+  return typeof value === "object" && value !== null && value[IMAGE_BRAND] === true;
 }
-async function eachItem(list, handler, options, sink) {
-  const result = { total: 0, succeeded: 0, failed: 0, occurrence: 0 };
-  const length = options.progress === false ? void 0 : knownLength(list);
-  if (length !== void 0) sink.declareTotal(length);
-  let index = 0;
-  for await (const element of list) {
-    sink.checkCanceled();
-    const id = resolveId(options, element, index);
-    const description = options.description?.(element, index) ?? id ?? `#${index + 1}`;
-    const step = sink.startStep(options.op ?? "item", description);
-    const handle = new ItemHandle(index, id, step, options.payload?.(element, index), sink);
-    try {
-      await handler(element, handle, index);
-      if (!handle.reported) handle.succeeded();
-    } catch (error) {
-      if (isTerminalError(error) || sink.isAborted()) {
-        step?.setStatus("cancelled").succeeded();
-        throw error;
-      }
-      const message = thrownMessage(error);
-      if (!handle.reported) handle.failed(message);
-      step?.failed(error);
-      sink.logError(`item ${description} falhou: ${message}`);
-    }
-    step?.succeeded();
-    if (options.progress !== false) sink.advance();
-    result.total += 1;
-    result[handle.status ?? "succeeded"] += 1;
-    index += 1;
+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");
   }
-  return result;
+  const { readFile } = await import("fs/promises");
+  return new Uint8Array(await readFile(path));
 }
-
-// src/tasks/files.ts
-var LOCAL_FILES_DIR_ENV = "HOBOTS_LOCAL_FILES_DIR";
-var FILE_DOWNLOAD_IDLE_TIMEOUT_MS = 6e4;
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function isFileRef(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const ref = value;
-  return typeof ref.id === "string" && typeof ref.name === "string" && typeof ref.size === "number" && typeof ref.contentType === "string" && (ref.storage === "s3" || ref.storage === "local");
+function startsWith(bytes, signature, offset = 0) {
+  if (bytes.length < offset + signature.length) return false;
+  return signature.every((byte, index) => bytes[offset + index] === byte);
 }
-function fileField(params, field) {
-  if (!Object.prototype.hasOwnProperty.call(params, field)) return void 0;
-  const value = params[field];
-  if (isFileRef(value)) return value;
-  if (Array.isArray(value) && value.every(isFileRef)) return value;
+var PNG_MAGIC = [137, 80, 78, 71, 13, 10, 26, 10];
+var MAX_PNG_DIMENSION = WIRE_LIMITS.MAX_IMAGE_DIMENSION_PX;
+var JPEG_MAGIC = [255, 216, 255];
+var RIFF_MAGIC = [82, 73, 70, 70];
+var WEBP_MAGIC = [87, 69, 66, 80];
+function sniffContentType(bytes) {
+  if (startsWith(bytes, PNG_MAGIC)) return "image/png";
+  if (startsWith(bytes, JPEG_MAGIC)) return "image/jpeg";
+  if (startsWith(bytes, RIFF_MAGIC) && startsWith(bytes, WEBP_MAGIC, 8)) return "image/webp";
   return void 0;
 }
-function collectFileRefs(params) {
-  const refs = [];
-  for (const field of Object.keys(params)) {
-    const value = fileField(params, field);
-    if (value !== void 0) refs.push(...Array.isArray(value) ? value : [value]);
-  }
-  return refs;
+function readPngDimensions(bytes) {
+  if (!startsWith(bytes, PNG_MAGIC) || bytes.length < 24) return void 0;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const width = view.getUint32(16);
+  const height = view.getUint32(20);
+  if (width === 0 || height === 0) return void 0;
+  if (width > MAX_PNG_DIMENSION || height > MAX_PNG_DIMENSION) return void 0;
+  return { width, height };
 }
-function safeFileName(name, fallback) {
-  const cleaned = name.replace(/^.*[\\/]/, "").replace(/[\u0000-\u001f<>:"|?*]/g, "_").trim();
-  return cleaned === "" || cleaned === "." || cleaned === ".." ? fallback : cleaned;
+async function toBytes(input) {
+  if (typeof input === "string") return readImageFile(input);
+  if (input instanceof Uint8Array) return input;
+  return new Uint8Array(input);
 }
-function isInsideDir(root, candidate, sep) {
-  const base = root.endsWith(sep) ? root : root + sep;
-  return candidate.startsWith(base) && candidate.length > base.length;
+
+// src/tasks/run-context-store.ts
+var storage;
+var stepStorage;
+var initPromise;
+async function ensureStorage() {
+  if (storage || !isNode()) return;
+  initPromise ??= import("async_hooks").then(({ AsyncLocalStorage: ALS }) => {
+    storage = new ALS();
+    stepStorage = new ALS();
+  });
+  await initPromise;
 }
-function unavailableLocal(ref) {
-  return new Error(`arquivo "${ref.name}" enviado pelo Studio de outro computador ou j\xE1 consumido`);
+async function runWithRunContext(store, fn) {
+  await ensureStorage();
+  return storage ? storage.run(store, fn) : fn();
 }
-function errorCode(error) {
-  return error?.code;
+function currentRunReporter() {
+  return storage?.getStore()?.reporter;
 }
-var RunFileStore = class {
-  constructor(deps) {
-    this.deps = deps;
-    this.files = {
-      list: () => collectFileRefs(deps.params),
-      get: (field) => fileField(deps.params, field),
-      // async: erro de uso (campo sem arquivo, valor inválido) chega como Promise rejeitada, nunca síncrono
-      download: async (refOrField, options) => this.download(this.single(refOrField), options?.dest),
-      downloadAll: async (field, options) => this.downloadAll(field, options?.dest),
-      read: async (refOrField) => this.read(this.single(refOrField))
-    };
-  }
-  deps;
-  files;
-  tempDir;
-  /** Apaga a pasta temporária da execução (cópias que o bot não levou para `dest`). Nunca lança. */
-  async cleanup() {
-    const pending = this.tempDir;
-    this.tempDir = void 0;
-    if (!pending) return;
+async function runWithStepScope(scope, fn) {
+  await ensureStorage();
+  return stepStorage ? stepStorage.run(scope, fn) : fn();
+}
+function currentStep(transaction) {
+  const scope = stepStorage?.getStore();
+  return scope?.transaction === transaction ? scope.step : void 0;
+}
+
+// src/retry.ts
+var DEFAULT_RETRIES = 3;
+var DEFAULT_DELAY_MS = 1e3;
+function resolveDelay(delay, attempt, fallbackMs) {
+  const value = typeof delay === "function" ? delay(attempt) : delay ?? fallbackMs;
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+async function retryWithBackoff(fn, options = {}) {
+  const requested = options.retries ?? DEFAULT_RETRIES;
+  const retries = Number.isFinite(requested) ? Math.max(0, Math.floor(requested)) : DEFAULT_RETRIES;
+  const wait = options.wait ?? sleep;
+  for (let attempt = 1; ; attempt++) {
+    if (options.signal?.aborted) throw runCanceledError();
     try {
-      const { rm } = await import("fs/promises");
-      await rm(await pending, { recursive: true, force: true });
-    } catch {
-    }
-  }
-  field(field) {
-    const value = fileField(this.deps.params, field);
-    if (value === void 0) throw new Error(`campo "${field}" n\xE3o tem arquivo nos params`);
-    return value;
-  }
-  single(refOrField) {
-    if (typeof refOrField === "string") {
-      const value = this.field(refOrField);
-      if (Array.isArray(value)) {
-        throw new Error(`campo "${refOrField}" tem v\xE1rios arquivos \u2014 use downloadAll("${refOrField}") ou passe um item da lista`);
-      }
-      return value;
+      return await fn(attempt);
+    } catch (error) {
+      const exhausted = attempt > retries;
+      const retriable = !isTerminalError(error) && !options.signal?.aborted && (options.shouldRetry?.(error) ?? true);
+      if (exhausted || !retriable) throw error;
+      const delay = resolveDelay(options.delayMs, attempt, DEFAULT_DELAY_MS);
+      options.onRetry?.(error, attempt, delay);
+      await wait(delay);
     }
-    if (!isFileRef(refOrField)) throw new TypeError("esperado um FileRef ou o nome de um campo de arquivo");
-    return refOrField;
-  }
-  async downloadAll(field, dest) {
-    const value = this.field(field);
-    const refs = Array.isArray(value) ? value : [value];
-    const paths = [];
-    for (const ref of refs) paths.push(await this.download(ref, dest, true));
-    return paths;
   }
-  async read(ref) {
-    const { readFile, rm } = await import("fs/promises");
-    const { dirname } = await import("path");
-    const path = await this.download(ref, void 0);
-    try {
-      return await readFile(path);
-    } finally {
-      await rm(dirname(path), { recursive: true, force: true });
-    }
+}
+
+// src/transaction.ts
+var FLUSH_TRANSACTION_OP = "hobots.run.flush";
+var DEFAULT_STEP_RETRIES = 1;
+var DEFAULT_STEP_RETRY_DELAY_MS = 5e3;
+var MAX_STEP_MESSAGE_CHARS = 2e3;
+var MAX_BACKLOG = 100;
+function stepMessage(text) {
+  return clip(scrubSecrets(text), MAX_STEP_MESSAGE_CHARS);
+}
+function stepId() {
+  return uuid4().slice(0, 16);
+}
+function stepLabel(op, description) {
+  return [op, description].filter(Boolean).join(" \u2014 ") || "(sem nome)";
+}
+function errorText(error) {
+  if (error instanceof Error) return error.message || error.name;
+  return safeString(error);
+}
+function errorReason(error) {
+  return error instanceof Error ? `${error.name}: ${errorText(error)}` : errorText(error);
+}
+function levelForStatus(status) {
+  switch (status) {
+    case "warning":
+      return "warning";
+    case "error":
+      return "error";
+    case "cancelled":
+      return "warning";
+    default:
+      return "success";
   }
-  async download(ref, dest, destIsDir = false) {
-    this.checkCanceled();
-    const target = await this.resolveTarget(ref, dest, destIsDir);
-    if (ref.storage === "local") await this.copyLocal(ref, target);
-    else await this.downloadS3(ref, target);
-    return target;
+}
+function colorForStatus(status) {
+  switch (status) {
+    case "warning":
+      return "yellow";
+    case "error":
+      return "red";
+    case "cancelled":
+      return "gray";
+    default:
+      return "green";
   }
-  checkCanceled() {
-    if (this.deps.signal.aborted) throw runCanceledError();
+}
+var Step = class {
+  constructor(transaction, parentStepId, op, description) {
+    this.transaction = transaction;
+    this.parentStepId = parentStepId;
+    this.op = op;
+    this.description = description;
   }
-  runTempDir() {
-    this.tempDir ??= (async () => {
-      const { mkdtemp } = await import("fs/promises");
-      const { tmpdir } = await import("os");
-      const { join } = await import("path");
-      return mkdtemp(join(tmpdir(), "hobots-files-"));
-    })();
-    return this.tempDir;
+  transaction;
+  parentStepId;
+  op;
+  description;
+  stepId = stepId();
+  startTimestamp = nowISO();
+  status = "ok";
+  endTimestamp;
+  _data;
+  // ── API do bot ────────────────────────────────────────────────────────────
+  warning(message, options) {
+    if (this.status !== "error") this._setStatus("warning", message);
+    if (options?.image !== void 0) this.attachImage(options.image);
+    return this;
   }
-  async resolveTarget(ref, dest, destIsDir) {
-    const { mkdir, mkdtemp, stat } = await import("fs/promises");
-    const { dirname, join, resolve: resolve2 } = await import("path");
-    const name = safeFileName(ref.name, "arquivo");
-    if (dest === void 0) {
-      return join(await mkdtemp(join(await this.runTempDir(), "f-")), name);
-    }
-    const isDir = destIsDir || dest.endsWith("/") || dest.endsWith("\\") || (await stat(dest).catch(() => void 0))?.isDirectory() === true;
-    if (isDir) {
-      await mkdir(dest, { recursive: true });
-      return resolve2(dest, name);
+  image(image3) {
+    this.attachImage(image3);
+    return this;
+  }
+  data(key, value) {
+    if (key === "attachments") return this;
+    this._setData(key, value);
+    return this;
+  }
+  // ── Internos (chamados pelo SDK) ──────────────────────────────────────────
+  /** `data` da etapa como vai no wire (undefined quando vazio). */
+  get payload() {
+    return this._data;
+  }
+  _setStatus(status, message) {
+    this.status = status;
+    if (message) this._setData("message", stepMessage(safeString(message)));
+    return this;
+  }
+  /**
+   * Marca `error` guardando `{ type, message }` em `data.error` e fecha a etapa. Aceita qualquer
+   * valor lançado; `message` sobrescreve a mensagem do erro. Numa etapa já fechada não faz nada.
+   */
+  _failed(error, message) {
+    if (this.endTimestamp) return this;
+    this.status = "error";
+    const type = error instanceof Error ? error.name : typeof error === "object" && error !== null ? "Error" : void 0;
+    const raw = message ?? errorText(error);
+    this._setData("error", { ...type ? { type } : {}, message: stepMessage(safeString(raw)) });
+    this._close();
+    return this;
+  }
+  _setData(key, value) {
+    this._data = { ...this._data, [key]: value };
+  }
+  _deleteData(key) {
+    if (!this._data || !(key in this._data)) return;
+    const rest = { ...this._data };
+    delete rest[key];
+    this._data = Object.keys(rest).length > 0 ? rest : void 0;
+  }
+  /**
+   * 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 (warning/erro) — usado no log de FINISH. */
+  reason() {
+    const error = this._data?.error;
+    const text = typeof error?.message === "string" ? error.message : this._data?.message;
+    return typeof text === "string" && text ? text : void 0;
+  }
+  /** Fecha a etapa mantendo o status que estiver. Idempotente. */
+  _close() {
+    if (this.endTimestamp) return;
+    this.endTimestamp = nowISO();
+    this.transaction.emit(
+      "step",
+      "finish",
+      stepLabel(this.op, this.description),
+      this.startTimestamp,
+      this.endTimestamp,
+      this.status,
+      this.reason()
+    );
+  }
+  toJSON() {
+    return {
+      step_id: this.stepId,
+      ...this.parentStepId ? { parent_step_id: this.parentStepId } : {},
+      ...this.op ? { op: clip(this.op, MAX_STEP_OP_CHARS) } : {},
+      ...this.description ? { description: clip(this.description, MAX_STEP_DESCRIPTION_CHARS) } : {},
+      status: this.status,
+      start_timestamp: this.startTimestamp,
+      timestamp: this.endTimestamp ?? nowISO(),
+      ...this._data ? { data: this._data } : {}
+    };
+  }
+};
+var Transaction = class {
+  constructor(client, name, op, runId, options = {}) {
+    this.client = client;
+    this.name = name;
+    this.op = op;
+    this.runId = runId;
+    this.echo = options.echo ?? false;
+    this.emit("transaction", "start", op ? `${name} (${op})` : name);
+  }
+  client;
+  name;
+  op;
+  runId;
+  eventId = uuid4();
+  stepId = stepId();
+  startTimestamp = nowISO();
+  status = "ok";
+  steps = [];
+  finished = false;
+  lifecycleSink;
+  attachmentSink;
+  warnedNoAttachmentSink = false;
+  // instalado pelo RunReporter: abrir uma etapa é um ponto de parada cooperativo (lança RunCanceled)
+  stepGuard;
+  // modo local (sem client): o FINISH de cada etapa sai no terminal, como `[hobots:item]`
+  echo;
+  // eventos emitidos antes do sink existir (o START da transaction sai no construtor,
+  // antes do RunReporter conectar) — replay no setLifecycleSink
+  lifecycleBacklog = [];
+  // ── Lifecycle / eco ───────────────────────────────────────────────────────
+  /**
+   * Registra o início/fim de uma etapa ou da transaction: espelha a linha no sink de
+   * lifecycle, se conectado (é assim que os eventos de performance aparecem nos logs da
+   * run no app), e ecoa no terminal com `debug: true` — ou, no modo local, só o FINISH das
+   * etapas (`[hobots:step] FINISH …`), para o Studio e o dev verem.
+   */
+  emit(kind, phase, label, startTs, endTs, status, reason) {
+    const durationMs = startTs && endTs ? new Date(endTs).getTime() - new Date(startTs).getTime() : void 0;
+    const suffix = (durationMs != null ? ` (${durationMs}ms)` : "") + (reason ? `: ${reason}` : "");
+    const localFinish = this.echo && kind === "step" && phase === "finish";
+    if (this.client?.debug || localFinish) {
+      const tag = colorize(`[hobots:${kind}] ${phase.toUpperCase()}`, phase === "finish" ? colorForStatus(status ?? "ok") : "cyan");
+      console.log(`${tag} ${label}${suffix}`);
     }
-    await mkdir(dirname(resolve2(dest)), { recursive: true });
-    return resolve2(dest);
+    const level = phase === "finish" ? levelForStatus(status ?? "ok") : "info";
+    const message = `[${kind}] ${phase.toUpperCase()} ${label}${suffix}`;
+    if (this.lifecycleSink) this.lifecycleSink(level, message);
+    else if (this.lifecycleBacklog.length < MAX_BACKLOG) this.lifecycleBacklog.push([level, message]);
   }
-  /** storage 's3': URL pré-assinada → GET em streaming → confere o tamanho → só então DELETE. */
-  async downloadS3(ref, target) {
-    const { api, runId, signal } = this.deps;
-    let expected;
-    let url;
-    try {
-      const info = await api.requestFileDownload(runId, ref.id, signal);
-      expected = info.size >= 0 ? info.size : ref.size;
-      url = info.url;
-    } catch (error) {
-      throw this.translate(error, ref);
+  /** Conecta o espelho de lifecycle (RunReporter) e faz replay do backlog em ordem. */
+  setLifecycleSink(sink) {
+    this.lifecycleSink = sink;
+    const backlog = this.lifecycleBacklog;
+    this.lifecycleBacklog = [];
+    for (const [level, message] of backlog) sink(level, message);
+  }
+  /** Conecta o pipeline de anexos da run — é o que dá imagem às etapas. */
+  setAttachmentSink(sink) {
+    this.attachmentSink = sink;
+  }
+  /** Imagem de uma etapa → 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 etapa descartada \u2014 s\xF3 \xE9 suportada dentro de uma execu\xE7\xE3o");
     }
-    const { open, rename, rm } = await import("fs/promises");
-    const part = `${target}.part`;
-    const idleTimeoutMs = this.deps.idleTimeoutMs ?? FILE_DOWNLOAD_IDLE_TIMEOUT_MS;
-    const controller = new AbortController();
-    let timedOut = false;
-    let timer;
-    const arm = () => {
-      clearTimeout(timer);
-      timer = setTimeout(() => {
-        timedOut = true;
-        controller.abort();
-      }, idleTimeoutMs);
-    };
-    const onCancel = () => controller.abort();
-    signal.addEventListener("abort", onCancel, { once: true });
+    return void 0;
+  }
+  // ── Etapas ────────────────────────────────────────────────────────────────
+  /**
+   * Conecta a checagem de cancelamento chamada antes de cada etapa nova (inclusive antes de
+   * cada nova tentativa) — é assim que `hobots.step()` para uma run cancelada.
+   */
+  setStepGuard(guard) {
+    this.stepGuard = guard;
+  }
+  /** A etapa aberta por `step()` (ou `items.each`) no contexto async atual, se houver. */
+  currentStep() {
+    return currentStep(this);
+  }
+  /** Faz de `step` a etapa corrente durante `fn` (filhas aninham nela). Sem etapa, só roda `fn`. */
+  scope(step, fn) {
+    if (!step) return fn();
+    return runWithStepScope({ transaction: this, step }, fn);
+  }
+  /** Abre uma etapa sob a corrente (ou direta da transaction). Interno: o bot usa `step()`. */
+  start(op, description) {
+    this.stepGuard?.();
+    const parent = this.currentStep();
+    const step = new Step(this, parent ? parent.stepId : this.stepId, op, description);
+    this.steps.push(step);
+    this.emit("step", "start", stepLabel(op, description));
+    return step;
+  }
+  /**
+   * Registra a etapa `name` executando `fn(etapa)` até dar certo ou esgotar `retries`
+   * tentativas extras (default 1), esperando `retryDelayMs` entre elas (default 5 000).
+   * Resolve com o retorno de `fn`.
+   *
+   * Uma etapa só no waterfall, cobrindo todas as tentativas: `data.attempts` quando houve
+   * mais de uma; `warning` com o motivo quando a última deu certo; `error` (e a exceção
+   * sobe) quando esgotou; `cancelled` em cancelamento/timeout, que nunca repetem.
+   */
+  async step(name, fn, options = {}) {
+    const requested = options.retries ?? DEFAULT_STEP_RETRIES;
+    const totalRetries = Number.isFinite(requested) ? Math.max(0, Math.floor(requested)) : DEFAULT_STEP_RETRIES;
+    const step = this.start(void 0, safeString(name));
+    let attempts = 0;
+    let lastFailure;
     try {
-      arm();
-      const response = await api.fetchFile(url, controller.signal);
-      const handle = await open(part, "w");
-      let written = 0;
-      try {
-        const reader = response.body?.getReader();
-        const stopReading = () => void reader?.cancel().catch(() => void 0);
-        controller.signal.addEventListener("abort", stopReading, { once: true });
-        for (; ; ) {
-          const chunk = reader ? await reader.read() : { done: true, value: void 0 };
-          if (chunk.done) break;
-          arm();
-          written += chunk.value.byteLength;
-          if (written > expected) {
-            stopReading();
-            break;
+      const result = await retryWithBackoff(
+        (attempt) => {
+          attempts = attempt;
+          return this.scope(step, async () => fn(step));
+        },
+        {
+          retries: totalRetries,
+          delayMs: (attempt) => resolveDelay(options.retryDelayMs, attempt, DEFAULT_STEP_RETRY_DELAY_MS),
+          signal: options.signal,
+          wait: options.wait,
+          onRetry: (error, attempt, delayMs) => {
+            lastFailure = { error };
+            options.warn?.(
+              `etapa "${step.description}": tentativa ${attempt}/${totalRetries + 1} falhou: ${truncate(errorReason(error), 500)} \u2014 nova tentativa em ${delayMs}ms`
+            );
           }
-          await handle.write(chunk.value);
         }
-      } finally {
-        await handle.close();
-      }
-      if (written !== expected) {
-        throw new Error(`tamanho divergente no download de "${ref.name}": recebidos ${written} bytes, esperados ${expected}`);
+      );
+      this.noteAttempts(step, attempts);
+      if (lastFailure && step.status === "ok") {
+        step._setStatus("warning", `tentativa ${attempts - 1}/${totalRetries + 1} falhou: ${errorReason(lastFailure.error)}`);
       }
-      await rename(part, target);
-    } catch (error) {
-      await rm(part, { force: true });
-      if (signal.aborted) throw runCanceledError();
-      if (timedOut) {
-        throw new Error(`download de "${ref.name}" parado h\xE1 ${idleTimeoutMs / 1e3}s \u2014 tente de novo`);
-      }
-      throw this.translate(error, ref);
-    } finally {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", onCancel);
-    }
-    try {
-      await api.confirmFileDownload(runId, ref.id);
+      step._close();
+      return result;
     } catch (error) {
-      this.deps.warn(`arquivo "${ref.name}" baixado, mas a confirma\xE7\xE3o ao servidor falhou: ${String(error)}`);
+      this.noteAttempts(step, attempts);
+      if (isTerminalError(error)) step._setStatus("cancelled")._close();
+      else step._failed(error);
+      throw error;
     }
   }
-  /** storage 'local': copia o único arquivo de `$HOBOTS_LOCAL_FILES_DIR/<id>/` e apaga a pasta de origem. */
-  async copyLocal(ref, target) {
-    const base = process.env[LOCAL_FILES_DIR_ENV];
-    if (!base) throw unavailableLocal(ref);
-    const { copyFile, readdir, rename, rm, stat } = await import("fs/promises");
-    const { join, resolve: resolve2, sep } = await import("path");
-    const root = resolve2(base);
-    const folder = resolve2(root, ref.id);
-    if (!isInsideDir(root, folder, sep) || !UUID_RE.test(ref.id)) {
-      throw new Error(`id de arquivo local inv\xE1lido: ${JSON.stringify(ref.id)}`);
-    }
-    let names;
-    try {
-      names = (await readdir(folder, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name);
-    } catch (error) {
-      if (errorCode(error) === "ENOENT" || errorCode(error) === "ENOTDIR") throw unavailableLocal(ref);
-      throw error;
+  noteAttempts(step, attempts) {
+    if (attempts > 1) step._setData("attempts", attempts);
+  }
+  // ── Metadados ─────────────────────────────────────────────────────────────
+  setStatus(status) {
+    this.status = status;
+    return this;
+  }
+  // ── Encerramento ──────────────────────────────────────────────────────────
+  /**
+   * Envia já as etapas raiz finalizadas (e todas as descendentes, fechando as que
+   * ficaram abertas) como transactions parciais da mesma run (`op` hobots.run.flush,
+   * `event_id` novo, até 200 etapas cada) e as tira da memória. Etapas raiz ainda abertas
+   * ficam para o próximo flush ou para o `finish()`. É assim que um agente sempre
+   * ligado (`start()`), cuja run não termina, entrega as etapas enquanto processa.
+   * Devolve quantas etapas foram enviadas (0 sem client, sem nada terminado ou depois do `finish()`).
+   */
+  flush() {
+    if (!this.client || this.finished) return 0;
+    const ready = /* @__PURE__ */ new Set();
+    for (const step of this.steps) {
+      if (step.parentStepId === this.stepId && step.endTimestamp) ready.add(step.stepId);
     }
-    if (names.length === 0) throw unavailableLocal(ref);
-    if (names.length > 1) throw new Error(`pasta do arquivo "${ref.name}" tem ${names.length} arquivos \u2014 esperado 1`);
-    this.checkCanceled();
-    const part = `${target}.part`;
-    try {
-      await copyFile(join(folder, names[0]), part);
-      const { size } = await stat(part);
-      if (size !== ref.size) {
-        throw new Error(`tamanho divergente na c\xF3pia de "${ref.name}": copiados ${size} bytes, esperados ${ref.size}`);
+    if (ready.size === 0) return 0;
+    const batch = [];
+    const remaining = [];
+    for (const step of this.steps) {
+      if (ready.has(step.stepId) || ready.has(step.parentStepId)) {
+        ready.add(step.stepId);
+        batch.push(step);
+      } else {
+        remaining.push(step);
       }
-      await rename(part, target);
-    } catch (error) {
-      await rm(part, { force: true });
-      throw error;
     }
-    await rm(folder, { recursive: true, force: true });
-  }
-  translate(error, ref) {
-    if (this.deps.signal.aborted) return runCanceledError();
-    if (error instanceof TasksApiError && error.status === 410) {
-      return new TasksApiError(`arquivo "${ref.name}" j\xE1 baixado ou expirado`, 410);
+    for (const step of batch) step._close();
+    this.steps.splice(0, this.steps.length, ...remaining);
+    for (let i = 0; i < batch.length; i += MAX_STEPS) {
+      const chunk = batch.slice(i, i + MAX_STEPS);
+      const startTimestamp = chunk.reduce((min, step) => step.startTimestamp < min ? step.startTimestamp : min, chunk[0].startTimestamp);
+      const status = chunk.some((step) => step.status === "error") ? "error" : "ok";
+      this.client.sendTransaction(this.payload(uuid4(), FLUSH_TRANSACTION_OP, status, startTimestamp, nowISO(), chunk));
     }
-    if (error instanceof TasksApiError && error.status === 404) {
-      return new TasksApiError(`arquivo "${ref.name}" n\xE3o encontrado nesta execu\xE7\xE3o`, 404);
+    return batch.length;
+  }
+  /** Entrega já (com teto) o que está na fila do transport — as transactions parciais inclusive. */
+  async drain(timeoutMs) {
+    await this.client?.flush(timeoutMs);
+  }
+  payload(eventId, op, status, startTimestamp, timestamp, steps) {
+    return {
+      event_id: eventId,
+      name: this.name,
+      op,
+      status,
+      start_timestamp: startTimestamp,
+      timestamp,
+      steps: steps.map((step) => step.toJSON()),
+      // sem tags próprias: o client mescla as do processo
+      tags: void 0,
+      run_id: this.runId
+    };
+  }
+  finish() {
+    if (this.finished) return;
+    this.finished = true;
+    for (const step of this.steps) step._close();
+    const endTimestamp = nowISO();
+    this.emit(
+      "transaction",
+      "finish",
+      this.op ? `${this.name} (${this.op})` : this.name,
+      this.startTimestamp,
+      endTimestamp,
+      this.status
+    );
+    if (!this.client) return;
+    const steps = this.steps;
+    let first = 0;
+    while (steps.length - first > MAX_STEPS) {
+      const chunk = steps.slice(first, first + MAX_STEPS);
+      const status = chunk.some((step) => step.status === "error") ? "error" : "ok";
+      this.client.sendTransaction(this.payload(uuid4(), FLUSH_TRANSACTION_OP, status, chunk[0].startTimestamp, endTimestamp, chunk));
+      first += MAX_STEPS;
     }
-    return error;
+    this.client.sendTransaction(this.payload(this.eventId, this.op, this.status, this.startTimestamp, endTimestamp, steps.slice(first)));
   }
 };
 
-// src/retry.ts
-var DEFAULT_RETRIES = 3;
-var DEFAULT_DELAY_MS = 1e3;
-function resolveDelay(delay, attempt, fallbackMs) {
-  const value = typeof delay === "function" ? delay(attempt) : delay ?? fallbackMs;
-  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+// src/tasks/each.ts
+var DEFAULT_ITEM_ID_FIELD = "id";
+var DEFAULT_EACH_RETRIES = 1;
+var ID_SEPARATOR = "|";
+function thrownMessage(error) {
+  if (error instanceof Error) return error.message || error.name;
+  return safeString(error);
 }
-async function retryWithBackoff(fn, options = {}) {
-  const requested = options.retries ?? DEFAULT_RETRIES;
-  const retries = Number.isFinite(requested) ? Math.max(0, Math.floor(requested)) : DEFAULT_RETRIES;
-  const wait = options.wait ?? sleep;
-  for (let attempt = 1; ; attempt++) {
-    if (options.signal?.aborted) throw runCanceledError();
-    try {
-      return await fn(attempt);
-    } catch (error) {
-      const exhausted = attempt > retries;
-      const retriable = !isTerminalError(error) && !options.signal?.aborted && (options.shouldRetry?.(error) ?? true);
-      if (exhausted || !retriable) throw error;
-      const delay = resolveDelay(options.delayMs, attempt, DEFAULT_DELAY_MS);
-      options.onRetry?.(error, attempt, delay);
-      await wait(delay);
+var ItemHandle = class {
+  constructor(index, id, step, basePayload, sink) {
+    this.index = index;
+    this.step = step;
+    this.basePayload = basePayload;
+    this.sink = sink;
+    this.id = id ?? uuid4();
+  }
+  index;
+  step;
+  basePayload;
+  sink;
+  /** A identidade resolvida por `options.id` ou, sem ela, uma gerada — a mesma em todas as tentativas. */
+  id;
+  reported = false;
+  status;
+  attempt = 1;
+  succeeded(payload, options) {
+    this.record("succeeded", void 0, payload, options?.image);
+  }
+  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, options) {
+    this.record("occurrence", message, payload, options?.image);
+    if (this.step && this.step.status === "ok") this.step._setStatus("warning", message);
+  }
+  /** Nova tentativa: o desfecho da anterior não vale (o id é o mesmo, o último reporte vence). */
+  _nextAttempt(attempt) {
+    this.attempt = attempt;
+    this.reported = false;
+    this.status = void 0;
+    if (this.step && (this.step.status === "error" || this.step.status === "warning")) {
+      this.step._setStatus("ok");
+      this.step._deleteData("message");
     }
   }
-}
-
-// src/tasks/attachments.ts
-var MAX_ATTACHMENT_BYTES = WIRE_LIMITS.MAX_ATTACHMENT_BYTES;
-var MAX_ATTACHMENTS_PER_RUN = WIRE_LIMITS.MAX_ATTACHMENTS_PER_RUN;
-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;
+  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, image3);
   }
-  input;
-  caption;
-  contentType;
-  [IMAGE_BRAND] = true;
 };
-function image(input, options = {}) {
-  return new ImageAttachment(input, options.caption, options.contentType);
+function field(element, name) {
+  if (typeof element !== "object" || element === null) return { present: false, value: void 0 };
+  const record = element;
+  return { present: name in record, value: record[name] };
 }
-function isImageAttachment(value) {
-  return typeof value === "object" && value !== null && value[IMAGE_BRAND] === true;
+function resolveId(spec, element, index, explicit) {
+  if (spec === null) return void 0;
+  let raw;
+  if (typeof spec === "function") {
+    raw = spec(element, index);
+  } else {
+    const fields = spec === void 0 ? [DEFAULT_ITEM_ID_FIELD] : typeof spec === "string" ? [spec] : spec;
+    const parts = [];
+    for (const name of fields) {
+      const { present, value } = field(element, name);
+      if (!present || value === null || value === void 0) {
+        if (explicit) {
+          throw new Error(
+            `items.each: elemento #${index + 1} n\xE3o tem o campo "${name}" informado em id \u2014 passe o nome certo, uma lista de campos ou uma fun\xE7\xE3o (elemento, \xEDndice) => id`
+          );
+        }
+        return void 0;
+      }
+      parts.push(safeString(value));
+    }
+    raw = parts.join(ID_SEPARATOR);
+  }
+  if (raw === null || raw === void 0) return void 0;
+  const text = safeString(raw);
+  return text.length > 0 ? text : void 0;
 }
-function toImageAttachment(value) {
-  return isImageAttachment(value) ? value : new ImageAttachment(value);
+function knownLength(list) {
+  const length = list?.length;
+  return typeof length === "number" && Number.isInteger(length) && length >= 1 ? length : void 0;
 }
-async function readImageFile(path) {
-  if (!isNode()) {
-    throw new Error("caminho de arquivo s\xF3 \xE9 suportado em Node");
+function skippedMessage(count) {
+  if (count === 1) return "1 item pulado: j\xE1 conclu\xEDdo neste trabalho numa execu\xE7\xE3o anterior";
+  return `${count} itens pulados: j\xE1 conclu\xEDdos neste trabalho numa execu\xE7\xE3o anterior`;
+}
+async function eachItem(list, handler, options, sink) {
+  const result = { total: 0, succeeded: 0, failed: 0, occurrence: 0, skipped: 0 };
+  const requested = options.retries ?? DEFAULT_EACH_RETRIES;
+  const totalRetries = Number.isFinite(requested) ? Math.max(0, Math.floor(requested)) : DEFAULT_EACH_RETRIES;
+  const explicitId = options.id !== void 0;
+  const length = options.progress === false ? void 0 : knownLength(list);
+  if (length !== void 0) sink.declareTotal(length);
+  const done = options.skipDone === false ? void 0 : await sink.doneItemIds();
+  let index = 0;
+  for await (const element of list) {
+    sink.checkCanceled();
+    const id = resolveId(options.id, element, index, explicitId);
+    if (done?.size && id !== void 0 && done.has(id)) {
+      result.total += 1;
+      result.skipped += 1;
+      if (options.progress !== false) sink.advance();
+      index += 1;
+      continue;
+    }
+    const description = options.description?.(element, index) ?? id ?? `#${index + 1}`;
+    const step = sink.startStep(options.op ?? "item", description);
+    const handle = new ItemHandle(index, id, step, options.payload?.(element, index), sink);
+    const current = index;
+    let attempts = 0;
+    let lastFailure;
+    try {
+      await retryWithBackoff(
+        (attempt) => {
+          attempts = attempt;
+          if (attempt > 1) handle._nextAttempt(attempt);
+          return sink.stepScope(step, async () => handler(element, handle, current));
+        },
+        {
+          retries: totalRetries,
+          delayMs: (attempt) => resolveDelay(options.retryDelayMs, attempt, DEFAULT_STEP_RETRY_DELAY_MS),
+          // sem nova tentativa: ocorrência (regra de negócio), desfecho já registrado pelo
+          // handler (ele decidiu) ou run abortada (o erro é efeito do cancelamento)
+          shouldRetry: (error) => !isOccurrence(error) && !handle.reported && !sink.isAborted(),
+          wait: (ms) => sink.sleep(ms),
+          onRetry: (error, attempt, delayMs) => {
+            lastFailure = { error };
+            sink.logWarning(
+              `item ${description}: tentativa ${attempt}/${totalRetries + 1} falhou: ${truncate(errorReason(error), 500)} \u2014 nova tentativa em ${delayMs}ms`
+            );
+          }
+        }
+      );
+      if (!handle.reported) handle.succeeded();
+      if (step) {
+        noteAttempts(step, attempts);
+        if (lastFailure && step.status === "ok") {
+          step._setStatus("warning", `tentativa ${attempts - 1}/${totalRetries + 1} falhou: ${errorReason(lastFailure.error)}`);
+        }
+      }
+    } catch (error) {
+      if (isTerminalError(error) || sink.isAborted()) {
+        step?._setStatus("cancelled")._close();
+        throw error;
+      }
+      if (step) noteAttempts(step, attempts);
+      if (isOccurrence(error)) {
+        const occurrence = error;
+        if (!handle.reported) handle.occurrence(occurrence.message, occurrence.payload, { image: occurrence.image });
+      } else {
+        const message = thrownMessage(error);
+        if (!handle.reported) handle.failed(message);
+        step?._failed(error);
+        sink.logError(`item ${description} falhou: ${message}`);
+      }
+    }
+    step?._close();
+    if (options.progress !== false) sink.advance();
+    result.total += 1;
+    result[handle.status ?? "succeeded"] += 1;
+    index += 1;
+    if (options.flush !== false) await sink.flush();
   }
-  const { readFile } = await import("fs/promises");
-  return new Uint8Array(await readFile(path));
+  if (result.skipped > 0) sink.logInfo(skippedMessage(result.skipped));
+  return result;
 }
-function startsWith(bytes, signature, offset = 0) {
-  if (bytes.length < offset + signature.length) return false;
-  return signature.every((byte, index) => bytes[offset + index] === byte);
+function noteAttempts(step, attempts) {
+  if (attempts > 1) step._setData("attempts", attempts);
 }
-var PNG_MAGIC = [137, 80, 78, 71, 13, 10, 26, 10];
-var MAX_PNG_DIMENSION = WIRE_LIMITS.MAX_IMAGE_DIMENSION_PX;
-var JPEG_MAGIC = [255, 216, 255];
-var RIFF_MAGIC = [82, 73, 70, 70];
-var WEBP_MAGIC = [87, 69, 66, 80];
-function sniffContentType(bytes) {
-  if (startsWith(bytes, PNG_MAGIC)) return "image/png";
-  if (startsWith(bytes, JPEG_MAGIC)) return "image/jpeg";
-  if (startsWith(bytes, RIFF_MAGIC) && startsWith(bytes, WEBP_MAGIC, 8)) return "image/webp";
-  return void 0;
+
+// src/tasks/files.ts
+var LOCAL_FILES_DIR_ENV = "HOBOTS_LOCAL_FILES_DIR";
+var FILE_DOWNLOAD_IDLE_TIMEOUT_MS = 6e4;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isFileRef(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const ref = value;
+  return typeof ref.id === "string" && typeof ref.name === "string" && typeof ref.size === "number" && typeof ref.contentType === "string" && (ref.storage === "s3" || ref.storage === "local");
 }
-function readPngDimensions(bytes) {
-  if (!startsWith(bytes, PNG_MAGIC) || bytes.length < 24) return void 0;
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const width = view.getUint32(16);
-  const height = view.getUint32(20);
-  if (width === 0 || height === 0) return void 0;
-  if (width > MAX_PNG_DIMENSION || height > MAX_PNG_DIMENSION) return void 0;
-  return { width, height };
+function fileField(params, field2) {
+  if (!Object.prototype.hasOwnProperty.call(params, field2)) return void 0;
+  const value = params[field2];
+  if (isFileRef(value)) return value;
+  if (Array.isArray(value) && value.every(isFileRef)) return value;
+  return void 0;
 }
-async function toBytes(input) {
-  if (typeof input === "string") return readImageFile(input);
-  if (input instanceof Uint8Array) return input;
-  return new Uint8Array(input);
+function collectFileRefs(params) {
+  const refs = [];
+  for (const field2 of Object.keys(params)) {
+    const value = fileField(params, field2);
+    if (value !== void 0) refs.push(...Array.isArray(value) ? value : [value]);
+  }
+  return refs;
 }
-
-// src/tasks/context.ts
-var LOG_LEVEL_COLOR = {
-  debug: "gray",
-  info: "cyan",
-  warning: "yellow",
-  error: "red",
-  success: "green"
-};
-function joinLogArgs(message, rest) {
-  if (rest.length === 0) return safeString(message);
-  return [message, ...rest].map(safeString).join(" ");
+function safeFileName(name, fallback) {
+  const cleaned = name.replace(/^.*[\\/]/, "").replace(/[\u0000-\u001f<>:"|?*]/g, "_").trim();
+  return cleaned === "" || cleaned === "." || cleaned === ".." ? fallback : cleaned;
 }
-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 isInsideDir(root, candidate, sep) {
+  const base = root.endsWith(sep) ? root : root + sep;
+  return candidate.startsWith(base) && candidate.length > base.length;
 }
-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);
+function unavailableLocal(ref) {
+  return new Error(`arquivo "${ref.name}" enviado pelo Studio de outro computador ou j\xE1 consumido`);
 }
-function cancelableSleep(ms, signal) {
-  return new Promise((resolve2, reject) => {
-    if (signal.aborted) {
-      reject(runCanceledError());
-      return;
-    }
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(runCanceledError());
-    };
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve2();
-    }, ms);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
+function localRunPath(ref) {
+  if (!isLocalRun()) return void 0;
+  const path = ref.path;
+  return typeof path === "string" && path.trim() !== "" ? path : void 0;
 }
-var DEFAULT_LOG_FLUSH_INTERVAL_MS = 2e3;
-var DEFAULT_CANCEL_CHECK_INTERVAL_MS = 5e3;
-var MIN_CANCEL_CHECK_INTERVAL_MS = 1e3;
-var MAX_CANCEL_CHECK_INTERVAL_MS = 15e3;
-var MAX_LOG_MESSAGE_CHARS = WIRE_LIMITS.MAX_LOG_MESSAGE_CHARS;
-var MAX_LOGS_PER_PATCH = WIRE_LIMITS.MAX_LOGS_PER_PATCH;
-var FLUSH_AT_BUFFERED = 20;
-var MAX_ITEMS_PER_REQUEST = WIRE_LIMITS.MAX_ITEMS_PER_REQUEST;
-var MAX_ITEM_MESSAGE_CHARS = WIRE_LIMITS.MAX_ITEM_MESSAGE_CHARS;
-var MAX_ITEM_PAYLOAD_BYTES = WIRE_LIMITS.MAX_ITEM_PAYLOAD_BYTES;
-var ITEMS_FLUSH_AT_BUFFERED = 100;
-var ITEMS_DRAIN_MS = 15e3;
-var PROGRESS_FLUSH_MS = 1e3;
-function scrubPayloadValue(value, depth) {
-  if (typeof value === "string") return scrubSecrets(value);
-  if (depth >= 4 || value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map((entry) => scrubPayloadValue(entry, depth + 1));
-  const out = {};
-  for (const [key, entry] of Object.entries(value)) {
-    out[key] = scrubPayloadValue(entry, depth + 1);
-  }
-  return out;
+function errorCode(error) {
+  return error?.code;
 }
-var RunReporter = class {
-  constructor(api, runId, logger, tx, flushIntervalMs, cancelCheckIntervalMs, params = {}) {
-    this.api = api;
-    this.runId = runId;
-    this.logger = logger;
-    this.tx = tx;
-    this.flushIntervalMs = flushIntervalMs ?? DEFAULT_LOG_FLUSH_INTERVAL_MS;
-    this.cancelCheckIntervalMs = Math.min(
-      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: 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, image3) => this.addItem(status, message, payload, id, image3),
-      startStep: (op, description) => tx.start(op, description),
-      declareTotal: (total) => {
-        if (this.progressTotal == null) this.setProgress(this.progressCurrent, total);
-      },
-      advance: () => this.setProgress(this.progressCurrent + 1, this.progressTotal),
-      checkCanceled,
-      isAborted: () => this.abortController.signal.aborted,
-      logError: (message) => this.log("error", message)
-    };
-    const items = {
-      add: (item) => {
-        checkCanceled();
-        this.addItem(item.status, item.message, item.payload, item.id, item.image);
-      },
-      succeeded: (payload, options) => {
-        checkCanceled();
-        this.addItem("succeeded", void 0, payload, options?.id, options?.image);
-      },
-      failed: (message, payload, options) => {
-        checkCanceled();
-        this.addItem("failed", message, payload, options?.id, options?.image);
-      },
-      occurrence: (message, payload, options) => {
-        checkCanceled();
-        this.addItem("occurrence", message, payload, options?.id, options?.image);
-      },
-      each: (list, handler, options = {}) => eachItem(list, handler, options, eachSink)
+var RunFileStore = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.files = {
+      list: () => collectFileRefs(deps.params),
+      get: (field2) => fileField(deps.params, field2),
+      // async: erro de uso (campo sem arquivo, valor inválido) chega como Promise rejeitada, nunca síncrono
+      download: async (refOrField, options) => this.download(this.single(refOrField), options?.dest),
+      downloadAll: async (field2, options) => this.downloadAll(field2, options?.dest),
+      read: async (refOrField) => this.read(this.single(refOrField))
     };
-    const progress = Object.defineProperties(
-      {
-        total: (total) => {
-          checkCanceled();
-          this.setProgress(this.progressCurrent, total);
-        },
-        advance: (count = 1) => {
-          checkCanceled();
-          this.setProgress(this.progressCurrent + count, this.progressTotal);
-        },
-        set: (current, total) => {
-          checkCanceled();
-          this.setProgress(current, total ?? this.progressTotal);
-        }
-      },
-      {
-        current: { enumerable: true, get: () => this.progressCurrent },
-        snapshot: {
-          enumerable: true,
-          get: () => this.progressTotal == null ? null : { current: this.progressCurrent, total: this.progressTotal }
-        }
+  }
+  deps;
+  files;
+  tempDir;
+  /** Apaga a pasta temporária da execução (cópias que o bot não levou para `dest`). Nunca lança. */
+  async cleanup() {
+    const pending = this.tempDir;
+    this.tempDir = void 0;
+    if (!pending) return;
+    try {
+      const { rm } = await import("fs/promises");
+      await rm(await pending, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  field(field2) {
+    const value = fileField(this.deps.params, field2);
+    if (value === void 0) throw new Error(`campo "${field2}" n\xE3o tem arquivo nos params`);
+    return value;
+  }
+  single(refOrField) {
+    if (typeof refOrField === "string") {
+      const value = this.field(refOrField);
+      if (Array.isArray(value)) {
+        throw new Error(`campo "${refOrField}" tem v\xE1rios arquivos \u2014 use downloadAll("${refOrField}") ou passe um item da lista`);
       }
-      // defineProperties não tipa os getters adicionados — a interface é a fonte de verdade
-    );
-    const signal = this.abortController.signal;
-    const sleep2 = (ms) => cancelableSleep(ms, signal);
-    this.fileStore = new RunFileStore({ api, runId, params, signal, warn: (message) => this.log("warning", message) });
-    this.context = {
-      runId,
-      params,
-      log,
-      items,
-      progress,
-      files: this.fileStore.files,
-      transaction: tx,
-      flush: (timeoutMs) => this.flush(timeoutMs),
-      signal,
-      throwIfCanceled: checkCanceled,
-      sleep: sleep2,
-      retry: (fn, options) => retryWithBackoff(fn, { ...options, signal, wait: sleep2 })
-    };
+      return value;
+    }
+    if (!isFileRef(refOrField)) throw new TypeError("esperado um FileRef ou o nome de um campo de arquivo");
+    return refOrField;
   }
-  api;
-  runId;
-  logger;
-  tx;
-  context;
-  buffer = [];
-  dead = false;
-  chain = Promise.resolve();
-  pendingUpdates = 0;
-  timer;
-  watchTimer;
-  abortController = new AbortController();
-  flushIntervalMs;
-  cancelCheckIntervalMs;
-  // Itens de execução vivem FORA de `this.chain` (status/liveness não pode ficar
-  // atrás de milhares de itens), mas têm cadeia própria serializada — ordem de
-  // envio preservada e sem lotes sobrepostos.
-  itemsBuffer = [];
-  itemsChain = Promise.resolve();
-  itemsTimer;
-  itemSeq = 0;
-  /** Servidor sem o recurso (404) — para de tentar (e de avisar) nesta run. */
-  itemsUnsupported = false;
-  /**
-   * Cota de itens por run do servidor (429, legado — hoje a api não tem teto de itens) —
-   * degrada com um aviso só.
-   */
-  itemsQuotaExceeded = false;
-  /**
-   * Armazenamento do plano cheio (402 `storage_limit`): o lote é descartado e o aviso sai
-   * uma vez por episódio. Os envios continuam — num agente `start()` o espaço pode ser
-   * liberado (ou o plano trocado) sem reiniciar; um lote aceito rearma o aviso.
-   */
-  itemsStorageFull = false;
-  /**
-   * Só o kill() do exit path fecha os itens — `dead` (run cancelada/finalizada no
-   * servidor) NÃO fecha: o servidor aceita itens de run terminal (trabalho já feito).
-   */
-  itemsClosed = false;
-  // Uploads de anexo vivem FORA de `this.chain`: a cadeia é um FIFO puro de
-  // status/logs e não pode ficar bloqueada esperando um binário subir.
-  pendingAttachments = /* @__PURE__ */ new Set();
-  attachmentCount = 0;
-  uploadSlots = MAX_CONCURRENT_UPLOADS;
-  uploadQueue = [];
-  /** Uma vez que a instalação recusa anexos, para de tentar (e de avisar) nesta run. */
-  attachmentsUnsupported = false;
-  // Progresso (ctx.progress): snapshot absoluto, enviado com throttle via piggyback
-  // em `enqueue()` — nunca gera tráfego próprio enquanto logs/heartbeat já fluem.
-  progressCurrent = 0;
-  progressTotal = null;
-  /** Snapshot ainda não entregue ao servidor. */
-  progressDirty = false;
-  progressTimer;
-  progressWarned = false;
-  /** Arquivos do formulário desta run (`ctx.files`) — a pasta temporária é apagada no fim. */
-  fileStore;
-  /** Apaga as cópias de arquivo que ficaram na pasta temporária da run. Nunca lança. */
-  cleanupFiles() {
-    return this.fileStore.cleanup();
+  async downloadAll(field2, dest) {
+    const value = this.field(field2);
+    const refs = Array.isArray(value) ? value : [value];
+    const paths = [];
+    for (const ref of refs) paths.push(await this.download(ref, dest, true));
+    return paths;
   }
-  get isDead() {
-    return this.dead;
+  async read(ref) {
+    const { readFile, rm } = await import("fs/promises");
+    const { dirname } = await import("path");
+    const path = await this.download(ref, void 0);
+    try {
+      return await readFile(path);
+    } finally {
+      await rm(dirname(path), { recursive: true, force: true });
+    }
+  }
+  async download(ref, dest, destIsDir = false) {
+    this.checkCanceled();
+    const target = await this.resolveTarget(ref, dest, destIsDir);
+    if (ref.storage === "local") await this.copyLocal(ref, target);
+    else await this.downloadS3(ref, target);
+    return target;
   }
-  /** Lança `RunCanceled` se o signal desta run já disparou. */
   checkCanceled() {
-    if (this.abortController.signal.aborted) throw runCanceledError();
+    if (this.deps.signal.aborted) throw runCanceledError();
   }
-  /** Aborta o ctx.signal sem matar o reporter (timeout/shutdown ainda reportam o terminal). */
-  abort() {
-    this.stopCancelWatch();
-    if (!this.abortController.signal.aborted) this.abortController.abort();
+  runTempDir() {
+    this.tempDir ??= (async () => {
+      const { mkdtemp } = await import("fs/promises");
+      const { tmpdir } = await import("os");
+      const { join } = await import("path");
+      return mkdtemp(join(tmpdir(), "hobots-files-"));
+    })();
+    return this.tempDir;
   }
-  /**
-   * Mata o reporter de vez: aborta o signal e suprime todo reporte futuro.
-   * Usado no exit path — depois que o agente reportou AgentTerminated por fora
-   * da fila, um handler zumbi não pode reenviar status por cima.
-   */
-  kill() {
-    this.abort();
-    this.dead = true;
-    this.clearFlushTimer();
-    this.clearProgressTimer();
-    this.buffer = [];
-    this.itemsClosed = true;
-    this.clearItemsTimer();
-    if (this.itemsBuffer.length > 0) {
-      this.logger.warn(`${this.itemsBuffer.length} item(ns) de execu\xE7\xE3o descartados (processo encerrando)`);
-      this.itemsBuffer = [];
+  async resolveTarget(ref, dest, destIsDir) {
+    const { mkdir, mkdtemp, stat } = await import("fs/promises");
+    const { dirname, join, resolve: resolve2 } = await import("path");
+    const name = safeFileName(ref.name, "arquivo");
+    if (dest === void 0) {
+      return join(await mkdtemp(join(await this.runTempDir(), "f-")), name);
+    }
+    const isDir = destIsDir || dest.endsWith("/") || dest.endsWith("\\") || (await stat(dest).catch(() => void 0))?.isDirectory() === true;
+    if (isDir) {
+      await mkdir(dest, { recursive: true });
+      return resolve2(dest, name);
+    }
+    await mkdir(dirname(resolve2(dest)), { recursive: true });
+    return resolve2(dest);
+  }
+  /** storage 's3': URL pré-assinada → GET em streaming → confere o tamanho → só então DELETE. */
+  async downloadS3(ref, target) {
+    const { api, runId, signal } = this.deps;
+    let expected;
+    let url;
+    try {
+      const info = await api.requestFileDownload(runId, ref.id, signal);
+      expected = info.size >= 0 ? info.size : ref.size;
+      url = info.url;
+    } catch (error) {
+      throw this.translate(error, ref);
+    }
+    const { open, rename, rm } = await import("fs/promises");
+    const part = `${target}.part`;
+    const idleTimeoutMs = this.deps.idleTimeoutMs ?? FILE_DOWNLOAD_IDLE_TIMEOUT_MS;
+    const controller = new AbortController();
+    let timedOut = false;
+    let timer;
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, idleTimeoutMs);
+    };
+    const onCancel = () => controller.abort();
+    signal.addEventListener("abort", onCancel, { once: true });
+    try {
+      arm();
+      const response = await api.fetchFile(url, controller.signal);
+      const handle = await open(part, "w");
+      let written = 0;
+      try {
+        const reader = response.body?.getReader();
+        const stopReading = () => void reader?.cancel().catch(() => void 0);
+        controller.signal.addEventListener("abort", stopReading, { once: true });
+        for (; ; ) {
+          const chunk = reader ? await reader.read() : { done: true, value: void 0 };
+          if (chunk.done) break;
+          arm();
+          written += chunk.value.byteLength;
+          if (written > expected) {
+            stopReading();
+            break;
+          }
+          await handle.write(chunk.value);
+        }
+      } finally {
+        await handle.close();
+      }
+      if (written !== expected) {
+        throw new Error(`tamanho divergente no download de "${ref.name}": recebidos ${written} bytes, esperados ${expected}`);
+      }
+      await rename(part, target);
+    } catch (error) {
+      await rm(part, { force: true });
+      if (signal.aborted) throw runCanceledError();
+      if (timedOut) {
+        throw new Error(`download de "${ref.name}" parado h\xE1 ${idleTimeoutMs / 1e3}s \u2014 tente de novo`);
+      }
+      throw this.translate(error, ref);
+    } finally {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onCancel);
+    }
+    try {
+      await api.confirmFileDownload(runId, ref.id);
+    } catch (error) {
+      this.deps.warn(`arquivo "${ref.name}" baixado, mas a confirma\xE7\xE3o ao servidor falhou: ${String(error)}`);
     }
-    const waiting = this.uploadQueue.splice(0, this.uploadQueue.length);
-    for (const resume of waiting) resume();
   }
   /**
-   * Drena o buffer pendente para o PATCH único do exit path (chame ANTES de kill,
-   * que descarta o buffer). Capado em um chunk — o exit path não tem retry nem fila,
-   * então preserva os logs mais recentes, os mais valiosos na morte do processo.
+   * storage 'local': copia o único arquivo de `$HOBOTS_LOCAL_FILES_DIR/<id>/` e apaga a pasta de
+   * origem. No modo local, um FileRef com `path` copia direto desse caminho, sem apagar a origem.
    */
-  drainLogs() {
-    this.clearFlushTimer();
-    return this.takeLogs().slice(-MAX_LOGS_PER_PATCH);
+  async copyLocal(ref, target) {
+    const direct = localRunPath(ref);
+    if (direct !== void 0) {
+      await this.copyFromPath(ref, direct, target);
+      return;
+    }
+    const base = process.env[LOCAL_FILES_DIR_ENV];
+    if (!base) throw unavailableLocal(ref);
+    const { copyFile, readdir, rename, rm, stat } = await import("fs/promises");
+    const { join, resolve: resolve2, sep } = await import("path");
+    const root = resolve2(base);
+    const folder = resolve2(root, ref.id);
+    if (!isInsideDir(root, folder, sep) || !UUID_RE.test(ref.id)) {
+      throw new Error(`id de arquivo local inv\xE1lido: ${JSON.stringify(ref.id)}`);
+    }
+    let names;
+    try {
+      names = (await readdir(folder, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name);
+    } catch (error) {
+      if (errorCode(error) === "ENOENT" || errorCode(error) === "ENOTDIR") throw unavailableLocal(ref);
+      throw error;
+    }
+    if (names.length === 0) throw unavailableLocal(ref);
+    if (names.length > 1) throw new Error(`pasta do arquivo "${ref.name}" tem ${names.length} arquivos \u2014 esperado 1`);
+    this.checkCanceled();
+    const part = `${target}.part`;
+    try {
+      await copyFile(join(folder, names[0]), part);
+      const { size } = await stat(part);
+      if (size !== ref.size) {
+        throw new Error(`tamanho divergente na c\xF3pia de "${ref.name}": copiados ${size} bytes, esperados ${ref.size}`);
+      }
+      await rename(part, target);
+    } catch (error) {
+      await rm(part, { force: true });
+      throw error;
+    }
+    await rm(folder, { recursive: true, force: true });
   }
   /**
-   * 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.
+   * Modo local: cópia do arquivo apontado por `path` (teste roda várias vezes — a fonte fica).
+   * Sem conferência de tamanho: o `size` do FileRef é informativo aqui.
    */
-  log(level, message, image3) {
-    if (this.dead) return;
-    const scrubbed = scrubSecrets(safeString(message));
-    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);
+  async copyFromPath(ref, path, target) {
+    const { copyFile, rename, rm, stat } = await import("fs/promises");
+    const { resolve: resolve2 } = await import("path");
+    const source = resolve2(path);
+    const info = await stat(source).catch(() => void 0);
+    if (!info?.isFile()) throw new Error(`arquivo "${ref.name}" n\xE3o encontrado em ${path}`);
+    this.checkCanceled();
+    const part = `${target}.part`;
+    try {
+      await copyFile(source, part);
+      await rename(part, target);
+    } catch (error) {
+      await rm(part, { force: true });
+      throw error;
+    }
   }
-  /** Bufferiza uma entrada de log sem eco no terminal (cap, truncate, flush). */
-  push(level, message, alreadyScrubbed = false, attachments, ts = nowISO()) {
-    if (this.dead) return ts;
-    const scrubbed = alreadyScrubbed ? message : scrubSecrets(message);
-    this.buffer.push({
-      ts,
-      level,
-      message: truncate(scrubbed, MAX_LOG_MESSAGE_CHARS),
-      ...attachments && attachments.length > 0 ? { attachments: attachments.slice(0, WIRE_LIMITS.MAX_ATTACHMENTS_PER_LOG_ENTRY) } : {}
-    });
-    if (this.buffer.length >= FLUSH_AT_BUFFERED) {
-      this.flushLogs();
-    } else {
-      this.scheduleFlush();
+  translate(error, ref) {
+    if (this.deps.signal.aborted) return runCanceledError();
+    if (error instanceof TasksApiError && error.status === 410) {
+      return new TasksApiError(`arquivo "${ref.name}" j\xE1 baixado ou expirado`, 410);
     }
-    return ts;
+    if (error instanceof TasksApiError && error.status === 404) {
+      return new TasksApiError(`arquivo "${ref.name}" n\xE3o encontrado nesta execu\xE7\xE3o`, 404);
+    }
+    return error;
   }
-  scheduleFlush() {
-    if (this.timer) return;
-    this.timer = setTimeout(() => {
-      this.timer = void 0;
-      this.flushLogs();
-    }, this.flushIntervalMs);
-    unrefTimer(this.timer);
-  }
-  clearFlushTimer() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = void 0;
-    }
-  }
-  takeLogs() {
-    return this.buffer.splice(0, this.buffer.length);
-  }
-  /** Flush incremental: envia o buffer como status 'running' (em chunks). */
-  flushLogs() {
-    this.clearFlushTimer();
-    if (this.dead || this.buffer.length === 0) return;
-    const logs = this.buffer.splice(0, this.buffer.length);
-    for (let i = 0; i < logs.length; i += MAX_LOGS_PER_PATCH) {
-      this.enqueue({ status: "running", logs: logs.slice(i, i + MAX_LOGS_PER_PATCH) });
-    }
-  }
-  /**
-   * `hobots.flush()`: o bot decide quando entregar o que já fez — steps raiz finalizadas
-   * viram transactions parciais da run, e itens, logs e progresso pendentes saem já, sem
-   * esperar o throttle. Aguarda a entrega com teto. Nunca lança (pode ir num `finally`).
-   */
-  async flush(timeoutMs = ITEMS_DRAIN_MS) {
-    this.tx.flush();
-    this.flushItems();
-    if (this.progressDirty) this.flushProgress();
-    else this.flushLogs();
-    await Promise.race([
-      Promise.all([this.itemsChain, this.chain, this.tx.drain(timeoutMs)]).catch(() => void 0),
-      new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
-    ]);
-  }
-  /** Primeiro PATCH (claimed → running). Retorna false se a run já morreu (cancelada). */
-  async reportRunning() {
-    this.enqueue({ status: "running" });
-    await this.chain;
-    if (!this.dead) this.startCancelWatch();
-    return !this.dead;
-  }
-  reportSuccess() {
-    this.stopCancelWatch();
-    this.clearFlushTimer();
-    this.forceFinalProgress();
-    this.enqueue({ status: "succeeded", logs: this.takeLogsForTerminal() });
-  }
-  reportFailure(error) {
-    this.stopCancelWatch();
-    this.clearFlushTimer();
-    this.forceFinalProgress();
-    this.enqueue({ status: "failed", error, logs: this.takeLogsForTerminal() });
-  }
-  /**
-   * Esvazia o buffer para o PATCH terminal respeitando o teto de 100 logs por PATCH:
-   * o excedente sai antes, em PATCHes `running` na mesma cadeia (a ordem se mantém).
-   */
-  takeLogsForTerminal() {
-    let logs = this.takeLogs();
-    while (logs.length > MAX_LOGS_PER_PATCH) {
-      this.enqueue({ status: "running", logs: logs.slice(0, MAX_LOGS_PER_PATCH) });
-      logs = logs.slice(MAX_LOGS_PER_PATCH);
-    }
-    return logs;
-  }
-  // ── Progresso ────────────────────────────────────────────────────────────────
-  /** Valida, clampa e marca o snapshot como pendente; agenda flush só se nada mais vai sair. */
-  setProgress(current, total) {
-    if (this.dead) return;
-    if (total != null && (!Number.isInteger(total) || total < 1)) {
-      if (!this.progressWarned) {
-        this.progressWarned = true;
-        this.logger.warn(`ctx.progress: total inv\xE1lido (${String(total)}) \u2014 precisa ser inteiro >= 1; ignorado`);
-      }
+};
+
+// src/tasks/context.ts
+var LOG_LEVEL_COLOR = {
+  debug: "gray",
+  info: "cyan",
+  warning: "yellow",
+  error: "red",
+  success: "green"
+};
+function joinLogArgs(message, rest) {
+  if (rest.length === 0) return safeString(message);
+  return [message, ...rest].map(safeString).join(" ");
+}
+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);
+}
+var PROGRESS_LINE_PREFIX = "[hobots:progress]";
+var PROGRESS_PRINT_THROTTLE_MS = 250;
+function printRunProgress(current, total) {
+  console.log(`${PROGRESS_LINE_PREFIX} ${current}/${total}`);
+}
+function cancelableSleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal.aborted) {
+      reject(runCanceledError());
       return;
     }
-    const safeCurrent = Number.isFinite(current) ? Math.max(0, Math.floor(current)) : this.progressCurrent;
-    const next = total == null ? safeCurrent : Math.min(safeCurrent, total);
-    if (next === this.progressCurrent && total === this.progressTotal) return;
-    this.progressCurrent = next;
-    this.progressTotal = total;
-    if (total == null) return;
-    this.progressDirty = true;
-    if (this.progressTimer) return;
-    this.progressTimer = setTimeout(() => {
-      this.progressTimer = void 0;
-      this.flushProgress();
-    }, PROGRESS_FLUSH_MS);
-    unrefTimer(this.progressTimer);
-  }
-  flushProgress() {
-    this.clearProgressTimer();
-    if (this.dead || !this.progressDirty) return;
-    if (this.buffer.length > 0) this.flushLogs();
-    else this.enqueue({ status: "running" });
-  }
-  clearProgressTimer() {
-    if (this.progressTimer) {
-      clearTimeout(this.progressTimer);
-      this.progressTimer = void 0;
-    }
-  }
-  /** O PATCH terminal sempre leva o snapshot final (o app mostra "87/100" numa run que falhou). */
-  forceFinalProgress() {
-    this.clearProgressTimer();
-    this.progressDirty = this.progressTotal != null;
-  }
-  /** Consome o snapshot pendente para pegar carona no próximo PATCH. */
-  takeProgress() {
-    if (!this.progressDirty || this.progressTotal == null) return void 0;
-    this.progressDirty = false;
-    return { current: this.progressCurrent, total: this.progressTotal };
-  }
-  /**
-   * Heartbeat de cancelamento: enquanto o handler roda, um PATCH 'running' vazio
-   * periódico faz o servidor responder 409 se a run foi cancelada no app — o que
-   * mata o reporter e dispara ctx.signal, mesmo em handlers que nunca logam.
-   */
-  startCancelWatch() {
-    if (this.watchTimer) return;
-    this.watchTimer = setInterval(() => {
-      if (this.dead || this.pendingUpdates > 0 || this.buffer.length > 0) return;
-      this.enqueue({ status: "running" });
-    }, this.cancelCheckIntervalMs);
-    unrefTimer(this.watchTimer);
-  }
-  stopCancelWatch() {
-    if (this.watchTimer) {
-      clearInterval(this.watchTimer);
-      this.watchTimer = void 0;
-    }
-  }
-  /** Aguarda a fila de PATCHes esvaziar (chame depois do terminal). */
-  finalize() {
-    return this.chain;
-  }
-  // ── Itens de execução ────────────────────────────────────────────────────────
-  /**
-   * Bufferiza um item (síncrono — a chamada nunca espera rede). Diferente do PATCH
-   * 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, image3) {
-    if (this.itemsClosed || this.itemsUnsupported) return;
-    let scrubbedPayload;
-    if (payload) {
-      scrubbedPayload = scrubPayloadValue(payload, 0);
-      let serializedLength;
-      try {
-        serializedLength = JSON.stringify(scrubbedPayload).length;
-      } catch {
-      }
-      if (serializedLength === void 0 || serializedLength > MAX_ITEM_PAYLOAD_BYTES) {
-        this.logger.warn(
-          `payload do item descartado (${serializedLength === void 0 ? "n\xE3o serializ\xE1vel" : `${serializedLength} bytes > ${MAX_ITEM_PAYLOAD_BYTES}`}) \u2014 o item foi mantido`
-        );
-        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,
-      ...attachmentId ? { attachments: [attachmentId] } : {}
-    });
-    if (this.itemsBuffer.length >= ITEMS_FLUSH_AT_BUFFERED) {
-      this.flushItems();
-    } else {
-      this.scheduleItemsFlush();
-    }
-  }
-  scheduleItemsFlush() {
-    if (this.itemsTimer) return;
-    this.itemsTimer = setTimeout(() => {
-      this.itemsTimer = void 0;
-      this.flushItems();
-    }, this.flushIntervalMs);
-    unrefTimer(this.itemsTimer);
-  }
-  clearItemsTimer() {
-    if (this.itemsTimer) {
-      clearTimeout(this.itemsTimer);
-      this.itemsTimer = void 0;
-    }
-  }
-  /** Envia o buffer de itens em lotes serializados na cadeia própria. */
-  flushItems() {
-    this.clearItemsTimer();
-    if (this.itemsBuffer.length === 0 || this.itemsUnsupported) return;
-    const items = this.itemsBuffer.splice(0, this.itemsBuffer.length);
-    for (let i = 0; i < items.length; i += MAX_ITEMS_PER_REQUEST) {
-      const batch = items.slice(i, i + MAX_ITEMS_PER_REQUEST);
-      this.itemsChain = this.itemsChain.then(() => this.sendItems(batch));
-    }
-  }
-  async sendItems(batch) {
-    if (this.itemsUnsupported) return;
-    try {
-      await this.api.createItems(this.runId, { items: batch });
-      this.itemsStorageFull = false;
-    } catch (error) {
-      if (error instanceof TasksApiError && error.status === 404) {
-        this.itemsUnsupported = true;
-        this.logger.warn("itens de execu\xE7\xE3o n\xE3o s\xE3o suportados por este servidor Hobots \u2014 descartados");
-        return;
-      }
-      if (error instanceof TasksApiError && error.status === 429) {
-        if (!this.itemsQuotaExceeded) {
-          this.itemsQuotaExceeded = true;
-          this.log("warning", "itens descartados: limite de itens por execu\xE7\xE3o atingido no servidor");
-        }
-        return;
-      }
-      if (error instanceof TasksApiError && error.status === 402) {
-        if (!this.itemsStorageFull) {
-          this.itemsStorageFull = true;
-          this.log("warning", "itens descartados: armazenamento do plano cheio \u2014 libere espa\xE7o ou fa\xE7a upgrade em Plano e cobran\xE7a");
-        }
-        return;
-      }
-      if (error instanceof TasksApiError) {
-        this.logger.error(`lote de ${batch.length} item(ns) rejeitado pelo servidor:`, error);
-        this.log("warning", `${batch.length} item(ns) descartado(s): envio rejeitado pelo servidor (HTTP ${error.status})`);
-        return;
-      }
-      this.itemsBuffer.unshift(...batch);
-      this.scheduleItemsFlush();
-      this.logger.error(`lote de ${batch.length} item(ns) n\xE3o enviado (devolvido ao buffer):`, error);
-    }
-  }
-  /**
-   * Dreno final de itens antes do PATCH terminal (com teto): garante que os
-   * totalizadores estejam completos quando a run vira succeeded/failed. Como o
-   * servidor aceita itens tardios, perder a corrida aqui não perde dados.
-   */
-  async finalizeItems(timeoutMs = ITEMS_DRAIN_MS) {
-    this.flushItems();
-    await Promise.race([
-      this.itemsChain,
-      new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
-    ]);
-    if (this.itemsBuffer.length > 0 && !this.itemsUnsupported && !this.itemsQuotaExceeded) {
-      this.flushItems();
-      await Promise.race([
-        this.itemsChain,
-        new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
-      ]);
-    }
-  }
-  // ── Anexos ───────────────────────────────────────────────────────────────────
-  /**
-   * 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()`.
-   */
-  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) {
-      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 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 id;
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(runCanceledError());
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var DEFAULT_LOG_FLUSH_INTERVAL_MS = 2e3;
+var DEFAULT_CANCEL_CHECK_INTERVAL_MS = 5e3;
+var MIN_CANCEL_CHECK_INTERVAL_MS = 1e3;
+var MAX_CANCEL_CHECK_INTERVAL_MS = 15e3;
+var MAX_LOG_MESSAGE_CHARS = WIRE_LIMITS.MAX_LOG_MESSAGE_CHARS;
+var MAX_LOGS_PER_PATCH = WIRE_LIMITS.MAX_LOGS_PER_PATCH;
+var FLUSH_AT_BUFFERED = 20;
+var MAX_ITEMS_PER_REQUEST = WIRE_LIMITS.MAX_ITEMS_PER_REQUEST;
+var MAX_ITEMS_DONE_PER_PAGE = WIRE_LIMITS.MAX_ITEMS_DONE_PER_PAGE;
+var MAX_ITEM_MESSAGE_CHARS = WIRE_LIMITS.MAX_ITEM_MESSAGE_CHARS;
+var MAX_ITEM_PAYLOAD_BYTES = WIRE_LIMITS.MAX_ITEM_PAYLOAD_BYTES;
+var ITEMS_FLUSH_AT_BUFFERED = 100;
+var ITEMS_DRAIN_MS = 15e3;
+var PROGRESS_FLUSH_MS = 1e3;
+function scrubPayloadValue(value, depth) {
+  if (typeof value === "string") return scrubSecrets(value);
+  if (depth >= 4 || value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((entry) => scrubPayloadValue(entry, depth + 1));
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    out[key] = scrubPayloadValue(entry, depth + 1);
   }
-  /** Retorna o motivo da falha, ou undefined em sucesso. */
-  async uploadAttachment(id, image3, meta) {
-    let bytes;
-    try {
-      bytes = await toBytes(image3);
-    } catch (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", "imagem descartada: formato n\xE3o reconhecido (aceitos: PNG, JPEG, WEBP)");
-      return "unsupported-format";
-    }
-    if (bytes.byteLength > MAX_ATTACHMENT_BYTES) {
-      this.log(
-        "warning",
-        `imagem descartada: ${Math.round(bytes.byteLength / 1024)} KB excede o limite de ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB`
-      );
-      return "too-large";
-    }
-    const dimensions = readPngDimensions(bytes);
-    const release = await this.acquireUploadSlot();
-    try {
-      if (this.abortController.signal.aborted || this.dead) return "canceled";
-      const created = await this.api.createAttachment(
-        this.runId,
-        {
-          id,
-          content_type: contentType,
-          size_bytes: bytes.byteLength,
-          log_ts: meta.logTs,
-          ...meta.caption ? { caption: meta.caption } : {},
-          ...dimensions ?? {}
+  return out;
+}
+var RunReporter = class {
+  constructor(api, runId, logger, tx, flushIntervalMs, cancelCheckIntervalMs, params = {}) {
+    this.api = api;
+    this.runId = runId;
+    this.logger = logger;
+    this.tx = tx;
+    this.flushIntervalMs = flushIntervalMs ?? DEFAULT_LOG_FLUSH_INTERVAL_MS;
+    this.cancelCheckIntervalMs = Math.min(
+      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: 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, image3) => this.addItem(status, message, payload, id, image3),
+      startStep: (op, description) => tx.start(op, description),
+      stepScope: (step, fn) => tx.scope(step, fn),
+      declareTotal: (total) => {
+        if (this.progressTotal == null) this.setProgress(this.progressCurrent, total);
+      },
+      advance: () => this.setProgress(this.progressCurrent + 1, this.progressTotal),
+      checkCanceled,
+      isAborted: () => this.abortController.signal.aborted,
+      logInfo: (message) => this.log("info", message),
+      logWarning: (message) => this.log("warning", message),
+      logError: (message) => this.log("error", message),
+      sleep: (ms) => cancelableSleep(ms, this.abortController.signal),
+      doneItemIds: () => this.listDoneItemIds(),
+      flush: () => this.flush()
+    };
+    const items = {
+      add: (item) => {
+        checkCanceled();
+        this.addItem(item.status, item.message, item.payload, item.id, item.image);
+      },
+      succeeded: (payload, options) => {
+        checkCanceled();
+        this.addItem("succeeded", void 0, payload, options?.id, options?.image);
+      },
+      failed: (message, payload, options) => {
+        checkCanceled();
+        this.addItem("failed", message, payload, options?.id, options?.image);
+      },
+      occurrence: (message, payload, options) => {
+        checkCanceled();
+        this.addItem("occurrence", message, payload, options?.id, options?.image);
+      },
+      each: (list, handler, options = {}) => eachItem(list, handler, options, eachSink)
+    };
+    const progress = Object.defineProperties(
+      {
+        total: (total) => {
+          checkCanceled();
+          this.setProgress(this.progressCurrent, total);
         },
-        this.abortController.signal
-      );
-      await this.api.uploadAttachment(created.upload_url, created.headers, bytes, this.abortController.signal);
-      await this.api.confirmAttachment(this.runId, id, { status: "uploaded", size_bytes: bytes.byteLength, ...dimensions ?? {} }).catch(() => {
-      });
-      return void 0;
-    } catch (error) {
-      if (this.isUnsupported(error)) {
-        this.attachmentsUnsupported = true;
-        this.log("warning", "anexos n\xE3o est\xE3o habilitados nesta instala\xE7\xE3o do Hobots \u2014 imagem n\xE3o enviada");
-        return "unsupported";
-      }
-      if (error instanceof TasksApiError && error.status === 429) {
-        this.log("warning", "imagem descartada: limite de anexos por execu\xE7\xE3o atingido no servidor");
-        return "quota";
+        advance: (count = 1) => {
+          checkCanceled();
+          this.setProgress(this.progressCurrent + count, this.progressTotal);
+        },
+        set: (current, total) => {
+          checkCanceled();
+          this.setProgress(current, total ?? this.progressTotal);
+        }
+      },
+      {
+        current: { enumerable: true, get: () => this.progressCurrent },
+        snapshot: {
+          enumerable: true,
+          get: () => this.progressTotal == null ? null : { current: this.progressCurrent, total: this.progressTotal }
+        }
       }
-      if (this.abortController.signal.aborted) return "canceled";
-      this.log("warning", `falha ao enviar a imagem: ${String(error)}`);
-      void this.api.confirmAttachment(this.runId, id, { status: "failed" }).catch(() => {
-      });
-      return "upload-failed";
-    } finally {
-      release();
-    }
-  }
-  /** 404 = API anterior ao recurso; 501/503 = instalação sem S3 configurado. */
-  isUnsupported(error) {
-    return error instanceof TasksApiError && (error.status === 404 || error.status === 501 || error.status === 503);
-  }
-  /** Semáforo simples: no máximo MAX_CONCURRENT_UPLOADS binários em voo por run. */
-  acquireUploadSlot() {
-    const release = () => {
-      const next = this.uploadQueue.shift();
-      if (next) next();
-      else this.uploadSlots++;
+      // defineProperties não tipa os getters adicionados — a interface é a fonte de verdade
+    );
+    const signal = this.abortController.signal;
+    const sleep2 = (ms) => cancelableSleep(ms, signal);
+    this.fileStore = new RunFileStore({ api, runId, params, signal, warn: (message) => this.log("warning", message) });
+    this.context = {
+      runId,
+      params,
+      log,
+      items,
+      progress,
+      files: this.fileStore.files,
+      step: async (name, fn, options) => {
+        const root = tx.currentStep() === void 0;
+        try {
+          return await tx.step(name, fn, { ...options, signal, wait: sleep2, warn: (message) => this.log("warning", message) });
+        } finally {
+          if (options?.flush !== false && root && !signal.aborted) await this.flush();
+        }
+      },
+      flush: (timeoutMs) => this.flush(timeoutMs),
+      signal,
+      throwIfCanceled: checkCanceled,
+      sleep: sleep2,
+      retry: (fn, options) => retryWithBackoff(fn, { ...options, signal, wait: sleep2 })
     };
-    if (this.uploadSlots > 0) {
-      this.uploadSlots--;
-      return Promise.resolve(release);
-    }
-    return new Promise((resolve2) => {
-      this.uploadQueue.push(() => resolve2(release));
-    });
   }
+  api;
+  runId;
+  logger;
+  tx;
+  context;
+  buffer = [];
+  dead = false;
+  chain = Promise.resolve();
+  pendingUpdates = 0;
+  timer;
+  watchTimer;
+  abortController = new AbortController();
+  flushIntervalMs;
+  cancelCheckIntervalMs;
+  // Itens de execução vivem FORA de `this.chain` (status/liveness não pode ficar
+  // atrás de milhares de itens), mas têm cadeia própria serializada — ordem de
+  // envio preservada e sem lotes sobrepostos.
+  itemsBuffer = [];
+  itemsChain = Promise.resolve();
+  itemsTimer;
+  itemSeq = 0;
+  /** Servidor sem o recurso (404) — para de tentar (e de avisar) nesta run. */
+  itemsUnsupported = false;
   /**
-   * Espera os uploads pendentes antes do PATCH terminal, para a run não terminar
-   * exibindo miniaturas em "enviando…". Capado: um upload lento não segura a run.
+   * Cota de itens por run do servidor (429, legado — hoje a api não tem teto de itens) —
+   * degrada com um aviso só.
    */
-  async finalizeAttachments(timeoutMs = ATTACHMENT_DRAIN_MS) {
-    if (this.pendingAttachments.size === 0) return;
-    await Promise.race([
-      Promise.allSettled([...this.pendingAttachments]),
-      new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
-    ]);
-  }
-  enqueue(updateIn) {
-    if (this.dead) {
-      this.salvageLogs(updateIn.logs);
-      return;
-    }
-    this.clearProgressTimer();
-    const progress = this.takeProgress();
-    const update = progress ? { ...updateIn, progress } : updateIn;
-    this.pendingUpdates++;
-    this.chain = this.chain.then(async () => {
-      if (this.dead) {
-        this.salvageLogs(update.logs);
-        return;
-      }
-      const payload = update.logs && update.logs.length === 0 ? { ...update, logs: void 0 } : update;
-      try {
-        await this.api.updateRun(this.runId, payload);
-      } catch (error) {
-        if (error instanceof TasksApiError && (error.status === 409 || error.status === 404)) {
-          this.dead = true;
-          this.stopCancelWatch();
-          this.abort();
-          const pending = this.buffer.splice(0, this.buffer.length);
-          this.salvageLogs(pending);
-          this.logger.warn(
-            `run ${this.runId} cancelada/finalizada no servidor \u2014 status suprimido` + (pending.length > 0 ? `, ${pending.length} log(s) enviados como log tardio` : "")
-          );
-          return;
-        }
-        if (update.logs && update.logs.length > 0) {
-          this.buffer.unshift(...update.logs);
-          this.scheduleFlush();
-        }
-        if (update.progress && this.progressTotal != null) this.progressDirty = true;
-        this.logger.error(`update da run ${this.runId} perdido:`, error);
-      }
-    }).finally(() => {
-      this.pendingUpdates--;
-    });
-  }
+  itemsQuotaExceeded = false;
   /**
-   * Best-effort de log tardio: envia logs para uma run já terminal, fora da fila.
-   * O servidor anexa os logs mesmo respondendo 409; erros são engolidos — este é
-   * o último recurso, não um canal confiável.
+   * Armazenamento do plano cheio (402 `storage_limit`): o lote é descartado e o aviso sai
+   * uma vez por episódio. Os envios continuam — num agente `start()` o espaço pode ser
+   * liberado (ou o plano trocado) sem reiniciar; um lote aceito rearma o aviso.
    */
-  salvageLogs(logs) {
-    if (!logs || logs.length === 0) return;
-    for (let i = 0; i < logs.length; i += MAX_LOGS_PER_PATCH) {
-      void this.api.updateRunOnce(this.runId, { status: "running", logs: logs.slice(i, i + MAX_LOGS_PER_PATCH) }).catch(() => {
-      });
-    }
-  }
-};
-
-// src/tasks/run-context-store.ts
-var storage;
-var initPromise;
-async function ensureStorage() {
-  if (storage || !isNode()) return;
-  initPromise ??= import("async_hooks").then(({ AsyncLocalStorage: ALS }) => {
-    storage = new ALS();
-  });
-  await initPromise;
-}
-async function runWithRunContext(store, fn) {
-  await ensureStorage();
-  return storage ? storage.run(store, fn) : fn();
-}
-function currentRunReporter() {
-  return storage?.getStore()?.reporter;
-}
-
-// src/transaction.ts
-var FLUSH_TRANSACTION_OP = "hobots.run.flush";
-var MAX_STEP_MESSAGE_CHARS = 2e3;
-function stepMessage(text) {
-  return truncate(scrubSecrets(text), MAX_STEP_MESSAGE_CHARS);
-}
-function stepId() {
-  return uuid4().slice(0, 16);
-}
-function stepLabel(op, description) {
-  return [op, description].filter(Boolean).join(" \u2014 ") || "(sem nome)";
-}
-function levelForStatus(status) {
-  switch (status) {
-    case "warning":
-      return "warning";
-    case "error":
-      return "error";
-    case "cancelled":
-      return "warning";
-    default:
-      return "success";
-  }
-}
-function colorForStatus(status) {
-  switch (status) {
-    case "warning":
-      return "yellow";
-    case "error":
-      return "red";
-    case "cancelled":
-      return "gray";
-    default:
-      return "green";
+  itemsStorageFull = false;
+  /**
+   * Só o kill() do exit path fecha os itens — `dead` (run cancelada/finalizada no
+   * servidor) NÃO fecha: o servidor aceita itens de run terminal (trabalho já feito).
+   */
+  itemsClosed = false;
+  // Uploads de anexo vivem FORA de `this.chain`: a cadeia é um FIFO puro de
+  // status/logs e não pode ficar bloqueada esperando um binário subir.
+  pendingAttachments = /* @__PURE__ */ new Set();
+  attachmentCount = 0;
+  uploadSlots = MAX_CONCURRENT_UPLOADS;
+  uploadQueue = [];
+  /** Uma vez que a instalação recusa anexos, para de tentar (e de avisar) nesta run. */
+  attachmentsUnsupported = false;
+  // Progresso (ctx.progress): snapshot absoluto, enviado com throttle via piggyback
+  // em `enqueue()` — nunca gera tráfego próprio enquanto logs/heartbeat já fluem.
+  progressCurrent = 0;
+  progressTotal = null;
+  /** Snapshot ainda não entregue ao servidor. */
+  progressDirty = false;
+  progressTimer;
+  progressWarned = false;
+  /** Relógio do último eco `[hobots:progress]` no terminal (throttle do eco, não do wire). */
+  progressLastPrint = 0;
+  /** Arquivos do formulário desta run (`ctx.files`) — a pasta temporária é apagada no fim. */
+  fileStore;
+  /** Apaga as cópias de arquivo que ficaram na pasta temporária da run. Nunca lança. */
+  cleanupFiles() {
+    return this.fileStore.cleanup();
   }
-}
-var Step = class {
-  constructor(transaction, parentStepId, op, description) {
-    this.transaction = transaction;
-    this.parentStepId = parentStepId;
-    this.op = op;
-    this.description = description;
+  get isDead() {
+    return this.dead;
+  }
+  /** Lança `RunCanceled` se o signal desta run já disparou. */
+  checkCanceled() {
+    if (this.abortController.signal.aborted) throw runCanceledError();
+  }
+  /** Aborta o ctx.signal sem matar o reporter (timeout/shutdown ainda reportam o terminal). */
+  abort() {
+    this.stopCancelWatch();
+    if (!this.abortController.signal.aborted) this.abortController.abort();
   }
-  transaction;
-  parentStepId;
-  op;
-  description;
-  stepId = stepId();
-  startTimestamp = nowISO();
-  status = "ok";
-  endTimestamp;
-  data;
   /**
-   * 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`.
+   * Mata o reporter de vez: aborta o signal e suprime todo reporte futuro.
+   * Usado no exit path — depois que o agente reportou AgentTerminated por fora
+   * da fila, um handler zumbi não pode reenviar status por cima.
    */
-  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;
+  kill() {
+    this.abort();
+    this.dead = true;
+    this.clearFlushTimer();
+    this.clearProgressTimer();
+    this.buffer = [];
+    this.itemsClosed = true;
+    this.clearItemsTimer();
+    if (this.itemsBuffer.length > 0) {
+      this.logger.warn(`${this.itemsBuffer.length} item(ns) de execu\xE7\xE3o descartados (processo encerrando)`);
+      this.itemsBuffer = [];
+    }
+    const waiting = this.uploadQueue.splice(0, this.uploadQueue.length);
+    for (const resume of waiting) resume();
   }
   /**
-   * Marca a step como `error` guardando o motivo em `data.error` ({ type, message }) e a
-   * fecha. Aceita qualquer valor lançado; `message` sobrescreve a mensagem do erro.
-   * `options.image` pendura um print do estado da tela em `data.attachments`.
-   * Numa step já fechada não faz nada.
+   * Drena o buffer pendente para o PATCH único do exit path (chame ANTES de kill,
+   * que descarta o buffer). Capado em um chunk — o exit path não tem retry nem fila,
+   * então preserva os logs mais recentes, os mais valiosos na morte do processo.
    */
-  failed(error, message, options) {
-    if (this.endTimestamp) return this;
-    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);
-    this.close();
-    return this;
+  drainLogs() {
+    this.clearFlushTimer();
+    return this.takeLogs().slice(-MAX_LOGS_PER_PATCH);
   }
   /**
-   * 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.
+   * 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. Devolve o id do anexo (quando houve
+   * imagem e ela não foi descartada) — o `captureException` o leva ao evento da issue.
    */
-  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]);
+  log(level, message, image3) {
+    if (this.dead) return void 0;
+    const scrubbed = scrubSecrets(safeString(message));
+    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);
+    return attachmentId;
   }
-  /** Motivo registrado via setStatus(…, message) ou failed — usado no log de FINISH. */
-  reason() {
-    const error = this.data?.error;
-    const text = typeof error?.message === "string" ? error.message : this.data?.message;
-    return typeof text === "string" && text ? text : void 0;
+  /** Bufferiza uma entrada de log sem eco no terminal (cap, truncate, flush). */
+  push(level, message, alreadyScrubbed = false, attachments, ts = nowISO()) {
+    if (this.dead) return ts;
+    const scrubbed = alreadyScrubbed ? message : scrubSecrets(message);
+    this.buffer.push({
+      ts,
+      level,
+      message: truncate(scrubbed, MAX_LOG_MESSAGE_CHARS),
+      ...attachments && attachments.length > 0 ? { attachments: attachments.slice(0, WIRE_LIMITS.MAX_ATTACHMENTS_PER_LOG_ENTRY) } : {}
+    });
+    if (this.buffer.length >= FLUSH_AT_BUFFERED) {
+      this.flushLogs();
+    } else {
+      this.scheduleFlush();
+    }
+    return ts;
   }
-  setData(key, value) {
-    this.data = { ...this.data, [key]: value };
-    return this;
+  scheduleFlush() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      this.flushLogs();
+    }, this.flushIntervalMs);
+    unrefTimer(this.timer);
   }
-  /** Step aninhada (filha desta step). */
-  start(op, description) {
-    return this.transaction.createStep(this.stepId, op, description);
+  clearFlushTimer() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+  }
+  takeLogs() {
+    return this.buffer.splice(0, this.buffer.length);
+  }
+  /** Flush incremental: envia o buffer como status 'running' (em chunks). */
+  flushLogs() {
+    this.clearFlushTimer();
+    if (this.dead || this.buffer.length === 0) return;
+    const logs = this.buffer.splice(0, this.buffer.length);
+    for (let i = 0; i < logs.length; i += MAX_LOGS_PER_PATCH) {
+      this.enqueue({ status: "running", logs: logs.slice(i, i + MAX_LOGS_PER_PATCH) });
+    }
   }
   /**
-   * Fecha a step. O status fica o que estiver (`ok` por padrão, ou o de `setStatus`).
-   * Idempotente; a transaction fecha no fim da run o que ficou aberto.
+   * `hobots.flush()`: o bot decide quando entregar o que já fez — etapas raiz finalizadas
+   * viram transactions parciais da run, e itens, logs e progresso pendentes saem já, sem
+   * esperar o throttle. Aguarda a entrega com teto. Nunca lança (pode ir num `finally`).
    */
-  succeeded() {
-    this.close();
-    return this;
+  async flush(timeoutMs = ITEMS_DRAIN_MS) {
+    this.tx.flush();
+    this.flushItems();
+    if (this.progressDirty) this.flushProgress();
+    else this.flushLogs();
+    await Promise.race([
+      Promise.all([this.itemsChain, this.chain, this.tx.drain(timeoutMs)]).catch(() => void 0),
+      new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
+    ]);
   }
-  close() {
-    if (this.endTimestamp) return;
-    this.endTimestamp = nowISO();
-    this.transaction.emit(
-      "step",
-      "finish",
-      stepLabel(this.op, this.description),
-      this.startTimestamp,
-      this.endTimestamp,
-      this.status,
-      this.reason()
-    );
+  /** Primeiro PATCH (claimed → running). Retorna false se a run já morreu (cancelada). */
+  async reportRunning() {
+    this.enqueue({ status: "running" });
+    await this.chain;
+    if (!this.dead) this.startCancelWatch();
+    return !this.dead;
   }
-  toJSON() {
-    return {
-      step_id: this.stepId,
-      parent_step_id: this.parentStepId,
-      op: this.op,
-      description: this.description,
-      status: this.status,
-      start_timestamp: this.startTimestamp,
-      timestamp: this.endTimestamp ?? nowISO(),
-      data: this.data
-    };
+  reportSuccess() {
+    this.stopCancelWatch();
+    this.clearFlushTimer();
+    this.forceFinalProgress();
+    this.enqueue({ status: "succeeded", logs: this.takeLogsForTerminal() });
   }
-};
-var Transaction = class {
-  constructor(client, name, op, runId) {
-    this.client = client;
-    this.name = name;
-    this.op = op;
-    this.runId = runId;
-    this.emit("transaction", "start", op ? `${name} (${op})` : name);
+  reportFailure(error) {
+    this.stopCancelWatch();
+    this.clearFlushTimer();
+    this.forceFinalProgress();
+    this.enqueue({ status: "failed", error, logs: this.takeLogsForTerminal() });
   }
-  client;
-  name;
-  op;
-  runId;
-  eventId = uuid4();
-  stepId = stepId();
-  startTimestamp = nowISO();
-  status = "ok";
-  steps = [];
-  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,
-  // antes do RunReporter conectar) — replay no setLifecycleSink
-  lifecycleBacklog = [];
   /**
-   * Registra o início/fim de uma step ou transaction: espelha a linha no sink de
-   * lifecycle, se conectado (é assim que os eventos de performance aparecem nos
-   * logs da run no app), e ecoa no terminal apenas com `debug: true` — o SDK não
-   * escreve no stdout do processo do usuário sem permissão.
+   * Esvazia o buffer para o PATCH terminal respeitando o teto de 100 logs por PATCH:
+   * o excedente sai antes, em PATCHes `running` na mesma cadeia (a ordem se mantém).
    */
-  emit(kind, phase, label, startTs, endTs, status, reason) {
-    const durationMs = startTs && endTs ? new Date(endTs).getTime() - new Date(startTs).getTime() : void 0;
-    const suffix = (durationMs != null ? ` (${durationMs}ms)` : "") + (reason ? `: ${reason}` : "");
-    if (this.client?.debug) {
-      const tag = colorize(`[hobots:${kind}] ${phase.toUpperCase()}`, phase === "finish" ? colorForStatus(status ?? "ok") : "cyan");
-      console.log(`${tag} ${label}${suffix}`);
+  takeLogsForTerminal() {
+    let logs = this.takeLogs();
+    while (logs.length > MAX_LOGS_PER_PATCH) {
+      this.enqueue({ status: "running", logs: logs.slice(0, MAX_LOGS_PER_PATCH) });
+      logs = logs.slice(MAX_LOGS_PER_PATCH);
     }
-    const level = phase === "finish" ? levelForStatus(status ?? "ok") : "info";
-    const message = `[${kind}] ${phase.toUpperCase()} ${label}${suffix}`;
-    if (this.lifecycleSink) this.lifecycleSink(level, message);
-    else if (this.lifecycleBacklog.length < 100) this.lifecycleBacklog.push([level, message]);
+    return logs;
   }
-  /** Conecta o espelho de lifecycle (RunReporter) e faz replay do backlog em ordem. */
-  setLifecycleSink(sink) {
-    this.lifecycleSink = sink;
-    const backlog = this.lifecycleBacklog;
-    this.lifecycleBacklog = [];
-    for (const [level, message] of backlog) sink(level, message);
+  // ── Progresso ────────────────────────────────────────────────────────────────
+  /** Valida, clampa e marca o snapshot como pendente; agenda flush só se nada mais vai sair. */
+  setProgress(current, total) {
+    if (this.dead) return;
+    if (total != null && (!Number.isInteger(total) || total < 1)) {
+      if (!this.progressWarned) {
+        this.progressWarned = true;
+        this.logger.warn(`ctx.progress: total inv\xE1lido (${String(total)}) \u2014 precisa ser inteiro >= 1; ignorado`);
+      }
+      return;
+    }
+    const safeCurrent = Number.isFinite(current) ? Math.max(0, Math.floor(current)) : this.progressCurrent;
+    const next = total == null ? safeCurrent : Math.min(safeCurrent, total);
+    const totalChanged = total !== this.progressTotal;
+    if (next === this.progressCurrent && !totalChanged) return;
+    this.progressCurrent = next;
+    this.progressTotal = total;
+    if (total == null) return;
+    const now = Date.now();
+    if (totalChanged || next >= total || now - this.progressLastPrint >= PROGRESS_PRINT_THROTTLE_MS) {
+      this.progressLastPrint = now;
+      printRunProgress(next, total);
+    }
+    this.progressDirty = true;
+    if (this.progressTimer) return;
+    this.progressTimer = setTimeout(() => {
+      this.progressTimer = void 0;
+      this.flushProgress();
+    }, PROGRESS_FLUSH_MS);
+    unrefTimer(this.progressTimer);
   }
-  /** Conecta o pipeline de anexos da run — é o que dá imagem às steps. */
-  setAttachmentSink(sink) {
-    this.attachmentSink = sink;
+  flushProgress() {
+    this.clearProgressTimer();
+    if (this.dead || !this.progressDirty) return;
+    if (this.buffer.length > 0) this.flushLogs();
+    else this.enqueue({ status: "running" });
   }
-  /** 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");
+  clearProgressTimer() {
+    if (this.progressTimer) {
+      clearTimeout(this.progressTimer);
+      this.progressTimer = void 0;
     }
-    return void 0;
+  }
+  /** O PATCH terminal sempre leva o snapshot final (o app mostra "87/100" numa run que falhou). */
+  forceFinalProgress() {
+    this.clearProgressTimer();
+    this.progressDirty = this.progressTotal != null;
+  }
+  /** Consome o snapshot pendente para pegar carona no próximo PATCH. */
+  takeProgress() {
+    if (!this.progressDirty || this.progressTotal == null) return void 0;
+    this.progressDirty = false;
+    return { current: this.progressCurrent, total: this.progressTotal };
   }
   /**
-   * Conecta a checagem de cancelamento chamada antes de cada step nova — é assim que
-   * `hobots.transaction.start()` (e `step.start()`) param uma run cancelada.
+   * Heartbeat de cancelamento: enquanto o handler roda, um PATCH 'running' vazio
+   * periódico faz o servidor responder 409 se a run foi cancelada no app — o que
+   * mata o reporter e dispara ctx.signal, mesmo em handlers que nunca logam.
    */
-  setStepGuard(guard) {
-    this.stepGuard = guard;
+  startCancelWatch() {
+    if (this.watchTimer) return;
+    this.watchTimer = setInterval(() => {
+      if (this.dead || this.pendingUpdates > 0 || this.buffer.length > 0) return;
+      this.enqueue({ status: "running" });
+    }, this.cancelCheckIntervalMs);
+    unrefTimer(this.watchTimer);
   }
-  createStep(parentStepId, op, description) {
-    this.stepGuard?.();
-    const step = new Step(this, parentStepId, op, description);
-    this.steps.push(step);
-    this.emit("step", "start", stepLabel(op, description));
-    return step;
+  stopCancelWatch() {
+    if (this.watchTimer) {
+      clearInterval(this.watchTimer);
+      this.watchTimer = void 0;
+    }
   }
-  /** Step direta da transaction. `op` é o nome usado por `succeeded(name)`/`failed(error, name)`. */
-  start(op, description) {
-    return this.createStep(this.stepId, op, description);
+  /** Aguarda a fila de PATCHes esvaziar (chame depois do terminal). */
+  finalize() {
+    return this.chain;
   }
+  // ── Itens de execução ────────────────────────────────────────────────────────
   /**
-   * Fecha a step aberta mais recente — com `name`, a mais recente aberta com esse `op`.
-   * Sem step aberta (ou sem nenhuma com esse nome), não faz nada e devolve undefined.
+   * Bufferiza um item (síncrono — a chamada nunca espera rede). Diferente do PATCH
+   * 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.
    */
-  succeeded(name) {
-    return this.findOpenStep(name)?.succeeded();
+  addItem(status, message, payload, id, image3) {
+    if (this.itemsClosed || this.itemsUnsupported) return;
+    let scrubbedPayload;
+    if (payload) {
+      scrubbedPayload = scrubPayloadValue(payload, 0);
+      let serializedLength;
+      try {
+        serializedLength = JSON.stringify(scrubbedPayload).length;
+      } catch {
+      }
+      if (serializedLength === void 0 || serializedLength > MAX_ITEM_PAYLOAD_BYTES) {
+        this.logger.warn(
+          `payload do item descartado (${serializedLength === void 0 ? "n\xE3o serializ\xE1vel" : `${serializedLength} bytes > ${MAX_ITEM_PAYLOAD_BYTES}`}) \u2014 o item foi mantido`
+        );
+        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,
+      ...attachmentId ? { attachments: [attachmentId] } : {}
+    });
+    if (this.itemsBuffer.length >= ITEMS_FLUSH_AT_BUFFERED) {
+      this.flushItems();
+    } else {
+      this.scheduleItemsFlush();
+    }
   }
   /**
-   * Marca como `error` e fecha a step aberta mais recente — com `name`, a mais recente
-   * aberta com esse `op`. `options.message` sobrescreve a mensagem do erro e
-   * `options.image` pendura um print. Sem step aberta, não faz nada e devolve undefined.
+   * Ids já concluídos (`succeeded`/`occurrence`) neste trabalho — a run e suas reexecuções.
+   * Pagina até o fim. undefined quando a consulta falha (servidor antigo, rede): o `each`
+   * avisa e processa tudo, nunca trava a run por isso.
    */
-  failed(error, name, options) {
-    return this.findOpenStep(name)?.failed(error, options?.message, options);
-  }
-  findOpenStep(name) {
-    for (let i = this.steps.length - 1; i >= 0; i--) {
-      const step = this.steps[i];
-      if (!step.endTimestamp && (name === void 0 || step.op === name)) return step;
+  async listDoneItemIds() {
+    const ids = /* @__PURE__ */ new Set();
+    let cursor = null;
+    try {
+      do {
+        const page = await this.api.listDoneItems(this.runId, {
+          limit: MAX_ITEMS_DONE_PER_PAGE,
+          ...cursor ? { cursor } : {}
+        });
+        for (const id of page.ids) ids.add(id);
+        cursor = page.next;
+      } while (cursor);
+      return ids;
+    } catch (error) {
+      this.log("warning", `n\xE3o foi poss\xEDvel consultar os itens j\xE1 conclu\xEDdos deste trabalho \u2014 todos ser\xE3o processados (${thrownMessage(error)})`);
+      return void 0;
     }
-    return void 0;
   }
-  setTag(key, value) {
-    this.tags[key] = value;
-    return this;
+  scheduleItemsFlush() {
+    if (this.itemsTimer) return;
+    this.itemsTimer = setTimeout(() => {
+      this.itemsTimer = void 0;
+      this.flushItems();
+    }, this.flushIntervalMs);
+    unrefTimer(this.itemsTimer);
   }
-  setStatus(status) {
-    this.status = status;
-    return this;
+  clearItemsTimer() {
+    if (this.itemsTimer) {
+      clearTimeout(this.itemsTimer);
+      this.itemsTimer = void 0;
+    }
   }
-  setName(name) {
-    this.name = name;
-    return this;
+  /** Envia o buffer de itens em lotes serializados na cadeia própria. */
+  flushItems() {
+    this.clearItemsTimer();
+    if (this.itemsBuffer.length === 0 || this.itemsUnsupported) return;
+    const items = this.itemsBuffer.splice(0, this.itemsBuffer.length);
+    for (let i = 0; i < items.length; i += MAX_ITEMS_PER_REQUEST) {
+      const batch = items.slice(i, i + MAX_ITEMS_PER_REQUEST);
+      this.itemsChain = this.itemsChain.then(() => this.sendItems(batch));
+    }
+  }
+  async sendItems(batch) {
+    if (this.itemsUnsupported) return;
+    try {
+      await this.api.createItems(this.runId, { items: batch });
+      this.itemsStorageFull = false;
+    } catch (error) {
+      if (error instanceof TasksApiError && error.status === 404) {
+        this.itemsUnsupported = true;
+        this.logger.warn("itens de execu\xE7\xE3o n\xE3o s\xE3o suportados por este servidor Hobots \u2014 descartados");
+        return;
+      }
+      if (error instanceof TasksApiError && error.status === 429) {
+        if (!this.itemsQuotaExceeded) {
+          this.itemsQuotaExceeded = true;
+          this.log("warning", "itens descartados: limite de itens por execu\xE7\xE3o atingido no servidor");
+        }
+        return;
+      }
+      if (error instanceof TasksApiError && error.status === 402) {
+        if (!this.itemsStorageFull) {
+          this.itemsStorageFull = true;
+          this.log("warning", "itens descartados: armazenamento do plano cheio \u2014 libere espa\xE7o ou fa\xE7a upgrade em Plano e cobran\xE7a");
+        }
+        return;
+      }
+      if (error instanceof TasksApiError) {
+        this.logger.error(`lote de ${batch.length} item(ns) rejeitado pelo servidor:`, error);
+        this.log("warning", `${batch.length} item(ns) descartado(s): envio rejeitado pelo servidor (HTTP ${error.status})`);
+        return;
+      }
+      this.itemsBuffer.unshift(...batch);
+      this.scheduleItemsFlush();
+      this.logger.error(`lote de ${batch.length} item(ns) n\xE3o enviado (devolvido ao buffer):`, error);
+    }
   }
   /**
-   * Envia já as steps raiz finalizadas (e todas as descendentes, fechando as que
-   * ficaram abertas) como transactions parciais da mesma run (`op` hobots.run.flush,
-   * `event_id` novo, até 200 steps cada) e as tira da memória. Steps raiz ainda abertas
-   * ficam para o próximo flush ou para o `finish()`. É assim que um agente sempre
-   * ligado (`start()`), cuja run não termina, entrega as etapas enquanto processa.
-   * Devolve quantas steps foram enviadas.
+   * Dreno final de itens antes do PATCH terminal (com teto): garante que os
+   * totalizadores estejam completos quando a run vira succeeded/failed. Como o
+   * servidor aceita itens tardios, perder a corrida aqui não perde dados.
    */
-  flush() {
-    if (this.finished) return 0;
-    const ready = /* @__PURE__ */ new Set();
-    for (const step of this.steps) {
-      if (step.parentStepId === this.stepId && step.endTimestamp) ready.add(step.stepId);
+  async finalizeItems(timeoutMs = ITEMS_DRAIN_MS) {
+    this.flushItems();
+    await Promise.race([
+      this.itemsChain,
+      new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
+    ]);
+    if (this.itemsBuffer.length > 0 && !this.itemsUnsupported && !this.itemsQuotaExceeded) {
+      this.flushItems();
+      await Promise.race([
+        this.itemsChain,
+        new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
+      ]);
     }
-    if (ready.size === 0) return 0;
-    const batch = [];
-    const remaining = [];
-    for (const step of this.steps) {
-      if (ready.has(step.stepId) || ready.has(step.parentStepId)) {
-        ready.add(step.stepId);
-        batch.push(step);
-      } else {
-        remaining.push(step);
+  }
+  // ── Anexos ───────────────────────────────────────────────────────────────────
+  /**
+   * Pendura uma imagem num evento da run (log, item ou etapa): 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()`.
+   */
+  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) {
+      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;
     }
-    for (const step of batch) step.succeeded();
-    this.steps.splice(0, this.steps.length, ...remaining);
-    if (this.client) {
-      for (let i = 0; i < batch.length; i += MAX_STEPS) {
-        const chunk = batch.slice(i, i + MAX_STEPS);
-        const startTimestamp = chunk.reduce((min, step) => step.startTimestamp < min ? step.startTimestamp : min, chunk[0].startTimestamp);
-        const status = chunk.some((step) => step.status === "error") ? "error" : "ok";
-        this.client.sendTransaction(this.payload(uuid4(), FLUSH_TRANSACTION_OP, status, startTimestamp, nowISO(), chunk));
+    this.attachmentCount++;
+    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 id;
+  }
+  /** Retorna o motivo da falha, ou undefined em sucesso. */
+  async uploadAttachment(id, image3, meta) {
+    let bytes;
+    try {
+      bytes = await toBytes(image3);
+    } catch (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", "imagem descartada: formato n\xE3o reconhecido (aceitos: PNG, JPEG, WEBP)");
+      return "unsupported-format";
+    }
+    if (bytes.byteLength > MAX_ATTACHMENT_BYTES) {
+      this.log(
+        "warning",
+        `imagem descartada: ${Math.round(bytes.byteLength / 1024)} KB excede o limite de ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB`
+      );
+      return "too-large";
+    }
+    const dimensions = readPngDimensions(bytes);
+    const release = await this.acquireUploadSlot();
+    try {
+      if (this.abortController.signal.aborted || this.dead) return "canceled";
+      const created = await this.api.createAttachment(
+        this.runId,
+        {
+          id,
+          content_type: contentType,
+          size_bytes: bytes.byteLength,
+          log_ts: meta.logTs,
+          ...meta.caption ? { caption: meta.caption } : {},
+          ...dimensions ?? {}
+        },
+        this.abortController.signal
+      );
+      await this.api.uploadAttachment(created.upload_url, created.headers, bytes, this.abortController.signal);
+      await this.api.confirmAttachment(this.runId, id, { status: "uploaded", size_bytes: bytes.byteLength, ...dimensions ?? {} }).catch(() => {
+      });
+      return void 0;
+    } catch (error) {
+      if (this.isUnsupported(error)) {
+        this.attachmentsUnsupported = true;
+        this.log("warning", "anexos n\xE3o est\xE3o habilitados nesta instala\xE7\xE3o do Hobots \u2014 imagem n\xE3o enviada");
+        return "unsupported";
+      }
+      if (error instanceof TasksApiError && error.status === 429) {
+        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 a imagem: ${String(error)}`);
+      void this.api.confirmAttachment(this.runId, id, { status: "failed" }).catch(() => {
+      });
+      return "upload-failed";
+    } finally {
+      release();
+    }
+  }
+  /** 404 = API anterior ao recurso; 501/503 = instalação sem S3 configurado. */
+  isUnsupported(error) {
+    return error instanceof TasksApiError && (error.status === 404 || error.status === 501 || error.status === 503);
+  }
+  /** Semáforo simples: no máximo MAX_CONCURRENT_UPLOADS binários em voo por run. */
+  acquireUploadSlot() {
+    const release = () => {
+      const next = this.uploadQueue.shift();
+      if (next) next();
+      else this.uploadSlots++;
+    };
+    if (this.uploadSlots > 0) {
+      this.uploadSlots--;
+      return Promise.resolve(release);
     }
-    return batch.length;
+    return new Promise((resolve2) => {
+      this.uploadQueue.push(() => resolve2(release));
+    });
   }
-  /** Entrega já (com teto) o que está na fila do transport — as transactions parciais inclusive. */
-  async drain(timeoutMs) {
-    await this.client?.flush(timeoutMs);
+  /**
+   * Espera os uploads pendentes antes do PATCH terminal, para a run não terminar
+   * exibindo miniaturas em "enviando…". Capado: um upload lento não segura a run.
+   */
+  async finalizeAttachments(timeoutMs = ATTACHMENT_DRAIN_MS) {
+    if (this.pendingAttachments.size === 0) return;
+    await Promise.race([
+      Promise.allSettled([...this.pendingAttachments]),
+      new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
+    ]);
   }
-  payload(eventId, op, status, startTimestamp, timestamp, steps) {
-    return {
-      event_id: eventId,
-      name: this.name,
-      op,
-      status,
-      start_timestamp: startTimestamp,
-      timestamp,
-      steps: steps.map((step) => step.toJSON()),
-      tags: Object.keys(this.tags).length > 0 ? { ...this.tags } : void 0,
-      run_id: this.runId
-    };
+  enqueue(updateIn) {
+    if (this.dead) {
+      this.salvageLogs(updateIn.logs);
+      return;
+    }
+    this.clearProgressTimer();
+    const progress = this.takeProgress();
+    const update = progress ? { ...updateIn, progress } : updateIn;
+    this.pendingUpdates++;
+    this.chain = this.chain.then(async () => {
+      if (this.dead) {
+        this.salvageLogs(update.logs);
+        return;
+      }
+      const payload = update.logs && update.logs.length === 0 ? { ...update, logs: void 0 } : update;
+      try {
+        await this.api.updateRun(this.runId, payload);
+      } catch (error) {
+        if (error instanceof TasksApiError && (error.status === 409 || error.status === 404)) {
+          this.dead = true;
+          this.stopCancelWatch();
+          this.abort();
+          const pending = this.buffer.splice(0, this.buffer.length);
+          this.salvageLogs(pending);
+          this.logger.warn(
+            `run ${this.runId} cancelada/finalizada no servidor \u2014 status suprimido` + (pending.length > 0 ? `, ${pending.length} log(s) enviados como log tardio` : "")
+          );
+          return;
+        }
+        if (update.logs && update.logs.length > 0) {
+          this.buffer.unshift(...update.logs);
+          this.scheduleFlush();
+        }
+        if (update.progress && this.progressTotal != null) this.progressDirty = true;
+        this.logger.error(`update da run ${this.runId} perdido:`, error);
+      }
+    }).finally(() => {
+      this.pendingUpdates--;
+    });
   }
-  finish() {
-    if (this.finished) return;
-    this.finished = true;
-    for (const step of this.steps) step.succeeded();
-    const endTimestamp = nowISO();
-    this.emit(
-      "transaction",
-      "finish",
-      this.op ? `${this.name} (${this.op})` : this.name,
-      this.startTimestamp,
-      endTimestamp,
-      this.status
-    );
-    if (!this.client) return;
-    const steps = this.steps;
-    let first = 0;
-    while (steps.length - first > MAX_STEPS) {
-      const chunk = steps.slice(first, first + MAX_STEPS);
-      const status = chunk.some((step) => step.status === "error") ? "error" : "ok";
-      this.client.sendTransaction(this.payload(uuid4(), FLUSH_TRANSACTION_OP, status, chunk[0].startTimestamp, endTimestamp, chunk));
-      first += MAX_STEPS;
+  /**
+   * Best-effort de log tardio: envia logs para uma run já terminal, fora da fila.
+   * O servidor anexa os logs mesmo respondendo 409; erros são engolidos — este é
+   * o último recurso, não um canal confiável.
+   */
+  salvageLogs(logs) {
+    if (!logs || logs.length === 0) return;
+    for (let i = 0; i < logs.length; i += MAX_LOGS_PER_PATCH) {
+      void this.api.updateRunOnce(this.runId, { status: "running", logs: logs.slice(i, i + MAX_LOGS_PER_PATCH) }).catch(() => {
+      });
     }
-    this.client.sendTransaction(this.payload(this.eventId, this.op, this.status, this.startTimestamp, endTimestamp, steps.slice(first)));
   }
 };
 
@@ -2774,7 +3092,7 @@ var DEFAULT_RETRY_DELAY_MS = 5e3;
 async function executeRun(input) {
   const { run, handler, api, client, logger, tracker } = input;
   const options = handler.options;
-  const tx = new Transaction(client, "run", "hobots.run", run.id);
+  const tx = new Transaction(client, "run", "hobots.run", run.id, { echo: !client });
   const reporter = new RunReporter(
     api,
     run.id,
@@ -3014,42 +3332,26 @@ var TaskAgent = class {
   }
 };
 
-// src/tasks/attached.ts
-var START_RETRY_DELAYS_MS = [1e3, 4e3, 16e3];
-function isTransient(error) {
-  if (!(error instanceof TasksApiError)) return true;
-  return error.status >= 500 || error.status === 429;
-}
-function describeRejection(runId, error) {
-  if (error instanceof TasksApiError && error.status === 404) {
-    return `run ${runId} n\xE3o existe na plataforma (404) \u2014 nada a executar`;
-  }
-  if (error instanceof TasksApiError && error.status === 409) {
-    return `run ${runId} n\xE3o pode ser iniciada (409: cancelada, j\xE1 iniciada ou de outra inst\xE2ncia) \u2014 nada a executar`;
-  }
-  return `n\xE3o foi poss\xEDvel iniciar a run ${runId} (${String(error)}) \u2014 nada a executar`;
-}
-var AttachedRunner = class {
-  constructor(runId, handler, deps) {
-    this.runId = runId;
+// src/tasks/single-run.ts
+var SingleRunRunner = class {
+  constructor(handler, deps) {
     this.handler = handler;
     this.deps = deps;
     this.done = new Promise((resolve2) => {
       this.resolveDone = resolve2;
     });
   }
-  runId;
   handler;
   deps;
   abort = new AbortController();
-  /** Resolve quando a run terminou (ou não pôde ser iniciada, ou o runner foi parado antes). */
+  /** Resolve quando a run terminou (ou não pôde começar, ou o runner foi parado antes). */
   done;
   resolveDone;
   async run() {
     try {
-      const run = await this.startRun();
+      const run = await this.openRun();
       if (!run) return;
-      this.deps.logger.debug(`run ${run.id} iniciada (HOBOTS_RUN_ID)`);
+      this.deps.logger.debug(this.opened(run));
       await executeRun({
         run,
         handler: this.handler,
@@ -3064,11 +3366,37 @@ var AttachedRunner = class {
       this.resolveDone();
     }
   }
-  /** Desiste de iniciar a run (close() antes da plataforma responder). Uma run já iniciada segue pelo tracker. */
+  /** Desiste de obter a run (close() antes dela existir). Uma run já em execução segue pelo tracker. */
   stop() {
     this.abort.abort();
   }
-  async startRun() {
+};
+
+// src/tasks/attached.ts
+var START_RETRY_DELAYS_MS = [1e3, 4e3, 16e3];
+function isTransient(error) {
+  if (!(error instanceof TasksApiError)) return true;
+  return error.status >= 500 || error.status === 429;
+}
+function describeRejection(runId, error) {
+  if (error instanceof TasksApiError && error.status === 404) {
+    return `run ${runId} n\xE3o existe na plataforma (404) \u2014 nada a executar`;
+  }
+  if (error instanceof TasksApiError && error.status === 409) {
+    return `run ${runId} n\xE3o pode ser iniciada (409: cancelada, j\xE1 iniciada ou de outra inst\xE2ncia) \u2014 nada a executar`;
+  }
+  return `n\xE3o foi poss\xEDvel iniciar a run ${runId} (${String(error)}) \u2014 nada a executar`;
+}
+var AttachedRunner = class extends SingleRunRunner {
+  constructor(runId, handler, deps) {
+    super(handler, deps);
+    this.runId = runId;
+  }
+  runId;
+  opened(run) {
+    return `run ${run.id} iniciada (HOBOTS_RUN_ID)`;
+  }
+  async openRun() {
     for (let attempt = 0; ; attempt++) {
       if (this.abort.signal.aborted) return void 0;
       try {
@@ -3131,46 +3459,16 @@ function normalizeItemColumns(input, logger) {
 }
 
 // src/tasks/local.ts
-var LocalRunner = class {
+var LocalRunner = class extends SingleRunRunner {
+  backoff;
   constructor(handler, deps) {
-    this.handler = handler;
-    this.deps = deps;
+    super(handler, deps);
     this.backoff = new Backoff(deps.logger, "cria\xE7\xE3o da run");
-    this.done = new Promise((resolve2) => {
-      this.resolveDone = resolve2;
-    });
-  }
-  handler;
-  deps;
-  abort = new AbortController();
-  backoff;
-  /** Resolve quando a run terminou (ou o runner foi parado antes de abri-la). */
-  done;
-  resolveDone;
-  async run() {
-    try {
-      const run = await this.createRun();
-      if (!run) return;
-      this.deps.logger.debug(`run ${run.id} aberta (modo start)`);
-      await executeRun({
-        run,
-        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 execu\xE7\xE3o do agente:", error);
-    } finally {
-      this.resolveDone();
-    }
   }
-  /** Desiste de abrir a run (close() antes da plataforma responder). Uma run já aberta segue pelo tracker. */
-  stop() {
-    this.abort.abort();
+  opened(run) {
+    return `run ${run.id} aberta (modo start)`;
   }
-  async createRun() {
+  async openRun() {
     for (; ; ) {
       if (this.abort.signal.aborted) return void 0;
       try {
@@ -3183,6 +3481,133 @@ var LocalRunner = class {
   }
 };
 
+// src/tasks/local-transport.ts
+var LOCAL_RUN_ID = "local";
+var ITEM_LINE_PREFIX = "[hobots:item]";
+var SUMMARY_LINE_PREFIX = "[hobots:summary]";
+var ATTACHMENTS_DISCARDED_WARNING = "imagens e anexos n\xE3o s\xE3o enviados no modo local (descartados)";
+function unavailable(name) {
+  return new Error(`arquivo "${name}" enviado pela Central n\xE3o est\xE1 dispon\xEDvel no modo local`);
+}
+function cell(value) {
+  return (value ?? "").replace(/\r\n|[\t\r\n]/g, " ");
+}
+var LocalRunTransport = class {
+  constructor(params = {}, out = (line) => void process.stdout.write(`${line}
+`)) {
+    this.params = params;
+    this.out = out;
+  }
+  params;
+  out;
+  counts = { succeeded: 0, occurrence: 0, failed: 0 };
+  warnedAttachments = false;
+  /** Status terminal que o pipeline reportou — `undefined` enquanto a run corre (ou se ela nem reportou). */
+  terminalStatus;
+  async updateRun(_runId, update) {
+    if (update.status === "running") return;
+    this.terminalStatus = update.status;
+    if (update.status === "failed" && update.error && update.error.type !== "RunCanceled") {
+      printRunLog("error", `execu\xE7\xE3o falhou \u2014 ${update.error.type ?? "Error"}: ${update.error.message}`);
+      if (update.error.stack) console.error(update.error.stack);
+    }
+  }
+  async updateRunOnce() {
+  }
+  async createItems(_runId, request) {
+    for (const item of request.items) {
+      this.counts[item.status]++;
+      this.out(`${ITEM_LINE_PREFIX} ${item.status}	${cell(item.id)}	${cell(item.message)}`);
+    }
+    return { accepted: request.items.length, duplicates: 0 };
+  }
+  // modo local não tem trabalho anterior: nada a pular
+  async listDoneItems() {
+    return { ids: [], next: null };
+  }
+  /** Totais por status — chame uma vez, no fim da run, antes da linha de conclusão. */
+  printSummary() {
+    const { succeeded, occurrence, failed } = this.counts;
+    this.out(
+      `${SUMMARY_LINE_PREFIX} total=${succeeded + occurrence + failed} ok=${succeeded} avisos=${occurrence} falhas=${failed} pulados=0`
+    );
+  }
+  async createAttachment(_runId, request) {
+    if (!this.warnedAttachments) {
+      this.warnedAttachments = true;
+      printRunLog("warning", ATTACHMENTS_DISCARDED_WARNING);
+    }
+    return { id: request.id, upload_url: "", headers: {}, expires_in: 0 };
+  }
+  async uploadAttachment() {
+  }
+  async confirmAttachment() {
+  }
+  /** Nome do arquivo pelo id (nos params); sem ele, o próprio id. */
+  fileName(fileId) {
+    return collectFileRefs(this.params).find((ref) => ref.id === fileId)?.name ?? fileId;
+  }
+  async requestFileDownload(_runId, fileId) {
+    throw unavailable(this.fileName(fileId));
+  }
+  async fetchFile(url) {
+    throw unavailable(url);
+  }
+  async confirmFileDownload(_runId, fileId) {
+    throw unavailable(this.fileName(fileId));
+  }
+};
+
+// src/tasks/local-run.ts
+var LOCAL_RUN_EXIT_CODES = { succeeded: 0, failed: 1, canceled: 130 };
+var LOCAL_RUN_CANCEL_GRACE_MS = 4e3;
+var LOCAL_RUN_BANNER = "modo local \u2014 execu\xE7\xE3o sem a Central; params de HOBOTS_RUN_PARAMS";
+var LocalRunRunner = class extends SingleRunRunner {
+  constructor(params, handler, deps) {
+    super(handler, deps);
+    this.params = params;
+  }
+  params;
+  canceled = false;
+  startedAt = Date.now();
+  finished = false;
+  run() {
+    this.startedAt = Date.now();
+    return super.run();
+  }
+  opened() {
+    return "run local iniciada (HOBOTS_LOCAL_RUN)";
+  }
+  async openRun() {
+    if (this.abort.signal.aborted) return void 0;
+    return { id: LOCAL_RUN_ID, params: this.params, form: null, source: "local", created_at: nowISO() };
+  }
+  /** SIGINT/SIGTERM: dispara o `ctx.signal` da run em voo — o handler para no próximo ponto de parada. */
+  cancel() {
+    this.canceled = true;
+    this.deps.tracker.singleActive()?.abort();
+  }
+  /** Desfecho da run: cancelada pelo sinal, senão o status terminal reportado (sem reporte = falha). */
+  get outcome() {
+    if (this.canceled) return "canceled";
+    return this.deps.api.terminalStatus ?? "failed";
+  }
+  /**
+   * Fecha o relato no terminal — `[hobots:summary]` e a linha de conclusão — e devolve o
+   * desfecho. Idempotente: o runtime chama ao fim da run ou quando a graça do cancelamento
+   * esgota com o handler ainda rodando.
+   */
+  finish() {
+    const outcome = this.outcome;
+    if (this.finished) return outcome;
+    this.finished = true;
+    this.deps.api.printSummary();
+    const seconds = Math.round((Date.now() - this.startedAt) / 1e3);
+    printRunLog("info", `execu\xE7\xE3o local conclu\xEDda (${outcome}) em ${seconds}s`);
+    return outcome;
+  }
+};
+
 // src/tasks/registry.ts
 var RunTracker = class {
   constructor(api) {
@@ -3298,26 +3723,10 @@ function hostname() {
   if (!isNode()) return void 0;
   return process.env.HOSTNAME || process.env.COMPUTERNAME || void 0;
 }
-function createRuntime(options, handler) {
-  loadDotenv();
-  const config = resolveConfig({ clientSecret: options.clientSecret });
-  const logger = makeLogger(options.debug ?? false);
-  const environment = resolveEnvironmentOption(options.environment);
-  const client = new Client(
-    {
-      environment,
-      release: options.release,
-      tags: options.tags,
-      debug: options.debug,
-      captureRunErrors: options.captureUnhandled !== false
-    },
-    config
-  );
-  const api = new TasksApi({ baseUrl: config.runsBaseUrl, key: config.key, logger });
-  const rt = {
+function baseRuntime(options, handler, logger, api) {
+  return {
     options: { ...options, clientSecret: void 0 },
-    config,
-    client,
+    client: void 0,
     logger,
     api,
     handler,
@@ -3327,19 +3736,54 @@ function createRuntime(options, handler) {
     agent: void 0,
     local: void 0,
     attached: void 0,
+    localRun: void 0,
     runId: void 0,
     instanceId: resolveInstanceId(options.instanceId),
-    environment,
+    environment: void 0,
     pollIntervalMs: void 0,
     booted: false,
     bootScheduled: false,
     bootPromise: void 0,
-    uninstallGlobalHandlers: options.captureUnhandled !== false ? installGlobalHandlers(client) : void 0,
+    uninstallGlobalHandlers: void 0,
     uninstallShutdown: void 0
   };
+}
+function createRuntime(options, handler, logger) {
+  const config = resolveConfig({ clientSecret: options.clientSecret });
+  const environment = resolveEnvironmentOption(options.environment);
+  const client = new Client(
+    {
+      environment,
+      release: options.release,
+      tags: options.tags,
+      debug: options.debug,
+      captureRunErrors: options.captureUnhandled !== false
+    },
+    config
+  );
+  const api = new TasksApi({ baseUrl: config.runsBaseUrl, key: config.key, logger });
+  const rt = baseRuntime(options, handler, logger, api);
+  rt.client = client;
+  rt.environment = environment;
+  rt.uninstallGlobalHandlers = options.captureUnhandled !== false ? installGlobalHandlers(client) : void 0;
   logger.debug("inicializado", { endpoint: config.ingestEndpoint });
   return rt;
 }
+function createLocalRunRuntime(options, handler, logger) {
+  let params;
+  try {
+    params = resolveLocalRunParams();
+  } catch (error) {
+    printRunLog("error", error instanceof Error ? error.message : String(error));
+    process.exit(2);
+    throw error;
+  }
+  const transport = new LocalRunTransport(params);
+  const rt = baseRuntime(options, handler, logger, transport);
+  rt.localRun = new LocalRunRunner(params, handler, { api: transport, client: void 0, logger, tracker: rt.tracker });
+  printRunLog("info", LOCAL_RUN_BANNER);
+  return rt;
+}
 function validateHandler(handler, fn) {
   if (typeof handler !== "function") {
     throw new Error(`[hobots] ${fn}(): o handler precisa ser uma fun\xE7\xE3o \u2014 ${fn}(async (params) => { ... })`);
@@ -3382,9 +3826,12 @@ function instanceInfo(rt) {
     machine: rt.sampler?.sample()
   };
 }
+function platformApi(rt) {
+  return rt.api;
+}
 function ensureAgent(rt) {
   rt.agent ??= new TaskAgent({
-    api: rt.api,
+    api: platformApi(rt),
     client: rt.client,
     logger: rt.logger,
     handler: rt.handler,
@@ -3396,7 +3843,7 @@ function ensureAgent(rt) {
 }
 function launchLocal(rt) {
   const runner = new LocalRunner(rt.handler, {
-    api: rt.api,
+    api: platformApi(rt),
     client: rt.client,
     logger: rt.logger,
     tracker: rt.tracker,
@@ -3407,7 +3854,7 @@ function launchLocal(rt) {
 }
 function launchAttached(rt, runId) {
   const runner = new AttachedRunner(runId, rt.handler, {
-    api: rt.api,
+    api: platformApi(rt),
     client: rt.client,
     logger: rt.logger,
     tracker: rt.tracker,
@@ -3419,7 +3866,43 @@ function launchAttached(rt, runId) {
     if (runtime === rt) void close();
   });
 }
+function launchLocalRun(rt, runner) {
+  let finished = false;
+  const finish = () => {
+    if (finished) return;
+    finished = true;
+    rt.uninstallShutdown?.();
+    rt.uninstallShutdown = void 0;
+    const code = LOCAL_RUN_EXIT_CODES[runner.finish()];
+    if (runtime === rt) void close(0);
+    process.stdout.write("", () => process.exit(code));
+  };
+  if (rt.options.installExitHandlers !== false) {
+    let signaled = false;
+    const onSignal = (signal) => {
+      if (externalListenerCount(signal) > 0 || signaled) return;
+      signaled = true;
+      runner.cancel();
+      void Promise.race([runner.done, sleep(LOCAL_RUN_CANCEL_GRACE_MS)]).then(finish);
+    };
+    const onInt = markInternal(() => onSignal("SIGINT"));
+    const onTerm = markInternal(() => onSignal("SIGTERM"));
+    process.on("SIGINT", onInt);
+    process.on("SIGTERM", onTerm);
+    rt.uninstallShutdown = () => {
+      process.off("SIGINT", onInt);
+      process.off("SIGTERM", onTerm);
+    };
+  }
+  void runner.run();
+  void runner.done.then(finish);
+}
 async function boot(rt) {
+  if (rt.localRun) {
+    rt.booted = true;
+    launchLocalRun(rt, rt.localRun);
+    return;
+  }
   if (!rt.instanceId) {
     const id = await fallbackInstanceId();
     if (runtime !== rt) return;
@@ -3456,9 +3939,12 @@ function startAgent(fn, mode, handler, options) {
   }
   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;
-  if (mode === "remote") rt.runId = resolveRunId(options.runId);
+  loadDotenv();
+  const rt = isLocalRun() ? createLocalRunRuntime(options, agentHandler, logger) : createRuntime(options, agentHandler, logger);
+  if (!rt.localRun && mode === "remote") {
+    if (options.pollIntervalMs !== void 0) rt.pollIntervalMs = options.pollIntervalMs;
+    rt.runId = resolveRunId(options.runId);
+  }
   runtime = rt;
   scheduleBoot(rt);
 }
@@ -3481,10 +3967,10 @@ 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");
-    return;
+    return void 0;
   }
   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);
+  return reporter.log(toRunLogLevel(type), message, withMeta);
 }
 function captureException(error, hint) {
   const rt = runtime;
@@ -3495,13 +3981,19 @@ function captureException(error, hint) {
     }
     return void 0;
   }
+  let attachmentId;
   if (hint?.attachment) {
     const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-    forwardAttachment(rt, hint.attachment, message, hint.type ?? "error");
+    attachmentId = forwardAttachment(rt, hint.attachment, message, hint.type ?? "error");
+  }
+  if (!rt.client) {
+    rt.logger.debug("captureException ignorado no modo local (sem Central)");
+    return void 0;
   }
   const runId = currentReporter()?.runId;
   const withRun = runId ? { ...hint, tags: { run_id: runId, ...hint?.tags } } : hint;
-  return rt.client.captureException(error, withRun);
+  const contexts = runId && attachmentId ? { run: { id: runId, attachments: [attachmentId] } } : void 0;
+  return rt.client.captureException(error, withRun, contexts);
 }
 async function close(timeoutMs = 3e4) {
   const rt = runtime;
@@ -3511,6 +4003,7 @@ async function close(timeoutMs = 3e4) {
   if (rt.agent) await rt.agent.stop(0);
   rt.local?.stop();
   rt.attached?.stop();
+  rt.localRun?.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`);
@@ -3519,7 +4012,7 @@ async function close(timeoutMs = 3e4) {
   rt.heartbeat?.stop();
   rt.uninstallShutdown?.();
   rt.uninstallGlobalHandlers?.();
-  const flushed = await rt.client.close(timeoutMs);
+  const flushed = rt.client ? await rt.client.close(timeoutMs) : true;
   return idle && flushed;
 }
 
@@ -3548,11 +4041,19 @@ var noop = () => void 0;
 var fallbackEachSink = {
   report: noop,
   startStep: () => void 0,
+  stepScope: (_step, fn) => fn(),
   declareTotal: noop,
   advance: noop,
   checkCanceled: noop,
   isAborted: () => false,
-  logError: (message) => printRunLog("error", message)
+  /* v8 ignore start -- fora de uma run não há consulta de concluídos, logo nunca há item pulado para anunciar */
+  logInfo: (message) => printRunLog("info", message),
+  /* v8 ignore stop */
+  logWarning: (message) => printRunLog("warning", message),
+  logError: (message) => printRunLog("error", message),
+  sleep,
+  doneItemIds: () => Promise.resolve(void 0),
+  flush: () => Promise.resolve()
 };
 var fallbackItems = {
   add: noop,
@@ -3571,7 +4072,6 @@ var fallbackFiles = {
   read: outsideRunFiles
 };
 var neverAborts = new AbortController().signal;
-var detachedTransaction;
 function resolve(member) {
   const reporter = currentReporter();
   if (reporter) return reporter.context;
@@ -3592,8 +4092,12 @@ var hobots = Object.defineProperties({}, {
   items: getter("items", () => fallbackItems),
   progress: getter("progress", () => fallbackProgress),
   files: getter("files", () => fallbackFiles),
-  transaction: getter("transaction", () => detachedTransaction ??= new Transaction(void 0, "hobots.detached")),
   signal: getter("signal", () => neverAborts),
+  step: method((name, fn, options) => {
+    const ctx = resolve("step");
+    if (ctx) return ctx.step(name, fn, options);
+    return new Transaction(void 0, "hobots.detached").step(name, fn, options);
+  }),
   throwIfCanceled: method(() => resolve("throwIfCanceled")?.throwIfCanceled()),
   sleep: method((ms) => resolve("sleep")?.sleep(ms) ?? sleep(ms)),
   flush: method((timeoutMs) => resolve("flush")?.flush(timeoutMs) ?? Promise.resolve()),
@@ -3631,6 +4135,7 @@ var isFileRef2 = hobots.isFileRef;
 loadDotenv();
 var src_default = hobots;
 export {
+  Occurrence,
   captureException2 as captureException,
   close2 as close,
   src_default as default,