@h-ai/feedback 0.1.0-alpha.73 → 0.1.0-alpha.75

package/dist/index.js

@@ -1,13 +1,13 @@
-import { HaiFeedbackError, feedbackM, redactFeedbackText } from './chunk-PYKGS35A.js';
-export { HaiFeedbackError } from './chunk-PYKGS35A.js';
-import { createFeedbackBundle } from './chunk-5QWKURWU.js';
+import { HaiFeedbackError, feedbackM, redactFeedbackText } from './chunk-7W47WZXY.js';
+export { HaiFeedbackError } from './chunk-7W47WZXY.js';
+import { createFeedbackBundle } from './chunk-KGMLTOMM.js';
 import { z } from 'zod';
-import { resolveFeedbackBudget, FeedbackReportSchema, FeedbackEvidenceInputSchema, FeedbackExportInputSchema, FeedbackCompleteInputSchema, FeedbackAppendEvidenceInputSchema, FeedbackSetStatusInputSchema, FeedbackEvidenceQuerySchema, FeedbackEvidenceSchema, FeedbackListInputSchema, FeedbackSubmitInputSchema, FeedbackJobSchema, FeedbackHistorySchema, FeedbackAttachmentSchema, FeedbackUploadInputSchema } from '@h-ai/api-contract/feedback';
+import { resolveFeedbackBudget, FeedbackReportSchema, FeedbackEvidenceInputSchema, FeedbackExportInputSchema, FeedbackRetryInputSchema, FeedbackCompleteInputSchema, FeedbackAppendEvidenceInputSchema, FeedbackSetStatusInputSchema, FeedbackEvidenceQuerySchema, FeedbackEvidenceSchema, FeedbackListInputSchema, FeedbackSubmitInputSchema, FeedbackJobSchema, FeedbackHistorySchema, FeedbackAttachmentSchema, FeedbackUploadInputSchema, FeedbackAttachmentInputSchema } from '@h-ai/api-contract/feedback';
 import { core, ok, err } from '@h-ai/core';
 import { reldb, BaseReldbCrudRepository } from '@h-ai/reldb';
 import { storage } from '@h-ai/storage';
 import { Buffer } from 'buffer';
-import { randomUUID, createHash } from 'crypto';
+import { randomUUID, createHash, createHmac } from 'crypto';
 import { totalmem, arch, release, platform } from 'os';
 import process from 'process';
 
