create-safest-tools 0.2.0

package/template/src/report-workflow.ts

@@ -0,0 +1,886 @@
+import { AUDIT_GENESIS_HASH, canonicalJson, hashAuditEntry } from "./audit";
+import { ApiError } from "./report-http";
+import { analystAvatarColor } from "./report-presence";
+import type { DeliveryJob, OperatorSession, ParticipantAudience, ReportState } from "./report-types";
+import type { AppealDecisionInput, DecisionInput, ReviewerMessageInput } from "./report-workflow-validation";
+
+interface WorkflowReportRow {
+  id: string;
+  public_reference: string;
+  state: ReportState;
+  queue_id: string | null;
+  queue_version_id: string | null;
+  policy_version_id: string | null;
+  target_reference: string;
+  owner_reference: string | null;
+  reporter_reference: string | null;
+}
+
+interface ClaimRow {
+  report_id: string;
+  reviewer_id: string;
+  claimed_at: string;
+  expires_at: string;
+  version: number;
+}
+
+function now(): string {
+  return new Date().toISOString();
+}
+
+function addMinutes(timestamp: string, minutes: number): string {
+  return new Date(Date.parse(timestamp) + minutes * 60_000).toISOString();
+}
+
+function parsedJson(value: unknown, fallback: unknown): unknown {
+  if (typeof value !== "string") return fallback;
+  try { return JSON.parse(value) as unknown; } catch { return fallback; }
+}
+
+function auditEvent(
+  db: D1Database,
+  input: {
+    idempotencyKey: string;
+    action: string;
+    actorType: string;
+    actorId: string;
+    targetType: string;
+    targetId: string;
+    details: unknown;
+    createdAt: string;
+  },
+): D1PreparedStatement {
+  return db.prepare(`
+    INSERT OR IGNORE INTO audit_events (
+      id, idempotency_key, action, actor_type, actor_id, target_type, target_id, details_json, created_at
+    ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
+  `).bind(
+    crypto.randomUUID(), input.idempotencyKey, input.action, input.actorType, input.actorId,
+    input.targetType, input.targetId, canonicalJson(input.details), input.createdAt,
+  );
+}
+
+async function workflowReport(db: D1Database, reportId: string): Promise<WorkflowReportRow | null> {
+  return db.prepare(`
+    SELECT r.id, r.public_reference, r.state, r.queue_id, r.queue_version_id, r.policy_version_id,
+           t.target_reference, t.owner_reference, p.reference AS reporter_reference
+    FROM reports r
+    JOIN report_targets t ON t.report_id = r.id
+    JOIN report_participants p ON p.report_id = r.id AND p.audience = 'reporter'
+    WHERE r.id = ?1
+    LIMIT 1
+  `).bind(reportId).first<WorkflowReportRow>();
+}
+
+async function requireActiveClaim(db: D1Database, reportId: string, reviewerId: string, at: string): Promise<ClaimRow> {
+  const claim = await db.prepare(`
+    SELECT report_id, reviewer_id, claimed_at, expires_at, version
+    FROM review_claims
+    WHERE report_id = ?1
+    LIMIT 1
+  `).bind(reportId).first<ClaimRow>();
+  if (!claim || claim.reviewer_id !== reviewerId || claim.expires_at <= at) {
+    throw new ApiError(409, "active_claim_required", "Claim this report before changing it.");
+  }
+  return claim;
+}
+
+export async function claimReport(
+  db: D1Database,
+  reportId: string,
+  session: OperatorSession,
+  claimTtlMinutes: number,
+): Promise<{ reviewerId: string; claimedAt: string; expiresAt: string; version: number }> {
+  const report = await workflowReport(db, reportId);
+  if (!report) throw new ApiError(404, "report_not_found", "The report does not exist.");
+  if (!["human_review", "awaiting_reporter", "human_review_requested"].includes(report.state)) {
+    throw new ApiError(409, "report_not_claimable", "The report is not in a claimable state.");
+  }
+  const claimedAt = now();
+  const expiresAt = addMinutes(claimedAt, Math.max(1, Math.min(1_440, claimTtlMinutes)));
+  await db.prepare(`
+    INSERT INTO review_claims (report_id, reviewer_id, claimed_at, expires_at, version)
+    VALUES (?1, ?2, ?3, ?4, 1)
+    ON CONFLICT(report_id) DO UPDATE SET
+      reviewer_id = excluded.reviewer_id,
+      claimed_at = excluded.claimed_at,
+      expires_at = excluded.expires_at,
+      version = review_claims.version + 1
+    WHERE review_claims.expires_at <= ?3 OR review_claims.reviewer_id = ?2
+  `).bind(reportId, session.actor.id, claimedAt, expiresAt).run();
+  const claim = await db.prepare(`
+    SELECT report_id, reviewer_id, claimed_at, expires_at, version
+    FROM review_claims WHERE report_id = ?1 LIMIT 1
+  `).bind(reportId).first<ClaimRow>();
+  if (!claim || claim.reviewer_id !== session.actor.id) {
+    throw new ApiError(409, "report_already_claimed", "Another reviewer currently holds this report.", {
+      expires_at: claim?.expires_at,
+    });
+  }
+  await db.batch([
+    auditEvent(db, {
+      idempotencyKey: `claim:${reportId}:${claim.version}`,
+      action: "report.claimed",
+      actorType: session.actor.type,
+      actorId: session.actor.id,
+      targetType: "report",
+      targetId: reportId,
+      details: { expiresAt: claim.expires_at, version: claim.version },
+      createdAt: claimedAt,
+    }),
+  ]);
+  return { reviewerId: claim.reviewer_id, claimedAt: claim.claimed_at, expiresAt: claim.expires_at, version: claim.version };
+}
+
+export async function releaseReportClaim(db: D1Database, reportId: string, session: OperatorSession): Promise<void> {
+  const claim = await db.prepare(`SELECT reviewer_id, version FROM review_claims WHERE report_id = ?1 LIMIT 1`)
+    .bind(reportId).first<{ reviewer_id: string; version: number }>();
+  if (!claim) return;
+  if (claim.reviewer_id !== session.actor.id && !session.permissions.manageConfiguration) {
+    throw new ApiError(409, "claim_owned_by_another_reviewer", "Only the current reviewer or an administrator can release this claim.");
+  }
+  const createdAt = now();
+  await db.batch([
+    db.prepare(`DELETE FROM review_claims WHERE report_id = ?1`).bind(reportId),
+    auditEvent(db, {
+      idempotencyKey: `claim-release:${reportId}:${claim.version}`,
+      action: "report.claim_released",
+      actorType: session.actor.type,
+      actorId: session.actor.id,
+      targetType: "report",
+      targetId: reportId,
+      details: { priorReviewerId: claim.reviewer_id, version: claim.version },
+      createdAt,
+    }),
+  ]);
+}
+
+export async function loadReportDetail(db: D1Database, reportId: string): Promise<Record<string, unknown> | null> {
+  const report = await db.prepare(`
+    SELECT r.id, r.public_reference AS reference, r.source, r.state, r.priority, r.reason_code AS reasonCode,
+           r.locale, r.queue_id AS queueId, r.submitted_at AS submittedAt, r.received_at AS receivedAt,
+           r.updated_at AS updatedAt, r.due_at AS dueAt, r.resolved_at AS resolvedAt,
+           r.policy_version_id AS policyVersionId, policy.title AS policyTitle,
+           policy.rules_json AS policyRulesJson, r.queue_version_id AS queuePolicyVersionId,
+           qv.management_mode AS queueManagementMode, qv.reviewer_instructions AS reviewerInstructions,
+           t.target_type AS targetType, t.target_reference AS targetReference,
+           t.owner_reference AS ownerReference, t.customer_url AS customerUrl,
+           p.reference AS reporterReference
+    FROM reports r
+    JOIN report_targets t ON t.report_id = r.id
+    JOIN report_participants p ON p.report_id = r.id AND p.audience = 'reporter'
+    LEFT JOIN policy_versions policy ON policy.id = r.policy_version_id
+    LEFT JOIN queue_versions qv ON qv.id = r.queue_version_id
+    WHERE r.id = ?1
+    LIMIT 1
+  `).bind(reportId).first<Record<string, unknown>>();
+  if (!report) return null;
+  const [answers, evidence, messages, decisions, actions, notices, aiRuns, history, claim, findings] = await Promise.all([
+    db.prepare(`SELECT field_key AS fieldKey, value_json AS valueJson FROM report_answers WHERE report_id = ?1 ORDER BY field_key`).bind(reportId).all<Record<string, unknown>>(),
+    db.prepare(`SELECT id, evidence_kind AS kind, reference, availability, created_at AS createdAt FROM evidence_references WHERE report_id = ?1 ORDER BY created_at, id`).bind(reportId).all<Record<string, unknown>>(),
+    db.prepare(`SELECT id, audience, direction, sender_type AS senderType, sender_id AS senderId, body, automated, delivery_state AS deliveryState, created_at AS createdAt FROM case_messages WHERE report_id = ?1 ORDER BY created_at, id LIMIT 500`).bind(reportId).all<Record<string, unknown>>(),
+    db.prepare(`SELECT id, decision_code AS decisionCode, policy_code AS policyCode, rationale, evidence_references_json AS evidenceReferencesJson, maker_type AS makerType, maker_id AS makerId, proposed_action_code AS proposedActionCode, created_at AS createdAt FROM decisions WHERE report_id = ?1 ORDER BY created_at DESC, id DESC`).bind(reportId).all<Record<string, unknown>>(),
+    db.prepare(`
+      SELECT id, decision_id AS decisionId, action_code AS actionCode, status, attempt_count AS attemptCount,
+        terminal, last_error_code AS errorCode, updated_at AS updatedAt
+      FROM decision_action_outbox WHERE report_id = ?1 ORDER BY created_at DESC, id DESC
+    `).bind(reportId).all<Record<string, unknown>>(),
+    db.prepare(`
+      SELECT id, decision_id AS decisionId, audience, delivery_state AS deliveryState, updated_at AS updatedAt
+      FROM notices WHERE report_id = ?1 ORDER BY created_at DESC, id DESC
+    `).bind(reportId).all<Record<string, unknown>>(),
+    db.prepare(`
+      SELECT ar.id, ar.status, ar.mode, ar.model, ar.prompt_version AS promptVersion,
+        ar.config_version_id AS configVersionId, ar.error_code AS errorCode,
+        ar.input_units AS inputUnits, ar.output_units AS outputUnits,
+        ar.estimated_cost_microusd AS estimatedCostMicrousd, ar.started_at AS startedAt,
+        ar.finished_at AS finishedAt, ai.outcome, ai.policy_code AS policyCode,
+        ai.summary, ai.confidence, ai.uncertain, ai.validation_state AS validationState,
+        ai.validation_errors_json AS validationErrorsJson
+      FROM ai_runs ar LEFT JOIN ai_results ai ON ai.ai_run_id = ar.id
+      WHERE ar.report_id = ?1 ORDER BY ar.started_at DESC, ar.id DESC
+    `).bind(reportId).all<Record<string, unknown>>(),
+    db.prepare(`SELECT id, from_state AS fromState, to_state AS toState, reason_code AS reasonCode, actor_type AS actorType, actor_id AS actorId, created_at AS createdAt FROM report_state_history WHERE report_id = ?1 ORDER BY created_at, id`).bind(reportId).all<Record<string, unknown>>(),
+    db.prepare(`
+      SELECT c.reviewer_id AS reviewerId, c.claimed_at AS claimedAt, c.expires_at AS expiresAt, c.version,
+             p.display_name AS analystDisplayName, p.avatar_url AS analystAvatarUrl,
+             p.avatar_color AS analystAvatarColor
+      FROM review_claims c
+      LEFT JOIN analyst_profiles p ON p.actor_id = c.reviewer_id
+      WHERE c.report_id = ?1 AND c.expires_at > ?2
+      LIMIT 1
+    `).bind(reportId, now()).first<Record<string, unknown>>(),
+    db.prepare(`
+      SELECT f.id, f.run_id AS runId, f.step_run_id AS stepRunId,
+        f.component_version_id AS componentVersionId, f.ai_run_id AS aiRunId,
+        f.finding_type AS findingType, f.subject_type AS subjectType,
+        f.subject_reference AS subjectReference, f.status, f.confidence, f.summary,
+        f.data_json AS dataJson, f.provenance_json AS provenanceJson,
+        f.uncertainty_json AS uncertaintyJson, f.input_digest AS inputDigest,
+        f.output_digest AS outputDigest, f.expires_at AS expiresAt,
+        f.created_at AS createdAt, f.superseded_at AS supersededAt,
+        cv.version AS componentVersion, cd.component_key AS componentKey
+      FROM findings f
+      LEFT JOIN component_versions cv ON cv.id = f.component_version_id
+      LEFT JOIN component_definitions cd ON cd.id = cv.definition_id
+      WHERE f.report_id = ?1 ORDER BY f.created_at DESC, f.id DESC
+      LIMIT 500
+    `).bind(reportId).all<Record<string, unknown>>(),
+  ]);
+  return {
+    ...report,
+    policyRules: (() => {
+      try {
+        const value: unknown = JSON.parse(String(report.policyRulesJson ?? "[]"));
+        return Array.isArray(value) ? value : [];
+      } catch { return []; }
+    })(),
+    policyRulesJson: undefined,
+    answers: answers.results.map((row) => ({ fieldKey: row.fieldKey, value: JSON.parse(String(row.valueJson)) })),
+    evidence: evidence.results,
+    messages: messages.results.map((row) => ({ ...row, automated: row.automated === 1 })),
+    decisions: decisions.results.map((row) => ({
+      ...row,
+      evidenceReferences: JSON.parse(String(row.evidenceReferencesJson)),
+      evidenceReferencesJson: undefined,
+    })),
+    actions: actions.results.map((row) => ({ ...row, terminal: row.terminal === 1 })),
+    notices: notices.results,
+    aiRuns: aiRuns.results.map((row) => ({
+      ...row,
+      uncertain: row.uncertain === 1,
+      validationErrors: row.validationErrorsJson ? JSON.parse(String(row.validationErrorsJson)) : [],
+      validationErrorsJson: undefined,
+    })),
+    history: history.results,
+    findings: findings.results.map((row) => ({
+      ...row,
+      freshness: row.status === "available" && row.expiresAt && String(row.expiresAt) <= now() ? "stale" : row.status,
+      data: parsedJson(row.dataJson, {}),
+      provenance: parsedJson(row.provenanceJson, {}),
+      uncertainty: parsedJson(row.uncertaintyJson, []),
+      dataJson: undefined,
+      provenanceJson: undefined,
+      uncertaintyJson: undefined,
+    })),
+    claim: claim ? {
+      reviewerId: claim.reviewerId,
+      claimedAt: claim.claimedAt,
+      expiresAt: claim.expiresAt,
+      version: claim.version,
+      analyst: {
+        displayName: claim.analystDisplayName ?? claim.reviewerId,
+        avatarUrl: claim.analystAvatarUrl ?? null,
+        avatarColor: claim.analystAvatarColor ?? analystAvatarColor(String(claim.reviewerId)),
+      },
+    } : null,
+  };
+}
+
+export interface WorkflowDeliveryOptions {
+  notificationEnabled: boolean;
+}
+
+export async function addReviewerMessage(
+  db: D1Database,
+  reportId: string,
+  session: OperatorSession,
+  input: ReviewerMessageInput,
+  options: WorkflowDeliveryOptions,
+): Promise<{ messageId: string; jobs: DeliveryJob[]; idempotentReplay: boolean }> {
+  const existing = await db.prepare(`
+    SELECT id FROM case_messages WHERE report_id = ?1 AND idempotency_key = ?2 LIMIT 1
+  `).bind(reportId, input.idempotencyKey).first<{ id: string }>();
+  if (existing) return { messageId: existing.id, jobs: [], idempotentReplay: true };
+  const createdAt = now();
+  await requireActiveClaim(db, reportId, session.actor.id, createdAt);
+  const report = await workflowReport(db, reportId);
+  if (!report) throw new ApiError(404, "report_not_found", "The report does not exist.");
+  if (["closed", "resolved_by_human", "resolved_by_ai", "appealed"].includes(report.state)) {
+    throw new ApiError(409, "report_not_messageable", "The report is no longer open for reviewer messages.");
+  }
+  const messageId = crypto.randomUUID();
+  const noticeId = crypto.randomUUID();
+  const notificationId = crypto.randomUUID();
+  const nextState: ReportState = input.awaitReporter ? "awaiting_reporter" : report.state;
+  const jobs: DeliveryJob[] = options.notificationEnabled
+    ? [{ version: 1, jobId: `notification:${notificationId}`, type: "deliver_notification", outboxId: notificationId }]
+    : [];
+  const statements: D1PreparedStatement[] = [
+    db.prepare(`
+      INSERT INTO case_messages (
+        id, report_id, audience, direction, sender_type, sender_id, body, template_version_id,
+        automated, delivery_state, created_at, idempotency_key
+      ) VALUES (?1, ?2, 'reporter', 'outbound', 'human', ?3, ?4, 'reporter-follow-up-v1', 0, ?5, ?6, ?7)
+    `).bind(messageId, reportId, session.actor.id, input.body, options.notificationEnabled ? "queued" : "suppressed", createdAt, input.idempotencyKey),
+    db.prepare(`
+      INSERT INTO notices (
+        id, report_id, audience, template_version_id, rendered_body, delivery_state,
+        created_at, updated_at, idempotency_key, message_id
+      ) VALUES (?1, ?2, 'reporter', 'reporter-follow-up-v1', ?3, ?4, ?5, ?5, ?6, ?7)
+    `).bind(noticeId, reportId, input.body, options.notificationEnabled ? "queued" : "suppressed", createdAt, input.idempotencyKey, messageId),
+    auditEvent(db, {
+      idempotencyKey: `reviewer-message:${reportId}:${input.idempotencyKey}`,
+      action: "report.reporter_message_created",
+      actorType: session.actor.type,
+      actorId: session.actor.id,
+      targetType: "report",
+      targetId: reportId,
+      details: { messageId, audience: "reporter", nextState },
+      createdAt,
+    }),
+  ];
+  if (nextState !== report.state) {
+    statements.push(
+      db.prepare(`UPDATE reports SET state = ?2, updated_at = ?3 WHERE id = ?1`).bind(reportId, nextState, createdAt),
+      db.prepare(`
+        INSERT INTO report_state_history (id, report_id, from_state, to_state, reason_code, actor_type, actor_id, created_at)
+        VALUES (?1, ?2, ?3, ?4, 'reviewer_requested_information', ?5, ?6, ?7)
+      `).bind(crypto.randomUUID(), reportId, report.state, nextState, session.actor.type, session.actor.id, createdAt),
+    );
+  }
+  if (options.notificationEnabled) {
+    statements.push(db.prepare(`
+      INSERT INTO notification_outbox (
+        id, notice_id, idempotency_key, channel, payload_json, status, next_attempt_at, created_at, updated_at
+      ) VALUES (?1, ?2, ?3, 'customer_webhook', ?4, 'pending', ?5, ?5, ?5)
+    `).bind(notificationId, noticeId, `notice:${noticeId}`, canonicalJson({
+      version: 1,
+      event: "report.message.available",
+      notification_id: notificationId,
+      report_reference: report.public_reference,
+      ...(report.reporter_reference ? { recipient_reference: report.reporter_reference } : {}),
+      audience: "reporter",
+      message: input.body,
+    }), createdAt));
+  }
+  await db.batch(statements);
+  return { messageId, jobs, idempotentReplay: false };
+}
+
+
+export interface DecisionOptions extends WorkflowDeliveryOptions {
+  allowedActionCodes: Set<string>;
+  actionEnabled: boolean;
+}
+
+export async function recordHumanDecision(
+  db: D1Database,
+  reportId: string,
+  session: OperatorSession,
+  input: DecisionInput,
+  options: DecisionOptions,
+): Promise<{ decisionId: string; jobs: DeliveryJob[]; idempotentReplay: boolean }> {
+  const existing = await db.prepare(`
+    SELECT id FROM decisions WHERE report_id = ?1 AND idempotency_key = ?2 LIMIT 1
+  `).bind(reportId, input.idempotencyKey).first<{ id: string }>();
+  if (existing) return { decisionId: existing.id, jobs: [], idempotentReplay: true };
+  const createdAt = now();
+  await requireActiveClaim(db, reportId, session.actor.id, createdAt);
+  const report = await workflowReport(db, reportId);
+  if (!report) throw new ApiError(404, "report_not_found", "The report does not exist.");
+  if (!["human_review", "awaiting_reporter", "human_review_requested"].includes(report.state)) {
+    throw new ApiError(409, "report_not_decidable", "The report is not awaiting a human decision.");
+  }
+  if (!report.policy_version_id) throw new ApiError(409, "policy_version_missing", "The report has no selected policy version.");
+  const policy = await db.prepare(`SELECT rules_json FROM policy_versions WHERE id = ?1 AND published_at IS NOT NULL LIMIT 1`)
+    .bind(report.policy_version_id).first<{ rules_json: string }>();
+  const policyCodes = new Set<unknown>();
+  try {
+    const rules: unknown = JSON.parse(policy?.rules_json ?? "[]");
+    if (Array.isArray(rules)) rules.forEach((rule) => {
+      if (rule && typeof rule === "object" && !Array.isArray(rule)) policyCodes.add((rule as Record<string, unknown>).code);
+    });
+  } catch {
+    throw new ApiError(409, "policy_version_invalid", "The selected policy version cannot be used.");
+  }
+  if (!policyCodes.has(input.policyCode)) throw new ApiError(400, "policy_code_not_found", "The selected policy code is not in the report policy version.");
+  const evidence = await db.prepare(`SELECT reference FROM evidence_references WHERE report_id = ?1`)
+    .bind(reportId).all<{ reference: string }>();
+  const availableEvidence = new Set(evidence.results.map((item) => item.reference));
+  if (input.evidenceReferences.some((reference) => !availableEvidence.has(reference))) {
+    throw new ApiError(400, "evidence_reference_not_found", "Every considered evidence reference must belong to this report.");
+  }
+  if (input.actionCode && (!options.actionEnabled || !options.allowedActionCodes.has(input.actionCode))) {
+    throw new ApiError(400, "action_not_allowed", "The requested application action is not allowlisted for this deployment.");
+  }
+  if (input.affectedUserNotice && !report.owner_reference) {
+    throw new ApiError(400, "affected_user_reference_missing", "The report target has no affected-user reference for this notice.");
+  }
+  const superseded = report.state === "human_review_requested"
+    ? await db.prepare(`SELECT id FROM decisions WHERE report_id = ?1 ORDER BY created_at DESC, id DESC LIMIT 1`)
+      .bind(reportId).first<{ id: string }>()
+    : null;
+
+  const decisionId = crypto.randomUUID();
+  const reporterMessageId = crypto.randomUUID();
+  const reporterNoticeId = crypto.randomUUID();
+  const reporterNotificationId = crypto.randomUUID();
+  const actionId = input.actionCode ? crypto.randomUUID() : null;
+  const jobs: DeliveryJob[] = [];
+  const statements: D1PreparedStatement[] = [
+    db.prepare(`
+      INSERT INTO decisions (
+        id, report_id, decision_code, policy_version_id, policy_code, rationale,
+        evidence_references_json, maker_type, maker_id, queue_version_id, proposed_action_code, created_at, idempotency_key,
+        supersedes_decision_id
+      ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, 'human', ?8, ?9, ?10, ?11, ?12, ?13)
+    `).bind(
+      decisionId, reportId, input.decisionCode, report.policy_version_id, input.policyCode, input.rationale,
+      canonicalJson(input.evidenceReferences), session.actor.id, report.queue_version_id, input.actionCode ?? null, createdAt, input.idempotencyKey,
+      superseded?.id ?? null,
+    ),
+    db.prepare(`
+      INSERT INTO case_messages (
+        id, report_id, audience, direction, sender_type, sender_id, body, template_version_id,
+        automated, delivery_state, created_at, idempotency_key
+      ) VALUES (?1, ?2, 'reporter', 'outbound', 'human', ?3, ?4, 'reporter-outcome-v1', 0, ?5, ?6, ?7)
+    `).bind(reporterMessageId, reportId, session.actor.id, input.reporterNotice, options.notificationEnabled ? "queued" : "suppressed", createdAt, `decision:${decisionId}:reporter-message`),
+    db.prepare(`
+      INSERT INTO notices (
+        id, report_id, decision_id, audience, template_version_id, rendered_body,
+        delivery_state, created_at, updated_at, idempotency_key, message_id
+      ) VALUES (?1, ?2, ?3, 'reporter', 'reporter-outcome-v1', ?4, ?5, ?6, ?6, ?7, ?8)
+    `).bind(reporterNoticeId, reportId, decisionId, input.reporterNotice, options.notificationEnabled ? "queued" : "suppressed", createdAt, `decision:${decisionId}:reporter-notice`, reporterMessageId),
+    db.prepare(`
+      UPDATE reports SET state = 'resolved_by_human', resolved_at = ?2, updated_at = ?2 WHERE id = ?1
+    `).bind(reportId, createdAt),
+    db.prepare(`
+      INSERT INTO report_state_history (id, report_id, from_state, to_state, reason_code, actor_type, actor_id, created_at)
+      VALUES (?1, ?2, ?3, 'resolved_by_human', ?4, ?5, ?6, ?7)
+    `).bind(crypto.randomUUID(), reportId, report.state, input.decisionCode, session.actor.type, session.actor.id, createdAt),
+    db.prepare(`DELETE FROM review_claims WHERE report_id = ?1`).bind(reportId),
+    auditEvent(db, {
+      idempotencyKey: `decision:${reportId}:${input.idempotencyKey}`,
+      action: "report.human_decision_recorded",
+      actorType: session.actor.type,
+      actorId: session.actor.id,
+      targetType: "decision",
+      targetId: decisionId,
+      details: {
+        reportId, decisionCode: input.decisionCode, policyVersionId: report.policy_version_id,
+        policyCode: input.policyCode, queueVersionId: report.queue_version_id, evidenceReferences: input.evidenceReferences,
+        actionCode: input.actionCode ?? null,
+      },
+      createdAt,
+    }),
+    db.prepare(`
+      INSERT OR IGNORE INTO ai_quality_samples (id, ai_run_id, report_id, sample_reason, state, selected_at)
+      SELECT ?2, ar.id, ?1,
+        CASE ar.mode WHEN 'shadow' THEN 'shadow_human_comparison' ELSE 'assist_human_comparison' END,
+        'pending', ?3
+      FROM ai_runs ar
+      WHERE ar.report_id = ?1 AND ar.mode IN ('shadow', 'assist') AND ar.status = 'succeeded'
+      ORDER BY ar.started_at DESC, ar.id DESC LIMIT 1
+    `).bind(reportId, crypto.randomUUID(), createdAt),
+  ];
+
+  if (options.notificationEnabled) {
+    statements.push(db.prepare(`
+      INSERT INTO notification_outbox (
+        id, notice_id, idempotency_key, channel, payload_json, status, next_attempt_at, created_at, updated_at
+      ) VALUES (?1, ?2, ?3, 'customer_webhook', ?4, 'pending', ?5, ?5, ?5)
+    `).bind(reporterNotificationId, reporterNoticeId, `notice:${reporterNoticeId}`, canonicalJson({
+      version: 1,
+      event: "report.outcome.available",
+      notification_id: reporterNotificationId,
+      report_reference: report.public_reference,
+      ...(report.reporter_reference ? { recipient_reference: report.reporter_reference } : {}),
+      audience: "reporter",
+      message: input.reporterNotice,
+    }), createdAt));
+    jobs.push({ version: 1, jobId: `notification:${reporterNotificationId}`, type: "deliver_notification", outboxId: reporterNotificationId });
+  }
+
+  if (input.affectedUserNotice && report.owner_reference) {
+    const affectedMessageId = crypto.randomUUID();
+    const affectedNoticeId = crypto.randomUUID();
+    const affectedNotificationId = crypto.randomUUID();
+    statements.push(
+      db.prepare(`
+        INSERT OR IGNORE INTO report_participants (id, report_id, audience, reference, contact_mode, created_at)
+        VALUES (?1, ?2, 'affected_user', ?3, 'customer_notification', ?4)
+      `).bind(crypto.randomUUID(), reportId, report.owner_reference, createdAt),
+      db.prepare(`
+        INSERT INTO case_messages (
+          id, report_id, audience, direction, sender_type, sender_id, body, template_version_id,
+          automated, delivery_state, created_at, idempotency_key
+        ) VALUES (?1, ?2, 'affected_user', 'outbound', 'human', ?3, ?4, 'affected-user-notice-v1', 0, ?5, ?6, ?7)
+      `).bind(affectedMessageId, reportId, session.actor.id, input.affectedUserNotice, options.notificationEnabled ? "queued" : "suppressed", createdAt, `decision:${decisionId}:affected-message`),
+      db.prepare(`
+        INSERT INTO notices (
+          id, report_id, decision_id, audience, template_version_id, rendered_body,
+          delivery_state, created_at, updated_at, idempotency_key, message_id
+        ) VALUES (?1, ?2, ?3, 'affected_user', 'affected-user-notice-v1', ?4, ?5, ?6, ?6, ?7, ?8)
+      `).bind(affectedNoticeId, reportId, decisionId, input.affectedUserNotice, options.notificationEnabled ? "queued" : "suppressed", createdAt, `decision:${decisionId}:affected-notice`, affectedMessageId),
+    );
+    if (options.notificationEnabled) {
+      statements.push(db.prepare(`
+        INSERT INTO notification_outbox (
+          id, notice_id, idempotency_key, channel, payload_json, status, next_attempt_at, created_at, updated_at
+        ) VALUES (?1, ?2, ?3, 'customer_webhook', ?4, 'pending', ?5, ?5, ?5)
+      `).bind(affectedNotificationId, affectedNoticeId, `notice:${affectedNoticeId}`, canonicalJson({
+        version: 1,
+        event: "affected_user.decision_notice.available",
+        notification_id: affectedNotificationId,
+        report_reference: report.public_reference,
+        recipient_reference: report.owner_reference,
+        audience: "affected_user",
+        message: input.affectedUserNotice,
+      }), createdAt));
+      jobs.push({ version: 1, jobId: `notification:${affectedNotificationId}`, type: "deliver_notification", outboxId: affectedNotificationId });
+    }
+  }
+
+  if (input.actionCode && actionId) {
+    statements.push(db.prepare(`
+      INSERT INTO decision_action_outbox (
+        id, report_id, decision_id, idempotency_key, action_code, target_reference,
+        payload_json, status, next_attempt_at, created_at, updated_at
+      ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, 'pending', ?8, ?8, ?8)
+    `).bind(actionId, reportId, decisionId, `action:${decisionId}:${input.actionCode}`, input.actionCode, report.target_reference, canonicalJson({
+      version: 1,
+      action_id: actionId,
+      idempotency_key: `action:${decisionId}:${input.actionCode}`,
+      report_id: reportId,
+      report_reference: report.public_reference,
+      decision_id: decisionId,
+      action_code: input.actionCode,
+      target_reference: report.target_reference,
+      policy_version_id: report.policy_version_id,
+      policy_code: input.policyCode,
+    }), createdAt));
+    jobs.push({ version: 1, jobId: `action:${actionId}`, type: "deliver_action", outboxId: actionId });
+  }
+
+  await db.batch(statements);
+  return { decisionId, jobs, idempotentReplay: false };
+}
+
+
+export async function listAppeals(db: D1Database, limit: number, allowedQueueIds?: string[] | null): Promise<Array<Record<string, unknown>>> {
+  const result = await db.prepare(`
+    SELECT a.id, a.report_id AS reportId, r.public_reference AS reportReference,
+           a.decision_id AS decisionId, a.appellant_audience AS appellantAudience,
+           a.reason, a.state, a.submitted_at AS submittedAt,
+           c.reviewer_id AS reviewerId, c.expires_at AS claimExpiresAt
+    FROM appeals a
+    JOIN reports r ON r.id = a.report_id
+    LEFT JOIN appeal_claims c ON c.appeal_id = a.id
+    WHERE (?2 = 1 OR r.queue_id IN (SELECT value FROM json_each(?3)))
+    ORDER BY a.submitted_at ASC, a.id ASC
+    LIMIT ?1
+  `).bind(
+    Math.max(1, Math.min(100, limit)),
+    allowedQueueIds === null || allowedQueueIds === undefined ? 1 : 0,
+    canonicalJson(allowedQueueIds ?? []),
+  ).all<Record<string, unknown>>();
+  return result.results;
+}
+
+export async function loadAppealDetail(db: D1Database, appealId: string): Promise<Record<string, unknown> | null> {
+  const appeal = await db.prepare(`
+    SELECT a.id, a.report_id AS reportId, r.public_reference AS reportReference,
+      a.decision_id AS decisionId, a.appellant_audience AS appellantAudience,
+      a.reason, a.state, a.queue_id AS queueId, a.submitted_at AS submittedAt,
+      a.resolved_at AS resolvedAt, c.reviewer_id AS reviewerId,
+      c.claimed_at AS claimedAt, c.expires_at AS claimExpiresAt, c.version AS claimVersion,
+      d.decision_code AS originalDecisionCode, d.policy_code AS originalPolicyCode,
+      d.rationale AS originalRationale, d.maker_type AS originalMakerType,
+      d.maker_id AS originalMakerId, d.created_at AS originalDecisionAt
+    FROM appeals a JOIN reports r ON r.id = a.report_id
+    JOIN decisions d ON d.id = a.decision_id
+    LEFT JOIN appeal_claims c ON c.appeal_id = a.id AND c.expires_at > ?2
+    WHERE a.id = ?1 LIMIT 1
+  `).bind(appealId, now()).first<Record<string, unknown>>();
+  if (!appeal) return null;
+  const decisions = await db.prepare(`
+    SELECT id, outcome, rationale, reviewer_id AS reviewerId,
+      corrective_action_id AS correctiveActionId, created_at AS createdAt
+    FROM appeal_decisions WHERE appeal_id = ?1 ORDER BY created_at, id
+  `).bind(appealId).all<Record<string, unknown>>();
+  return { ...appeal, decisions: decisions.results };
+}
+
+export async function releaseAppealClaim(
+  db: D1Database,
+  appealId: string,
+  session: OperatorSession,
+): Promise<void> {
+  const claim = await db.prepare(`SELECT reviewer_id AS reviewerId, version FROM appeal_claims WHERE appeal_id = ?1 LIMIT 1`)
+    .bind(appealId).first<{ reviewerId: string; version: number }>();
+  if (!claim) return;
+  if (claim.reviewerId !== session.actor.id && !session.permissions.assignTasks) {
+    throw new ApiError(409, "appeal_claim_owned_by_another_reviewer", "Only the current reviewer or an assignment manager can release this claim.");
+  }
+  const createdAt = now();
+  await db.batch([
+    db.prepare(`DELETE FROM appeal_claims WHERE appeal_id = ?1`).bind(appealId),
+    db.prepare(`UPDATE appeals SET state = 'submitted' WHERE id = ?1 AND state = 'human_review'`).bind(appealId),
+    auditEvent(db, {
+      idempotencyKey: `appeal-claim-release:${appealId}:${claim.version}`,
+      action: "appeal.claim_released",
+      actorType: session.actor.type,
+      actorId: session.actor.id,
+      targetType: "appeal",
+      targetId: appealId,
+      details: { priorReviewerId: claim.reviewerId, version: claim.version },
+      createdAt,
+    }),
+  ]);
+}
+
+export async function claimAppeal(
+  db: D1Database,
+  appealId: string,
+  session: OperatorSession,
+  claimTtlMinutes: number,
+): Promise<{ reviewerId: string; claimedAt: string; expiresAt: string; version: number }> {
+  const appeal = await db.prepare(`
+    SELECT a.id, a.state, d.maker_type, d.maker_id
+    FROM appeals a JOIN decisions d ON d.id = a.decision_id
+    WHERE a.id = ?1 LIMIT 1
+  `).bind(appealId).first<{ id: string; state: string; maker_type: string; maker_id: string }>();
+  if (!appeal) throw new ApiError(404, "appeal_not_found", "The appeal does not exist.");
+  if (!["submitted", "human_review"].includes(appeal.state)) throw new ApiError(409, "appeal_not_claimable", "The appeal is not awaiting human review.");
+  if (appeal.maker_type === "human" && appeal.maker_id === session.actor.id) {
+    throw new ApiError(409, "independent_appeal_reviewer_required", "The original decision maker cannot claim this appeal.");
+  }
+  const claimedAt = now();
+  const expiresAt = addMinutes(claimedAt, Math.max(1, Math.min(1_440, claimTtlMinutes)));
+  await db.batch([
+    db.prepare(`
+      INSERT INTO appeal_claims (appeal_id, reviewer_id, claimed_at, expires_at, version)
+      VALUES (?1, ?2, ?3, ?4, 1)
+      ON CONFLICT(appeal_id) DO UPDATE SET reviewer_id = excluded.reviewer_id,
+        claimed_at = excluded.claimed_at, expires_at = excluded.expires_at,
+        version = appeal_claims.version + 1
+      WHERE appeal_claims.expires_at <= ?3 OR appeal_claims.reviewer_id = ?2
+    `).bind(appealId, session.actor.id, claimedAt, expiresAt),
+    db.prepare(`UPDATE appeals SET state = 'human_review' WHERE id = ?1 AND state = 'submitted'`).bind(appealId),
+  ]);
+  const claim = await db.prepare(`SELECT reviewer_id, claimed_at, expires_at, version FROM appeal_claims WHERE appeal_id = ?1 LIMIT 1`)
+    .bind(appealId).first<{ reviewer_id: string; claimed_at: string; expires_at: string; version: number }>();
+  if (!claim || claim.reviewer_id !== session.actor.id) throw new ApiError(409, "appeal_already_claimed", "Another appeal reviewer currently holds this appeal.");
+  return { reviewerId: claim.reviewer_id, claimedAt: claim.claimed_at, expiresAt: claim.expires_at, version: claim.version };
+}
+
+export async function decideAppeal(
+  db: D1Database,
+  appealId: string,
+  session: OperatorSession,
+  input: AppealDecisionInput,
+  options: DecisionOptions,
+): Promise<{ appealDecisionId: string; jobs: DeliveryJob[]; idempotentReplay: boolean }> {
+  const existing = await db.prepare(`
+    SELECT id FROM appeal_decisions WHERE appeal_id = ?1 AND idempotency_key = ?2 LIMIT 1
+  `).bind(appealId, input.idempotencyKey).first<{ id: string }>();
+  if (existing) return { appealDecisionId: existing.id, jobs: [], idempotentReplay: true };
+  const createdAt = now();
+  const appeal = await db.prepare(`
+    SELECT a.id, a.report_id, a.decision_id, a.appellant_audience, a.state, a.submitted_at,
+           d.maker_id AS original_maker_id, r.public_reference, r.state AS report_state,
+           r.policy_version_id, t.target_reference,
+           p.reference AS participant_reference
+    FROM appeals a
+    JOIN decisions d ON d.id = a.decision_id
+    JOIN reports r ON r.id = a.report_id
+    JOIN report_targets t ON t.report_id = r.id
+    JOIN report_participants p ON p.report_id = r.id AND p.audience = a.appellant_audience
+    WHERE a.id = ?1
+    LIMIT 1
+  `).bind(appealId).first<{
+    id: string;
+    report_id: string;
+    decision_id: string;
+    appellant_audience: ParticipantAudience;
+    state: string;
+    submitted_at: string;
+    original_maker_id: string;
+    public_reference: string;
+    report_state: ReportState;
+    policy_version_id: string | null;
+    target_reference: string;
+    participant_reference: string | null;
+  }>();
+  if (!appeal) throw new ApiError(404, "appeal_not_found", "The appeal does not exist.");
+  if (appeal.state !== "human_review") throw new ApiError(409, "appeal_not_decidable", "The appeal is not awaiting a human decision.");
+  if (appeal.original_maker_id === session.actor.id) {
+    throw new ApiError(409, "independent_appeal_reviewer_required", "The original decision maker cannot decide this appeal.");
+  }
+  const claim = await db.prepare(`SELECT reviewer_id, expires_at FROM appeal_claims WHERE appeal_id = ?1 LIMIT 1`)
+    .bind(appealId).first<{ reviewer_id: string; expires_at: string }>();
+  if (!claim || claim.reviewer_id !== session.actor.id || claim.expires_at <= createdAt) {
+    throw new ApiError(409, "active_appeal_claim_required", "Claim this appeal before deciding it.");
+  }
+  if (input.correctiveActionCode && (!options.actionEnabled || !options.allowedActionCodes.has(input.correctiveActionCode))) {
+    throw new ApiError(400, "action_not_allowed", "The corrective application action is not allowlisted for this deployment.");
+  }
+  const appealDecisionId = crypto.randomUUID();
+  const messageId = crypto.randomUUID();
+  const noticeId = crypto.randomUUID();
+  const notificationId = crypto.randomUUID();
+  const actionId = input.correctiveActionCode ? crypto.randomUUID() : null;
+  const templateId = appeal.appellant_audience === "affected_user" ? "appeal-outcome-v1" : "reporter-outcome-v1";
+  const jobs: DeliveryJob[] = [];
+  const statements: D1PreparedStatement[] = [
+    db.prepare(`
+      INSERT INTO appeal_decisions (
+        id, appeal_id, outcome, rationale, reviewer_id, corrective_action_id, created_at, idempotency_key
+      ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)
+    `).bind(appealDecisionId, appealId, input.outcome, input.rationale, session.actor.id, actionId, createdAt, input.idempotencyKey),
+    db.prepare(`UPDATE appeals SET state = ?2, resolved_at = ?3 WHERE id = ?1`).bind(appealId, input.outcome, createdAt),
+    db.prepare(`UPDATE reports SET state = 'closed', queue_id = NULL, updated_at = ?2 WHERE id = ?1`)
+      .bind(appeal.report_id, createdAt),
+    db.prepare(`
+      INSERT INTO report_state_history (id, report_id, from_state, to_state, reason_code, actor_type, actor_id, created_at)
+      VALUES (?1, ?2, ?3, 'closed', ?4, ?5, ?6, ?7)
+    `).bind(crypto.randomUUID(), appeal.report_id, appeal.report_state, `appeal_${input.outcome}`, session.actor.type, session.actor.id, createdAt),
+    db.prepare(`
+      INSERT INTO case_messages (
+        id, report_id, audience, direction, sender_type, sender_id, body, template_version_id,
+        automated, delivery_state, created_at, idempotency_key
+      ) VALUES (?1, ?2, ?3, 'outbound', 'human', ?4, ?5, ?6, 0, ?7, ?8, ?9)
+    `).bind(
+      messageId, appeal.report_id, appeal.appellant_audience, session.actor.id, input.participantNotice,
+      templateId, options.notificationEnabled ? "queued" : "suppressed", createdAt,
+      `appeal-decision:${appealDecisionId}:message`,
+    ),
+    db.prepare(`
+      INSERT INTO notices (
+        id, report_id, decision_id, audience, template_version_id, rendered_body,
+        delivery_state, created_at, updated_at, idempotency_key, message_id
+      ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?8, ?9, ?10)
+    `).bind(
+      noticeId, appeal.report_id, appeal.decision_id, appeal.appellant_audience, templateId,
+      input.participantNotice, options.notificationEnabled ? "queued" : "suppressed", createdAt,
+      `appeal-decision:${appealDecisionId}:notice`, messageId,
+    ),
+    db.prepare(`DELETE FROM appeal_claims WHERE appeal_id = ?1`).bind(appealId),
+    auditEvent(db, {
+      idempotencyKey: `appeal-decision:${appealId}:${input.idempotencyKey}`,
+      action: "appeal.human_decision_recorded",
+      actorType: session.actor.type,
+      actorId: session.actor.id,
+      targetType: "appeal_decision",
+      targetId: appealDecisionId,
+      details: {
+        appealId,
+        reportId: appeal.report_id,
+        outcome: input.outcome,
+        correctiveActionCode: input.correctiveActionCode ?? null,
+      },
+      createdAt,
+    }),
+  ];
+  if (input.outcome === "reversed") {
+    statements.push(db.prepare(`
+      INSERT INTO ai_usage_daily (usage_date, config_version_id, appeal_reversals, updated_at)
+      SELECT substr(?2, 1, 10), ar.config_version_id, 1, ?2
+      FROM decisions d JOIN ai_runs ar ON ar.id = d.ai_run_id
+      WHERE d.id = ?1
+      ON CONFLICT(usage_date, config_version_id) DO UPDATE SET
+        appeal_reversals = appeal_reversals + 1, updated_at = excluded.updated_at
+    `).bind(appeal.decision_id, createdAt));
+  }
+  if (options.notificationEnabled) {
+    statements.push(db.prepare(`
+      INSERT INTO notification_outbox (
+        id, notice_id, idempotency_key, channel, payload_json, status, next_attempt_at, created_at, updated_at
+      ) VALUES (?1, ?2, ?3, 'customer_webhook', ?4, 'pending', ?5, ?5, ?5)
+    `).bind(notificationId, noticeId, `notice:${noticeId}`, canonicalJson({
+      version: 1,
+      event: "appeal.outcome.available",
+      notification_id: notificationId,
+      report_reference: appeal.public_reference,
+      ...(appeal.participant_reference ? { recipient_reference: appeal.participant_reference } : {}),
+      audience: appeal.appellant_audience,
+      message: input.participantNotice,
+    }), createdAt));
+    jobs.push({ version: 1, jobId: `notification:${notificationId}`, type: "deliver_notification", outboxId: notificationId });
+  }
+  if (input.correctiveActionCode && actionId) {
+    statements.push(db.prepare(`
+      INSERT INTO decision_action_outbox (
+        id, report_id, decision_id, idempotency_key, action_code, target_reference,
+        payload_json, status, next_attempt_at, created_at, updated_at
+      ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, 'pending', ?8, ?8, ?8)
+    `).bind(
+      actionId, appeal.report_id, appeal.decision_id,
+      `appeal-action:${appealDecisionId}:${input.correctiveActionCode}`,
+      input.correctiveActionCode, appeal.target_reference,
+      canonicalJson({
+        version: 1,
+        action_id: actionId,
+        idempotency_key: `appeal-action:${appealDecisionId}:${input.correctiveActionCode}`,
+        report_id: appeal.report_id,
+        report_reference: appeal.public_reference,
+        original_decision_id: appeal.decision_id,
+        appeal_id: appealId,
+        appeal_decision_id: appealDecisionId,
+        action_code: input.correctiveActionCode,
+        target_reference: appeal.target_reference,
+        policy_version_id: appeal.policy_version_id,
+      }),
+      createdAt,
+    ));
+    jobs.push({ version: 1, jobId: `action:${actionId}`, type: "deliver_action", outboxId: actionId });
+  }
+  await db.batch(statements);
+  return { appealDecisionId, jobs, idempotentReplay: false };
+}
+
+export async function chainPendingAuditEvents(db: D1Database, limit = 50): Promise<void> {
+  const pending = await db.prepare(`
+    SELECT id, action, actor_type, actor_id, target_type, target_id, details_json, created_at
+    FROM audit_events
+    WHERE chained_at IS NULL
+    ORDER BY created_at ASC, id ASC
+    LIMIT ?1
+  `).bind(Math.max(1, Math.min(100, limit))).all<{
+    id: string;
+    action: string;
+    actor_type: string;
+    actor_id: string;
+    target_type: string;
+    target_id: string;
+    details_json: string;
+    created_at: string;
+  }>();
+  for (const event of pending.results) {
+    const tip = await db.prepare(`SELECT sequence, entry_hash FROM audit_entries ORDER BY sequence DESC LIMIT 1`)
+      .first<{ sequence: number; entry_hash: string }>() ?? { sequence: 0, entry_hash: AUDIT_GENESIS_HASH };
+    const sequence = tip.sequence + 1;
+    const entryHash = await hashAuditEntry({
+      sequence,
+      action: event.action,
+      actorType: event.actor_type,
+      actorId: event.actor_id,
+      targetType: event.target_type,
+      targetId: event.target_id,
+      detailsJson: event.details_json,
+      previousHash: tip.entry_hash,
+      createdAt: event.created_at,
+    });
+    try {
+      await db.batch([
+        db.prepare(`
+          INSERT INTO audit_entries (
+            sequence, id, action, actor_type, actor_id, target_type, target_id,
+            details_json, previous_hash, entry_hash, created_at
+          ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)
+        `).bind(
+          sequence, event.id, event.action, event.actor_type, event.actor_id, event.target_type,
+          event.target_id, event.details_json, tip.entry_hash, entryHash, event.created_at,
+        ),
+        db.prepare(`UPDATE audit_events SET chained_at = ?2, chain_error_code = NULL WHERE id = ?1 AND chained_at IS NULL`)
+          .bind(event.id, now()),
+      ]);
+    } catch (error) {
+      await db.prepare(`UPDATE audit_events SET chain_error_code = 'chain_contention' WHERE id = ?1 AND chained_at IS NULL`)
+        .bind(event.id).run();
+      console.warn("audit event chaining will retry", { eventId: event.id, errorType: error instanceof Error ? error.name : typeof error });
+      break;
+    }
+  }
+}