@@ -20,8 +20,10 @@ var FeedbackConfigSchema = z.strictObject({
   buildId: z.string().max(128).optional(),
   /** 源码提交标识，帮助定位对应代码。 */
   commit: z.string().max(128).optional(),
-  /** disabled 不通知，console 输出安全摘要，reach 使用已有通知通道。 */
+  /** disabled 不通知，console 默认仅输出元数据，reach 使用已有通知通道。 */
   notificationMode: z.enum(["disabled", "console", "reach"]).default("reach"),
+  /** console 通知内容；metadata 只输出定位和采集状态，summary 显式加入通用脱敏摘要。 */
+  consoleContent: z.enum(["metadata", "summary"]).default("metadata"),
   /** Reach 接收方，由实际 Provider 校验邮箱、手机号或业务目的地。 */
   recipients: z.array(z.string().min(1).max(320)).max(20).default([]),
   /** 已初始化 Reach Provider 的唯一名称，不限制为邮件。 */
@@ -30,14 +32,39 @@ var FeedbackConfigSchema = z.strictObject({
   adminUrl: z.url().refine((value) => ["http:", "https:"].includes(new URL(value).protocol)).optional(),
   /** 补充材料收集超时，单位毫秒；超时后冻结为完整或部分材料。 */
   collectionTimeoutMs: z.number().int().min(0).max(3e5).default(6e4),
+  /** 业务 collectEvidence 异步回调的等待上限，单位毫秒；超时后重试采集任务。 */
+  businessCollectionTimeoutMs: z.number().int().min(1).max(3e5).default(3e4),
+  /** 反馈采集结束后的 Webhook 地址；空字符串禁用，只允许可信 HTTP(S) 地址且不跟随重定向。 */
+  webhookUrl: z.string().max(2048).refine((value) => {
+    if (!value)
+      return true;
+    if (!URL.canParse(value))
+      return false;
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.hash;
+  }).default(""),
+  /** Webhook HMAC-SHA256 签名密钥；空字符串不签名，仅服务端私有环境配置。 */
+  webhookSecret: z.string().max(4096).default(""),
+  /** 单次 Webhook 请求超时，单位毫秒；非 2xx 或超时均进入持久重试。 */
+  webhookTimeoutMs: z.number().int().min(1).max(6e4).default(1e4),
   /** 持久任务扫描间隔，单位毫秒；零值由宿主手动运行任务。 */
   workerIntervalMs: z.number().int().min(0).max(6e4).default(1e3),
   /** 持久任务执行租约时长，单位毫秒；过期后允许其他实例接管。 */
   leaseMs: z.number().int().min(1e3).max(3e5).default(3e4),
-  /** 汇集、通知和导出任务最大尝试次数；到期清理持续重试。 */
+  /** 汇集、通知、Webhook 和导出任务最大尝试次数；到期清理持续重试。 */
   maxAttempts: z.number().int().min(1).max(20).default(5),
   /** 已受理反馈及对象附件的保留天数。 */
   retentionDays: z.number().int().min(1).max(3650).default(30),
+  /** 单个用户按数据库 UTC 日累计受理上限；幂等重试不重复计数。 */
+  maxReportsPerUserDay: z.number().int().min(1).max(1e4).default(20),
+  /** 单个用户每日预留存储字节（报告与最多历史导出）；默认 2 GiB。 */
+  maxBytesPerUserDay: z.number().int().min(4 * 1024 * 1024).max(1024 ** 4).default(2 * 1024 ** 3),
+  /** 应用内单个 scope 的持久材料预留容量；到期清理成功后释放，默认 10 GiB。 */
+  maxStoredBytesPerScope: z.number().int().min(4 * 1024 * 1024).max(1024 ** 4).default(10 * 1024 ** 3),
+  /** 单份报告最多历史导出数；已有有效快照复用，不重复计数。 */
+  maxExportsPerReport: z.number().int().min(1).max(20).default(5),
+  /** 已完成导出的有效小时数；过期禁止下载，后台删除对象，默认 24 小时。 */
+  exportRetentionHours: z.number().int().min(1).max(720).default(24),
   /** 允许采集的服务端环境变量名；凭据类名称仍按敏感信息策略排除。 */
   envAllowlist: z.array(z.string().min(1).max(128)).max(100).default([]),
   /** 未压缩导出总预算；客户端、附件总量和传输预算由此派生。 */
@@ -57,6 +84,7 @@ var EVIDENCE = "hai_feedback_evidence";
 var ATTACHMENTS = "hai_feedback_attachments";
 var HISTORY = "hai_feedback_history";
 var JOBS = "hai_feedback_jobs";
+var QUOTAS = "hai_feedback_quotas";
 var identityColumns = ["id", "report_id", "scope_id", "app_id", "user_id", "source", "request_id", "error_id", "client_id"];
 function feedbackTextEquals(column, value, params) {
   if (!identityColumns.includes(column))
@@ -95,7 +123,7 @@ function readFeedbackJson(value) {
   return typeof value === "string" ? JSON.parse(value) : value;
 }
 var FeedbackReportRepository = class extends BaseReldbCrudRepository {
-  tables = { reports: REPORTS, evidence: EVIDENCE, attachments: ATTACHMENTS, history: HISTORY, jobs: JOBS };
+  tables = { reports: REPORTS, evidence: EVIDENCE, attachments: ATTACHMENTS, history: HISTORY, jobs: JOBS, quotas: QUOTAS };
   constructor() {
     super(reldb, {
       table: REPORTS,
@@ -107,6 +135,18 @@ var FeedbackReportRepository = class extends BaseReldbCrudRepository {
     if (!report.success)
       return report;
     const definitions = [
+      [QUOTAS, {
+        id: { type: "TEXT", primaryKey: true },
+        app_id: { type: "TEXT", notNull: true },
+        scope_id: { type: "TEXT", notNull: true },
+        user_id: { type: "TEXT", notNull: true },
+        period: { type: "BIGINT", notNull: true },
+        report_count: { type: "BIGINT", notNull: true },
+        reserved_bytes: { type: "BIGINT", notNull: true },
+        report_bytes: { type: "BIGINT", notNull: true, defaultValue: 0 },
+        export_limit: { type: "INTEGER", notNull: true, defaultValue: 0 },
+        updated_at: { type: "BIGINT", notNull: true }
+      }],
       [EVIDENCE, {
         id: { type: "TEXT", primaryKey: true },
         report_id: { type: "TEXT" },
@@ -163,9 +203,11 @@ var FeedbackReportRepository = class extends BaseReldbCrudRepository {
         return created;
     }
     const indexes = [
+      { table: QUOTAS, name: "hai_feedback_quotas_expiry", columns: ["app_id", "period"] },
       { table: REPORTS, name: "hai_feedback_reports_scope_time", columns: ["scope_id", "created_at"] },
       { table: REPORTS, name: "hai_feedback_reports_scope_status", columns: ["scope_id", "status", "created_at"] },
       { table: EVIDENCE, name: "hai_feedback_evidence_report_seq", columns: ["report_id", "source", "sequence"] },
+      { table: EVIDENCE, name: "hai_feedback_evidence_temp_expiry", columns: ["app_id", "report_id", "expires_at"] },
       { table: EVIDENCE, name: "hai_feedback_evidence_temp_scope", columns: ["scope_id", "user_id", "timestamp"] },
       { table: ATTACHMENTS, name: "hai_feedback_attachments_report", columns: ["report_id"] },
       { table: HISTORY, name: "hai_feedback_history_report", columns: ["report_id"] },
@@ -270,28 +312,68 @@ function createFeedbackCapture(appId, envAllowlist, service) {
   let capacityLoss;
   let sequence = 0;
   let totalBytes = 0;
+  let pendingBytes = 0;
+  let failures = 0;
+  let retryAfter = 0;
   let stopped = false;
   let flushing = null;
-  async function flush() {
+  function removePending(key) {
+    const previous = pending.get(key);
+    if (previous)
+      pendingBytes -= previous.bytes;
+    pending.delete(key);
+  }
+  async function flush(force = false) {
     if (flushing)
       return flushing;
+    if (!force && retryAfter > Date.now())
+      return;
     flushing = core.context.run({ suppressLogObservers: true }, async () => {
-      for (const [key, item] of [...pending]) {
-        const current2 = await reldb.sql.get("SELECT id FROM hai_feedback_evidence WHERE id = ?", [key]);
+      const snapshot = [...pending];
+      let offset = 0;
+      while (offset < snapshot.length) {
+        const batch = [];
+        let bytes = 0;
+        while (offset < snapshot.length && batch.length < 32) {
+          const [key, item] = snapshot[offset];
+          if (batch.length && bytes + item.bytes > 256 * 1024)
+            break;
+          offset++;
+          if (item.event.timestamp < Date.now() - 5 * 6e4) {
+            removePending(key);
+            rememberLoss(item, "server_pending_evidence_expired");
+            continue;
+          }
+          batch.push([key, item]);
+          bytes += item.bytes;
+        }
+        if (!batch.length)
+          continue;
+        const current2 = await reldb.sql.query(`SELECT id FROM hai_feedback_evidence WHERE id IN (${batch.map(() => "?").join(",")})`, batch.map(([key]) => key));
         if (!current2.success) {
-          rememberLoss(item, "server_temporary_evidence_write_failed");
+          for (const [, item] of batch) rememberLoss(item, "server_temporary_evidence_write_failed");
+          retryAfter = Date.now() + Math.min(3e4, 250 * 2 ** Math.min(++failures, 7));
           return;
         }
-        if (!current2.data) {
-          const event = item.event;
-          const result = await reldb.sql.execute("INSERT INTO hai_feedback_evidence (id, report_id, scope_id, user_id, app_id, source, sequence, kind, timestamp, request_id, error_id, revision, bytes, expires_at, payload) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [key, null, item.scopeId, item.userId, appId, event.source, event.sequence, event.kind, event.timestamp, event.requestId ?? null, event.errorId ?? null, 1, item.bytes, Date.now() + 5 * 6e4, JSON.stringify(event)]);
+        const existing = new Set(current2.data.map((row) => row.id));
+        const additions = batch.filter(([key]) => !existing.has(key));
+        if (additions.length) {
+          const params = additions.flatMap(([key, item]) => {
+            const event = item.event;
+            return [key, null, item.scopeId, item.userId, appId, event.source, event.sequence, event.kind, event.timestamp, event.requestId ?? null, event.errorId ?? null, 1, item.bytes, event.timestamp + 5 * 6e4, JSON.stringify(event)];
+          });
+          const duplicate = reldb.config?.type === "mysql" ? "ON DUPLICATE KEY UPDATE id = id" : "ON CONFLICT (id) DO NOTHING";
+          const result = await reldb.sql.execute(`INSERT INTO hai_feedback_evidence (id, report_id, scope_id, user_id, app_id, source, sequence, kind, timestamp, request_id, error_id, revision, bytes, expires_at, payload) VALUES ${additions.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").join(",")} ${duplicate}`, params);
           if (!result.success) {
-            rememberLoss(item, "server_temporary_evidence_write_failed");
+            for (const [, item] of batch) rememberLoss(item, "server_temporary_evidence_write_failed");
+            retryAfter = Date.now() + Math.min(3e4, 250 * 2 ** Math.min(++failures, 7));
             return;
           }
         }
-        pending.delete(key);
+        for (const [key] of batch) removePending(key);
       }
+      failures = 0;
+      retryAfter = 0;
     }).finally(() => {
       flushing = null;
     });
@@ -301,7 +383,7 @@ function createFeedbackCapture(appId, envAllowlist, service) {
     for (const [key2, previous] of losses) {
       if (previous.event.timestamp < Date.now() - 5 * 6e4) {
         losses.delete(key2);
-        pending.delete(createHash("sha256").update(`${source}:${previous.event.sequence}`).digest("hex"));
+        removePending(createHash("sha256").update(`${source}:${previous.event.sequence}`).digest("hex"));
       }
     }
     if (capacityLoss && capacityLoss.timestamp < Date.now() - 5 * 6e4)
@@ -317,12 +399,21 @@ function createFeedbackCapture(appId, envAllowlist, service) {
     }
     const entry = { event, scopeId: item.scopeId, userId: item.userId, bytes: Buffer.byteLength(JSON.stringify(event)) };
     losses.set(key, entry);
-    pending.set(createHash("sha256").update(`${source}:${event.sequence}`).digest("hex"), entry);
+    if (pendingBytes + entry.bytes <= 8 * 1024 * 1024) {
+      pending.set(createHash("sha256").update(`${source}:${event.sequence}`).digest("hex"), entry);
+      pendingBytes += entry.bytes;
+    } else {
+      capacityLoss ??= { ...event, requestId: void 0, missingReason: "server_capture_capacity_exceeded" };
+    }
   }
   function pin(item, errorId) {
     if (item.event.kind === "error")
       item.event.errorId = item.event.id;
     else item.event.errorId ??= errorId;
+    const bytes = Buffer.byteLength(JSON.stringify(item.event));
+    if (item.buffered)
+      totalBytes += bytes - item.bytes;
+    item.bytes = bytes;
     const key = createHash("sha256").update(`${source}:${item.event.sequence}`).digest("hex");
     if (pending.has(key))
       return;
@@ -330,8 +421,13 @@ function createFeedbackCapture(appId, envAllowlist, service) {
       rememberLoss(item, "server_pending_evidence_overflow");
       return;
     }
+    if (pendingBytes + item.bytes > 8 * 1024 * 1024 - 128 * 1024) {
+      rememberLoss(item, "server_pending_evidence_bytes_exceeded");
+      return;
+    }
     const event = { ...item.event };
     pending.set(key, { ...item, event });
+    pendingBytes += item.bytes;
   }
   function observe(record) {
     if (stopped || record.context.module === "feedback")
@@ -369,9 +465,12 @@ function createFeedbackCapture(appId, envAllowlist, service) {
       else rememberLoss(item, "server_error_window_overflow");
     }
     buffer.push(item);
-    totalBytes += bytes;
+    item.buffered = true;
+    totalBytes += item.bytes;
     while (buffer.length > 1e4 || totalBytes > 16 * 1024 * 1024 || (buffer[0]?.event.timestamp ?? Date.now()) < Date.now() - 5 * 6e4) {
       const removed = buffer.shift();
+      if (removed)
+        removed.buffered = false;
       totalBytes -= removed?.bytes ?? 0;
       if (removed && removed.event.timestamp >= Date.now() - 5 * 6e4)
         rememberLoss(removed, "server_log_buffer_overflow");
@@ -384,7 +483,7 @@ function createFeedbackCapture(appId, envAllowlist, service) {
   timer.unref();
   return {
     async collect(scopeId, userId, anchor) {
-      await flush();
+      await flush(true);
       const params = [];
       const identity = `${feedbackTextEquals("app_id", appId, params)} AND ${feedbackTextEquals("scope_id", scopeId, params)} AND ${feedbackTextEquals("user_id", userId, params)}`;
       params.push(anchor - 5 * 6e4, anchor + 3e4);
@@ -446,7 +545,7 @@ function createFeedbackCapture(appId, envAllowlist, service) {
       stopped = true;
       stop();
       clearInterval(timer);
-      await flush();
+      await flush(true);
     }
   };
 }
@@ -489,13 +588,77 @@ function validActor(actor) {
 function escapeHtml(value) {
   return value.replace(/[&<>"']/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[character] ?? character);
 }
-function createFeedbackOperations(repo, config, capture) {
+function createFeedbackOperations(repo, config, capture, options = {}) {
   const budget = resolveFeedbackBudget(config);
   const table = repo.tables;
   const clock = feedbackClockSql();
   let stopped = false;
   let timer;
   let running = null;
+  let idleRounds = 0;
+  let cleanupBacklog = false;
+  let cleanupAfter = 0;
+  let wakePending = false;
+  const shutdown = new AbortController();
+  function schedule(delay) {
+    if (stopped || !config.workerIntervalMs)
+      return;
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      void tick();
+    }, delay);
+    timer.unref();
+  }
+  function wakeWorker() {
+    idleRounds = 0;
+    if (running)
+      wakePending = true;
+    else
+      schedule(config.workerIntervalMs);
+  }
+  async function tick() {
+    if (stopped)
+      return;
+    const result = await runJobs();
+    idleRounds = result.success && (result.data.processed > 0 || cleanupBacklog || wakePending) ? 0 : Math.min(idleRounds + 1, 10);
+    wakePending = false;
+    schedule(Math.min(3e4, config.workerIntervalMs * 2 ** idleRounds));
+  }
+  const collectEvidence = options.collectEvidence;
+  function quotaExceeded() {
+    return err(HaiFeedbackError.QUOTA_EXCEEDED, feedbackM("feedback_quotaExceeded"));
+  }
+  function scopeQuotaId(scopeId) {
+    return hash(JSON.stringify([config.appId, scopeId, "storage"]));
+  }
+  async function reserveQuota(tx, actor, reportId) {
+    const time = await tx.get(`SELECT ${clock} AS now`);
+    if (!time.success)
+      return time;
+    const now = Number(time.data?.now);
+    if (!Number.isFinite(now))
+      return failed();
+    const day = Math.floor(now / 864e5) * 864e5;
+    const bytes = budget.maxTotalBytes * (config.maxExportsPerReport + 1);
+    const buckets = [
+      { id: scopeQuotaId(actor.scopeId), period: 0, maxReports: Number.MAX_SAFE_INTEGER, maxBytes: config.maxStoredBytesPerScope },
+      { id: hash(JSON.stringify([config.appId, actor.scopeId, actor.userId, day])), period: day, maxReports: config.maxReportsPerUserDay, maxBytes: config.maxBytesPerUserDay }
+    ];
+    for (const bucket of buckets) {
+      const suffix = reldb.config?.type === "mysql" ? "ON DUPLICATE KEY UPDATE id = id" : "ON CONFLICT (id) DO NOTHING";
+      const inserted = await tx.execute(`INSERT INTO ${table.quotas} (id, app_id, scope_id, user_id, period, report_count, reserved_bytes, updated_at) VALUES (?, ?, ?, ?, ?, 0, 0, ?) ${suffix}`, [bucket.id, config.appId, actor.scopeId, bucket.period === 0 ? "" : actor.userId, bucket.period, now]);
+      if (!inserted.success)
+        return inserted;
+      const reserved = await tx.execute(`UPDATE ${table.quotas} SET report_count = report_count + 1, reserved_bytes = reserved_bytes + ?, updated_at = ? WHERE id = ? AND report_count < ? AND reserved_bytes <= ?`, [bytes, now, bucket.id, bucket.maxReports, bucket.maxBytes - bytes]);
+      if (!reserved.success)
+        return reserved;
+      if (!reserved.data.changes)
+        return quotaExceeded();
+    }
+    return tx.execute(`INSERT INTO ${table.quotas} (id, app_id, scope_id, user_id, period, report_count, reserved_bytes, report_bytes, export_limit, updated_at) VALUES (?, ?, ?, ?, -1, 1, ?, ?, ?, ?)`, [reportId, config.appId, actor.scopeId, actor.userId, bytes, budget.maxTotalBytes, config.maxExportsPerReport, now]);
+  }
   async function access(id, actor, permission, sql = reldb.sql) {
     if (!validActor(actor))
       return forbidden();
@@ -619,28 +782,25 @@ function createFeedbackOperations(repo, config, capture) {
     const result = await sql.query(`SELECT * FROM ${table.evidence} WHERE report_id = ? AND revision <= ? ORDER BY timestamp, source, sequence`, [id, revision]);
     return result.success ? ok(result.data.map((row) => FeedbackEvidenceSchema.parse({ ...FeedbackEvidenceInputSchema.parse(readFeedbackJson(row.payload)), feedbackId: id, revision: Number(row.revision) }))) : result;
   }
+  async function runJobs() {
+    if (stopped)
+      return err(HaiFeedbackError.NOT_INITIALIZED, feedbackM("feedback_notInitialized"));
+    if (running)
+      return running;
+    running = core.context.run({ suppressLogObservers: true }, processJobs).catch(failed).finally(() => {
+      running = null;
+    });
+    return running;
+  }
   const operations = {
     start() {
       if (!config.workerIntervalMs || stopped)
         return;
-      const tick = async () => {
-        if (stopped)
-          return;
-        await operations.runJobs();
-        if (!stopped) {
-          timer = setTimeout(() => {
-            void tick();
-          }, config.workerIntervalMs);
-          timer.unref();
-        }
-      };
-      timer = setTimeout(() => {
-        void tick();
-      }, config.workerIntervalMs);
-      timer.unref();
+      schedule(config.workerIntervalMs);
     },
     async close() {
       stopped = true;
+      shutdown.abort();
       if (timer)
         clearTimeout(timer);
       await running;
@@ -654,6 +814,8 @@ function createFeedbackOperations(repo, config, capture) {
       if (!parsed.success || parsed.data.appId !== config.appId)
         return invalid();
       const sanitized = FeedbackSubmitInputSchema.parse(sanitizeFeedbackValue(parsed.data));
+      if (sanitized.evidence?.some((event) => event.source.startsWith("server:")))
+        return invalid();
       const submissionKey = hash(JSON.stringify([actor.scopeId, actor.userId, config.appId, sanitized.submissionId]));
       const digest = hash(canonicalFeedbackJson(sanitized));
       const existing = await reldb.sql.get(`SELECT * FROM ${table.reports} WHERE submission_key = ?`, [submissionKey]);
@@ -694,13 +856,16 @@ function createFeedbackOperations(repo, config, capture) {
         const inserted = await repo.create({ ...row }, tx);
         if (!inserted.success)
           return inserted;
-        const initial = await appendInside(tx, row, sanitized.evidence ?? []);
+        const reservation = await reserveQuota(tx, actor, id);
+        if (!reservation.success)
+          return reservation;
+        const initial = await appendInside(tx, row, [...sanitized.evidence ?? [], capture.environment()], true);
         if (!initial.success)
           return initial;
         if ((sanitized.attachments ?? []).reduce((total, file) => total + file.size, 0) > budget.maxAttachmentsBytes)
           return limited();
         for (const attachment of sanitized.attachments ?? []) {
-          if (attachment.size > budget.maxAttachmentBytes || !allowedContentType(attachment.contentType))
+          if (attachment.id.startsWith("server:") || attachment.size > budget.maxAttachmentBytes || !allowedContentType(attachment.contentType))
             return invalid();
           const attachmentId = hash(`${id}:${attachment.id}`);
           const data = { ...attachment, feedbackId: id, status: "pending" };
@@ -713,7 +878,12 @@ function createFeedbackOperations(repo, config, capture) {
           if (!saved.success)
             return saved;
         }
-        const collected = await insertJob(tx, report, "collect", "initial", { anchor: sanitized.anchor?.timestamp ?? now }, row.collect_deadline);
+        if (config.webhookUrl) {
+          const webhook = await insertJob(tx, report, "webhook", "created", { url: config.webhookUrl }, row.collect_deadline);
+          if (!webhook.success)
+            return webhook;
+        }
+        const collected = await insertJob(tx, report, "collect", "initial", { anchor: sanitized.anchor?.timestamp ?? now, businessEvidence: !!collectEvidence }, row.collect_deadline);
         if (!collected.success)
           return collected;
         const cleanup = await insertJob(tx, report, "cleanup", "expiry", {}, row.expires_at);
@@ -731,9 +901,7 @@ function createFeedbackOperations(repo, config, capture) {
           return missing();
         return duplicate.data.submission_hash === digest ? ok(repo.report(duplicate.data)) : conflict();
       }
-      const environment = await appendInternal(id, actor, [capture.environment()]);
-      if (!environment.success)
-        core.logger.warn("Feedback environment collection deferred", { module: "feedback", feedbackId: id });
+      wakeWorker();
       const current2 = await repo.find(id, actor.scopeId);
       return current2.success && current2.data ? ok(repo.report(current2.data)) : result;
     },
@@ -900,7 +1068,7 @@ function createFeedbackOperations(repo, config, capture) {
         if (!saved.success)
           return saved;
       }
-      const next = await reldb.sql.execute(`UPDATE ${table.jobs} SET next_run_at = ${clock}, updated_at = ${clock} WHERE report_id = ? AND kind IN ('collect', 'notify') AND status = 'pending'`, [input.id]);
+      const next = await reldb.sql.execute(`UPDATE ${table.jobs} SET next_run_at = ${clock}, updated_at = ${clock} WHERE report_id = ? AND kind IN ('collect', 'notify', 'webhook') AND status = 'pending'`, [input.id]);
       return next.success ? ok(repo.report(row.data)) : next;
     },
     async uploadAttachment(input, actor) {
@@ -926,6 +1094,9 @@ function createFeedbackOperations(repo, config, capture) {
       return ok({ name: metadata.name, contentType: metadata.contentType, dataBase64: bytes.data.toString("base64") });
     },
     async retry(input, actor) {
+      const parsed = FeedbackRetryInputSchema.safeParse(input);
+      if (!parsed.success)
+        return invalid();
       const permission = input.target === "export" ? "feedback:export" : "feedback:process";
       const row = await access(input.id, actor, permission);
       if (!row.success)
@@ -942,13 +1113,15 @@ function createFeedbackOperations(repo, config, capture) {
         if (!resumed.success)
           return resumed;
       }
+      if (updated.success)
+        wakeWorker();
       return updated.success ? ok(void 0) : updated;
     },
     async export(input, actor) {
       const parsed = FeedbackExportInputSchema.safeParse(input);
       if (!parsed.success)
         return invalid();
-      return repo.transaction(async (tx) => {
+      const result = await repo.transaction(async (tx) => {
         const row = await access(input.id, actor, "feedback:export", tx);
         if (!row.success)
           return row;
@@ -962,12 +1135,20 @@ function createFeedbackOperations(repo, config, capture) {
         if (previous.data) {
           const snapshot = readFeedbackJson(previous.data.payload);
           const live = snapshot && typeof snapshot === "object" && "snapshotExpiresAt" in snapshot && typeof snapshot.snapshotExpiresAt === "number" && snapshot.snapshotExpiresAt > Date.now();
-          if (previous.data.status === "succeeded" || live)
+          if (previous.data.status === "succeeded" && Number(previous.data.created_at) + config.exportRetentionHours * 36e5 > Date.now() || previous.data.status !== "succeeded" && live)
             return ok(jobData(previous.data));
         }
         if (revision < Number(row.data.revision)) {
           return missing();
         }
+        const exports = await tx.get(`SELECT COUNT(*) AS count FROM ${table.jobs} WHERE report_id = ? AND kind = 'export'`, [input.id]);
+        if (!exports.success)
+          return exports;
+        const reservation = await tx.get(`SELECT report_bytes, export_limit FROM ${table.quotas} WHERE id = ?`, [input.id]);
+        if (!reservation.success)
+          return reservation;
+        if (!reservation.data || Number(exports.data?.count ?? 0) >= Math.min(config.maxExportsPerReport, Number(reservation.data.export_limit)))
+          return quotaExceeded();
         const events = await evidence(input.id, revision, tx);
         if (!events.success)
           return events;
@@ -978,12 +1159,15 @@ function createFeedbackOperations(repo, config, capture) {
         if (!changes.success)
           return changes;
         const suffix = `${revision}:${row.data.version}${previous.data ? `:${previous.data.id}` : ""}`;
-        const added = await insertJob(tx, repo.report(row.data), "export", suffix, { report: repo.report(row.data), evidence: events.data, attachments: files.data, history: changes.data, snapshotExpiresAt: Date.now() + 36e5 }, Date.now());
+        const added = await insertJob(tx, repo.report(row.data), "export", suffix, { report: repo.report(row.data), evidence: events.data, attachments: files.data, history: changes.data, maxBytes: Number(reservation.data.report_bytes), snapshotExpiresAt: Date.now() + 36e5 }, Date.now());
         if (!added.success)
           return added;
         const job = await tx.get(`SELECT * FROM ${table.jobs} WHERE id = ?`, [added.data]);
         return job.success && job.data ? ok(jobData(job.data)) : missing();
       });
+      if (result.success)
+        wakeWorker();
+      return result;
     },
     async getExport(input, actor) {
       const row = await access(input.id, actor, "feedback:export");
@@ -1004,6 +1188,8 @@ function createFeedbackOperations(repo, config, capture) {
           return missing();
         return err(HaiFeedbackError.CONFLICT, feedbackM("feedback_exportPending"));
       }
+      if (Number(job.data.created_at) + config.exportRetentionHours * 36e5 <= Date.now())
+        return missing();
       if (job.data.status === "failed")
         return failed();
       const data = readFeedbackJson(job.data.result);
@@ -1016,16 +1202,7 @@ function createFeedbackOperations(repo, config, capture) {
         return err(HaiFeedbackError.CHECKSUM_MISMATCH, feedbackM("feedback_checksumMismatch"));
       return ok({ name: `${repo.report(row.data).number}.zip`, contentType: "application/zip", dataBase64: bytes.data.toString("base64") });
     },
-    async runJobs() {
-      if (stopped)
-        return err(HaiFeedbackError.NOT_INITIALIZED, feedbackM("feedback_notInitialized"));
-      if (running)
-        return running;
-      running = core.context.run({ suppressLogObservers: true }, processJobs).catch(failed).finally(() => {
-        running = null;
-      });
-      return running;
-    }
+    runJobs
   };
   async function upload(input, actor) {
     const parsed = FeedbackUploadInputSchema.safeParse(input);
@@ -1084,6 +1261,124 @@ function createFeedbackOperations(repo, config, capture) {
     }
     return ok({ ...metadata, status: "available" });
   }
+  async function collectBusiness(job, report, actor) {
+    const marker = hash(`${report.id}:server:business:0`);
+    const previous = await reldb.sql.get(`SELECT id FROM ${table.evidence} WHERE id = ?`, [marker]);
+    if (!previous.success)
+      return previous;
+    if (previous.data)
+      return ok(void 0);
+    if (!collectEvidence)
+      return err(HaiFeedbackError.CONFIG_ERROR, feedbackM("feedback_configError"));
+    const controller = new AbortController();
+    const signal = AbortSignal.any([controller.signal, shutdown.signal]);
+    const timeout = setTimeout(() => controller.abort(), config.businessCollectionTimeoutMs);
+    timeout.unref();
+    let collected;
+    let onAbort;
+    try {
+      collected = await Promise.race([
+        Promise.resolve().then(() => collectEvidence({ report: Object.freeze({ ...report }), signal })),
+        new Promise((_resolve, reject) => {
+          onAbort = () => reject(new Error("Feedback business collection aborted"));
+          signal.addEventListener("abort", onAbort, { once: true });
+          if (signal.aborted)
+            onAbort();
+        })
+      ]);
+    } catch {
+      return failed();
+    } finally {
+      clearTimeout(timeout);
+      if (onAbort)
+        signal.removeEventListener("abort", onAbort);
+    }
+    if (!collected || typeof collected !== "object" || collected.text !== void 0 && typeof collected.text !== "string" || collected.attachments !== void 0 && !Array.isArray(collected.attachments))
+      return invalid();
+    if ((collected.attachments?.length ?? 0) > budget.maxAttachmentCount)
+      return limited();
+    const files = [];
+    for (const input of collected.attachments ?? []) {
+      if (!input || !(input.bytes instanceof Uint8Array) || typeof input.id !== "string" || input.id.length > 100)
+        return invalid();
+      if (input.bytes.byteLength > budget.maxAttachmentBytes)
+        return limited();
+      let bytes = Buffer.from(input.bytes);
+      if (!matchesContentType(bytes, input.contentType))
+        return invalid();
+      if (input.contentType === "text/plain")
+        bytes = Buffer.from(redactFeedbackText(bytes.toString("utf8")));
+      if (input.contentType === "application/json")
+        bytes = Buffer.from(JSON.stringify(sanitizeFeedbackValue(JSON.parse(bytes.toString("utf8")))));
+      if (bytes.length > budget.maxAttachmentBytes)
+        return limited();
+      const parsed = FeedbackAttachmentInputSchema.safeParse({ id: `server:business:${input.id}`, name: typeof input.name === "string" ? redactFeedbackText(input.name) : input.name, contentType: input.contentType, size: bytes.length, checksum: hash(bytes) });
+      if (!parsed.success || !input.id || files.some((file) => file.metadata.id === parsed.data.id))
+        return invalid();
+      const rowId = hash(`${report.id}:${parsed.data.id}`);
+      const key = `feedback/${hash(report.scopeId).slice(0, 16)}/${report.id}/business/${rowId}-${parsed.data.checksum}`;
+      files.push({ metadata: { ...parsed.data, feedbackId: report.id, status: "available" }, bytes, key, rowId });
+    }
+    const event = FeedbackEvidenceInputSchema.safeParse(sanitizeFeedbackValue({ id: `business-${report.id}`, source: "server:business", sequence: 0, kind: "business", timestamp: report.createdAt, data: { ...collected.data, ...collected.text !== void 0 ? { text: collected.text } : {}, attachmentIds: files.map((file) => file.metadata.id) } }));
+    if (!event.success)
+      return invalid();
+    async function checkCapacity(sql) {
+      const existing = await attachments(report.id, sql);
+      if (!existing.success)
+        return existing;
+      if (existing.data.length + files.length > budget.maxAttachmentCount || existing.data.reduce((total, item) => total + Number(item.size), 0) + files.reduce((total, file) => total + file.bytes.length, 0) > budget.maxAttachmentsBytes)
+        return limited();
+      return ok(void 0);
+    }
+    const frozenFiles = files.map((file) => ({ id: file.rowId, size: file.bytes.length, checksum: file.metadata.checksum })).sort((left, right) => left.id.localeCompare(right.id));
+    const frozen = await withLease(job, async (tx) => {
+      const current2 = await tx.get(`SELECT * FROM ${table.jobs} WHERE id = ?`, [job.id]);
+      if (!current2.success || !current2.data)
+        return missing();
+      const payload = readFeedbackJson(current2.data.payload);
+      if (!payload || typeof payload !== "object")
+        return invalid();
+      if ("businessFiles" in payload)
+        return canonicalFeedbackJson(payload.businessFiles) === canonicalFeedbackJson(frozenFiles) ? ok(void 0) : conflict();
+      const updated = await tx.execute(`UPDATE ${table.jobs} SET payload = ? WHERE id = ? AND token = ?`, [JSON.stringify({ ...payload, businessFiles: frozenFiles }), job.id, job.token]);
+      return updated.success ? ok(void 0) : updated;
+    });
+    if (!frozen.success)
+      return frozen;
+    const capacity = await checkCapacity(reldb.sql);
+    if (!capacity.success)
+      return capacity;
+    for (const file of files) {
+      const stored = await storage.file.put(file.key, file.bytes, { contentType: file.metadata.contentType, ifNoneMatch: "*", signal: AbortSignal.any([shutdown.signal, AbortSignal.timeout(3e4)]) });
+      if (!stored.success) {
+        const existing = await storage.file.get(file.key);
+        if (!existing.success || hash(existing.data) !== file.metadata.checksum)
+          return stored;
+      }
+    }
+    return withLease(job, async (tx) => {
+      const fresh = await access(report.id, actor, void 0, tx);
+      if (!fresh.success)
+        return fresh;
+      const completed = await tx.get(`SELECT id FROM ${table.evidence} WHERE id = ?`, [marker]);
+      if (!completed.success)
+        return completed;
+      if (completed.data)
+        return ok(void 0);
+      const capacity2 = await checkCapacity(tx);
+      if (!capacity2.success)
+        return capacity2;
+      const appended = await appendInside(tx, fresh.data, [event.data], true);
+      if (!appended.success)
+        return appended;
+      for (const file of files) {
+        const saved = await tx.execute(`INSERT INTO ${table.attachments} (id, client_id, report_id, scope_id, object_key, status, size, checksum, updated_at, payload) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [file.rowId, file.metadata.id, report.id, actor.scopeId, file.key, "available", file.bytes.length, file.metadata.checksum, Date.now(), JSON.stringify(file.metadata)]);
+        if (!saved.success)
+          return saved;
+      }
+      return ok(void 0);
+    });
+  }
   async function processJobs() {
     let processed = 0;
     const candidateParams = [];
@@ -1123,8 +1418,6 @@ function createFeedbackOperations(repo, config, capture) {
           if (!terminal.success)
             return terminal;
         }
-        if (!saved.data.changes && job.kind === "export" && result.success && result.data && typeof result.data === "object" && "key" in result.data && typeof result.data.key === "string")
-          await storage.file.delete(result.data.key);
         if (job.kind === "notify")
           await notificationSummary(job.report_id);
         processed++;
@@ -1136,8 +1429,47 @@ function createFeedbackOperations(repo, config, capture) {
         clearInterval(renewal);
       }
     }
-    const expired = await reldb.sql.execute(`DELETE FROM ${table.evidence} WHERE report_id IS NULL AND expires_at < ?`, [Date.now()]);
-    return expired.success ? ok({ processed }) : expired;
+    if (Date.now() >= cleanupAfter) {
+      const expiredExports = await reldb.sql.query(`SELECT * FROM ${table.jobs} WHERE app_id = ? AND kind = 'export' AND status = 'succeeded' AND created_at <= ${clock} - ? ORDER BY created_at, id LIMIT 20`, [config.appId, config.exportRetentionHours * 36e5]);
+      if (!expiredExports.success)
+        return expiredExports;
+      for (const job of expiredExports.data) {
+        if (job.app_id !== config.appId)
+          continue;
+        const result = readFeedbackJson(job.result);
+        if (result && typeof result === "object" && "key" in result && typeof result.key === "string") {
+          const deleted = await storage.file.delete(result.key);
+          if (!deleted.success)
+            return deleted;
+        }
+        const marked = await reldb.sql.execute(`UPDATE ${table.jobs} SET status = 'failed', result = NULL, payload = ?, last_error = ? WHERE id = ? AND status = 'succeeded'`, [JSON.stringify({ expired: true }), HaiFeedbackError.NOT_FOUND.code, job.id]);
+        if (!marked.success)
+          return marked;
+      }
+      const quotaRows = await reldb.sql.query(`SELECT id FROM ${table.quotas} WHERE app_id = ? AND period > 0 AND period < ${clock} - 172800000 ORDER BY period, id LIMIT 100`, [config.appId]);
+      if (!quotaRows.success)
+        return quotaRows;
+      if (quotaRows.data.length) {
+        const removed = await reldb.sql.execute(`DELETE FROM ${table.quotas} WHERE id IN (${quotaRows.data.map(() => "?").join(",")})`, quotaRows.data.map((row) => row.id));
+        if (!removed.success)
+          return removed;
+      }
+    }
+    if (Date.now() >= cleanupAfter) {
+      const params = [];
+      const identity = feedbackTextEquals("app_id", config.appId, params);
+      const expired = await reldb.sql.query(`SELECT id FROM ${table.evidence} WHERE ${identity} AND report_id IS NULL AND expires_at < ? ORDER BY expires_at, id LIMIT 100`, [...params, Date.now()]);
+      if (!expired.success)
+        return expired;
+      if (expired.data.length) {
+        const removed = await reldb.sql.execute(`DELETE FROM ${table.evidence} WHERE ${identity} AND report_id IS NULL AND id IN (${expired.data.map(() => "?").join(",")})`, [...params, ...expired.data.map((row) => row.id)]);
+        if (!removed.success)
+          return removed;
+      }
+      cleanupBacklog = expired.data.length === 100;
+      cleanupAfter = cleanupBacklog ? 0 : Date.now() + 3e4;
+    }
+    return ok({ processed });
   }
   async function executeJob(job) {
     if (job.app_id !== config.appId)
@@ -1174,6 +1506,11 @@ function createFeedbackOperations(repo, config, capture) {
       });
       if (!saved.success)
         return saved;
+      if ("businessEvidence" in payload && payload.businessEvidence === true) {
+        const business = await collectBusiness(job, report, actor);
+        if (!business.success)
+          return business;
+      }
       const files = await attachments(report.id);
       if (!files.success)
         return files;
@@ -1184,6 +1521,50 @@ function createFeedbackOperations(repo, config, capture) {
       const updated = await withLease(job, (tx) => tx.execute(`UPDATE ${table.reports} SET collection_status = ?, updated_at = ${clock} WHERE id = ?`, [partial ? "partial" : "complete", report.id]));
       return updated.success ? ok({ collected: captured.length }) : updated;
     }
+    if (job.kind === "webhook") {
+      if (!("url" in payload) || payload.url !== config.webhookUrl || !config.webhookUrl)
+        return err(HaiFeedbackError.CONFIG_ERROR, feedbackM("feedback_configError"));
+      if (report.collectionStatus === "collecting")
+        return ok({ pending: true });
+      const frozen = await withLease(job, async (tx) => {
+        const live = await access(report.id, actor, void 0, tx);
+        if (!live.success)
+          return live;
+        if (live.data.collection_status === "collecting")
+          return conflict();
+        const stored = await tx.get(`SELECT * FROM ${table.jobs} WHERE id = ?`, [job.id]);
+        if (!stored.success || !stored.data)
+          return missing();
+        const snapshot = readFeedbackJson(stored.data.payload);
+        if (snapshot && typeof snapshot === "object" && "body" in snapshot && typeof snapshot.body === "string")
+          return ok(snapshot.body);
+        const files = await attachments(report.id, tx);
+        if (!files.success)
+          return files;
+        const business = await tx.get(`SELECT id FROM ${table.evidence} WHERE id = ?`, [hash(`${report.id}:server:business:0`)]);
+        if (!business.success)
+          return business;
+        const detailUrl = config.adminUrl ? new URL(config.adminUrl) : void 0;
+        detailUrl?.searchParams.set("feedback", report.id);
+        const event = { event: "feedback.created", eventId: job.id, createdAt: report.createdAt, report: repo.report(live.data), evidence: { revision: Number(live.data.revision), business: !!business.data, attachments: files.data.map(attachmentData) }, ...detailUrl ? { detailUrl: detailUrl.href } : {} };
+        const body = JSON.stringify(event);
+        const saved = await tx.execute(`UPDATE ${table.jobs} SET payload = ? WHERE id = ? AND token = ?`, [JSON.stringify({ url: config.webhookUrl, body }), job.id, job.token]);
+        return saved.success ? ok(body) : saved;
+      });
+      if (!frozen.success)
+        return frozen;
+      const timestamp = String(Math.floor(Date.now() / 1e3));
+      const headers = { "content-type": "application/json", "idempotency-key": job.id, "x-hai-feedback-event": "feedback.created", "x-hai-feedback-timestamp": timestamp };
+      if (config.webhookSecret)
+        headers["x-hai-feedback-signature"] = `sha256=${createHmac("sha256", config.webhookSecret).update(`${timestamp}.${frozen.data}`).digest("hex")}`;
+      try {
+        const response = await fetch(config.webhookUrl, { method: "POST", headers, body: frozen.data, redirect: "manual", signal: AbortSignal.any([shutdown.signal, AbortSignal.timeout(config.webhookTimeoutMs)]) });
+        await response.body?.cancel();
+        return response.ok ? ok({ status: response.status }) : failed();
+      } catch {
+        return failed();
+      }
+    }
     if (job.kind === "notify") {
       if (config.notificationMode === "disabled")
         return ok({ disabled: true });
@@ -1195,7 +1576,7 @@ function createFeedbackOperations(repo, config, capture) {
         return live;
       const current2 = repo.report(live.data);
       if (config.notificationMode === "console") {
-        core.logger.info("Feedback notification", { module: "feedback", number: current2.number, appId: current2.appId, summary: current2.summary, collectionStatus: current2.collectionStatus });
+        core.logger.info("Feedback notification", { module: "feedback", number: current2.number, appId: current2.appId, appVersion: current2.appVersion, buildId: current2.buildId, commit: current2.commit, collectionStatus: current2.collectionStatus, ...config.consoleContent === "summary" ? { summary: current2.summary } : {} });
         return ok({ channel: "console" });
       }
       const { HaiReachError, reach } = await import('@h-ai/reach');
@@ -1226,6 +1607,8 @@ function createFeedbackOperations(repo, config, capture) {
       if (!("report" in payload) || !("evidence" in payload) || !("attachments" in payload))
         return invalid();
       const fixed = payload;
+      if (!Number.isSafeInteger(fixed.maxBytes) || fixed.maxBytes < 4 * 1024 * 1024 || fixed.maxBytes > 40 * 1024 * 1024)
+        return invalid();
       if (fixed.snapshotExpiresAt < Date.now())
         return missing();
       const files = [];
@@ -1245,12 +1628,17 @@ function createFeedbackOperations(repo, config, capture) {
         const info = attachmentData(file);
         files.push({ id: info.id, name: info.name, contentType: info.contentType, checksum: info.checksum, bytes: stored2.data });
       }
-      const bundle = await createFeedbackBundle({ maxBytes: budget.maxTotalBytes, report: fixed.report, evidence: fixed.evidence, history: fixed.history, attachments: files, missing: unavailable2 });
+      const bundle = await createFeedbackBundle({ maxBytes: fixed.maxBytes, createdAt: Number(job.created_at), report: fixed.report, evidence: fixed.evidence, history: fixed.history, attachments: files, missing: unavailable2 });
       if (!bundle.success)
         return bundle;
-      const key = `feedback/${hash(report.scopeId).slice(0, 16)}/${report.id}/exports/${job.id}-${job.token}.zip`;
+      const key = `feedback/${hash(report.scopeId).slice(0, 16)}/${report.id}/exports/${job.id}.zip`;
       const stored = await storage.file.put(key, bundle.data, { contentType: "application/zip", ifNoneMatch: "*" });
-      return stored.success ? ok({ key, checksum: hash(bundle.data), size: bundle.data.length }) : stored;
+      if (!stored.success) {
+        const existing = await storage.file.get(key);
+        if (!existing.success || hash(existing.data) !== hash(bundle.data))
+          return stored;
+      }
+      return ok({ key, checksum: hash(bundle.data), size: bundle.data.length });
     }
     const marked = await withLease(job, async (tx) => {
       const locked = await repo.find(report.id, report.scopeId, tx);
@@ -1279,6 +1667,17 @@ function createFeedbackOperations(repo, config, capture) {
         if (!removed2.success)
           return removed2;
       }
+      const reservation = await tx.get(`SELECT reserved_bytes FROM ${table.quotas} WHERE id = ?`, [report.id]);
+      if (!reservation.success)
+        return reservation;
+      if (reservation.data) {
+        const released = await tx.execute(`UPDATE ${table.quotas} SET report_count = report_count - 1, reserved_bytes = reserved_bytes - ?, updated_at = ${clock} WHERE id = ? AND reserved_bytes >= ? AND report_count > 0`, [Number(reservation.data.reserved_bytes), scopeQuotaId(report.scopeId), Number(reservation.data.reserved_bytes)]);
+        if (!released.success || !released.data.changes)
+          return released.success ? conflict() : released;
+        const removed2 = await tx.execute(`DELETE FROM ${table.quotas} WHERE id = ?`, [report.id]);
+        if (!removed2.success)
+          return removed2;
+      }
       const removedJobs = await tx.execute(`DELETE FROM ${table.jobs} WHERE report_id = ? AND id <> ?`, [report.id, job.id]);
       if (!removedJobs.success)
         return removedJobs;
@@ -1295,9 +1694,13 @@ function createFeedbackOperations(repo, config, capture) {
   return operations;
 }
 function allowedContentType(type) {
-  return ["image/png", "image/jpeg", "image/webp", "video/webm", "video/mp4", "text/plain", "application/json", "application/pdf"].includes(type);
+  return ["image/png", "image/jpeg", "image/webp", "video/webm", "video/mp4", "text/plain", "application/json", "application/pdf", "application/zip", "application/gzip"].includes(type);
 }
 function matchesContentType(bytes, type) {
+  if (type === "application/zip")
+    return bytes.length >= 4 && bytes[0] === 80 && bytes[1] === 75 && (bytes[2] === 3 && bytes[3] === 4 || bytes[2] === 5 && bytes[3] === 6);
+  if (type === "application/gzip")
+    return bytes.length >= 10 && bytes[0] === 31 && bytes[1] === 139 && bytes[2] === 8;
   if (type === "image/png")
     return bytes.length >= 24 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) && bytes.readUInt32BE(16) * bytes.readUInt32BE(20) <= 32 * 1024 * 1024;
   if (type === "image/jpeg")
@@ -1329,7 +1732,7 @@ var generation = 0;
 var initializing = false;
 var inFlight = /* @__PURE__ */ new Set();
 var feedback = {
-  async init(config) {
+  async init(config, options = {}) {
     if (initializing)
       return err(HaiFeedbackError.INIT_IN_PROGRESS, feedbackM("feedback_initInProgress"));
     initializing = true;
@@ -1339,6 +1742,8 @@ var feedback = {
       const parsed = FeedbackConfigSchema.safeParse(config);
       if (!parsed.success)
         return configFailure(parsed.error.issues.map((issue) => issue.path.join(".")));
+      if (options.collectEvidence !== void 0 && typeof options.collectEvidence !== "function")
+        return configFailure(["collectEvidence"]);
       if (!reldb.isInitialized || !storage.isInitialized)
         return configFailure([!reldb.isInitialized ? "reldb" : "storage"]);
       if (parsed.data.notificationMode === "reach") {
@@ -1354,8 +1759,9 @@ var feedback = {
       if (current) {
         const previous = current;
         current = null;
+        const closing = previous.operations.close();
         await Promise.allSettled([...inFlight]);
-        await previous.operations.close();
+        await closing;
         await previous.capture.close();
       }
       const repository = new FeedbackReportRepository();
@@ -1365,7 +1771,7 @@ var feedback = {
       if (epoch !== generation)
         return notInitialized.result();
       candidateCapture = createFeedbackCapture(parsed.data.appId, parsed.data.envAllowlist, { appVersion: parsed.data.appVersion, buildId: parsed.data.buildId, commit: parsed.data.commit });
-      const operations = createFeedbackOperations(repository, parsed.data, candidateCapture);
+      const operations = createFeedbackOperations(repository, parsed.data, candidateCapture, options);
       if (epoch !== generation) {
         await operations.close();
         await candidateCapture.close();
@@ -1387,12 +1793,11 @@ var feedback = {
     generation++;
     const previous = current;
     current = null;
-    await Promise.allSettled([...inFlight]);
-    if (!previous)
-      return ok(void 0);
     try {
-      await previous.operations.close();
-      await previous.capture.close();
+      const closing = previous?.operations.close();
+      await Promise.allSettled([...inFlight]);
+      await closing;
+      await previous?.capture.close();
       return ok(void 0);
     } catch {
       return err(HaiFeedbackError.OPERATION_FAILED, feedbackM("feedback_operationFailed"));