@elizaos/plugin-personal-assistant 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/lifeops/bulk-review.js

@@ -0,0 +1,1120 @@
+const CLEANUP_BULK_REVIEW_SCHEMA_VERSION = "lifeops.cleanup-plan.v1";
+const DEFAULT_CLEANUP_EXECUTION_CHUNK_SIZE = 50;
+const MAX_CLEANUP_EXECUTION_CHUNK_SIZE = 250;
+const DEFAULT_CLEANUP_PLAN_ITEM_LIMIT = 2500;
+function canonicalJson(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("[BulkReview] Hash payload contains a non-finite number");
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+  }
+  const entries = [];
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (entryValue !== void 0) {
+      entries.push([key, entryValue]);
+    }
+  }
+  entries.sort(([left], [right]) => left.localeCompare(right));
+  return `{${entries.map(
+    ([key, entryValue]) => `${JSON.stringify(key)}:${canonicalJson(entryValue)}`
+  ).join(",")}}`;
+}
+async function sha256Hex(input) {
+  const subtle = globalThis.crypto.subtle;
+  if (!subtle) {
+    throw new Error("[BulkReview] SHA-256 crypto.subtle is unavailable");
+  }
+  const bytes = new TextEncoder().encode(input);
+  const digest = await subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function sortedStrings(values) {
+  return values ? [...values].sort() : void 0;
+}
+function snapshotHashPayload(snapshot) {
+  return {
+    provider: snapshot.provider,
+    itemId: snapshot.itemId,
+    accountId: snapshot.accountId,
+    displayName: snapshot.displayName,
+    canonicalUrl: snapshot.canonicalUrl,
+    parentId: snapshot.parentId,
+    path: snapshot.path,
+    mimeType: snapshot.mimeType,
+    sizeBytes: snapshot.sizeBytes,
+    checksum: snapshot.checksum,
+    etag: snapshot.etag,
+    revisionId: snapshot.revisionId,
+    updatedAt: snapshot.updatedAt,
+    createdAt: snapshot.createdAt,
+    labels: sortedStrings(snapshot.labels),
+    metadata: snapshot.metadata
+  };
+}
+function operationHashPayload(operation) {
+  return {
+    kind: operation.kind,
+    risk: operation.risk,
+    reason: operation.reason,
+    requiresUserApproval: operation.requiresUserApproval,
+    undoSupported: operation.undoSupported,
+    parameters: operation.parameters
+  };
+}
+function planHashPayload(plan) {
+  return {
+    schemaVersion: CLEANUP_BULK_REVIEW_SCHEMA_VERSION,
+    id: plan.id,
+    ownerUserId: plan.ownerUserId,
+    createdAt: plan.createdAt,
+    expiresAt: plan.expiresAt,
+    source: plan.source,
+    title: plan.title,
+    summary: plan.summary,
+    metadata: plan.metadata,
+    clusters: plan.clusters.map((cluster) => ({
+      id: cluster.id,
+      title: cluster.title,
+      rationale: cluster.rationale,
+      items: cluster.items.map((item) => ({
+        itemKey: item.itemKey,
+        snapshot: snapshotHashPayload(item.snapshot),
+        operation: operationHashPayload(item.operation),
+        evidence: [...item.evidence]
+      }))
+    }))
+  };
+}
+function getCleanupItemKey(snapshot) {
+  const accountPart = encodeURIComponent(snapshot.accountId ?? "_");
+  return `${snapshot.provider}:${accountPart}:${encodeURIComponent(snapshot.itemId)}`;
+}
+async function hashCleanupItemSnapshot(snapshot) {
+  return sha256Hex(canonicalJson(snapshotHashPayload(snapshot)));
+}
+async function computeCleanupPlanHash(plan) {
+  return sha256Hex(canonicalJson(planHashPayload(plan)));
+}
+async function bindCleanupPlanHash(draft) {
+  const seenItemKeys = /* @__PURE__ */ new Set();
+  const clusters = [];
+  for (const cluster of draft.clusters) {
+    const items = [];
+    for (const item of cluster.items) {
+      const itemKey = getCleanupItemKey(item.snapshot);
+      if (seenItemKeys.has(itemKey)) {
+        throw new Error(`[BulkReview] Duplicate cleanup item key: ${itemKey}`);
+      }
+      seenItemKeys.add(itemKey);
+      items.push({
+        ...item,
+        itemKey,
+        snapshotHash: await hashCleanupItemSnapshot(item.snapshot)
+      });
+    }
+    clusters.push({
+      id: cluster.id,
+      title: cluster.title,
+      rationale: cluster.rationale,
+      items
+    });
+  }
+  const planWithoutHash = {
+    schemaVersion: CLEANUP_BULK_REVIEW_SCHEMA_VERSION,
+    id: draft.id,
+    ownerUserId: draft.ownerUserId,
+    createdAt: draft.createdAt,
+    expiresAt: draft.expiresAt,
+    source: draft.source,
+    title: draft.title,
+    summary: draft.summary,
+    clusters,
+    metadata: draft.metadata
+  };
+  return {
+    ...planWithoutHash,
+    planHash: await computeCleanupPlanHash(planWithoutHash)
+  };
+}
+function makePlanIndex(plan) {
+  const itemByKey = /* @__PURE__ */ new Map();
+  for (const cluster of plan.clusters) {
+    for (const item of cluster.items) {
+      if (itemByKey.has(item.itemKey)) {
+        throw new Error(
+          `[BulkReview] Duplicate cleanup item key: ${item.itemKey}`
+        );
+      }
+      itemByKey.set(item.itemKey, item);
+    }
+  }
+  return { itemByKey, itemCount: itemByKey.size };
+}
+function createExecutionId(planHash, now) {
+  const timestamp = Date.parse(now);
+  const timestampPart = Number.isFinite(timestamp) ? timestamp.toString(36) : "invalid-time";
+  return `cleanup-exec-${timestampPart}-${planHash.slice(0, 16)}`;
+}
+function createUndoId(executionId) {
+  return `${executionId}:undo`;
+}
+function normalizeChunkSize(size) {
+  if (size === void 0) {
+    return DEFAULT_CLEANUP_EXECUTION_CHUNK_SIZE;
+  }
+  if (!Number.isInteger(size) || size < 1) {
+    throw new Error(
+      "[BulkReview] Cleanup chunk size must be a positive integer"
+    );
+  }
+  if (size > MAX_CLEANUP_EXECUTION_CHUNK_SIZE) {
+    throw new Error(
+      `[BulkReview] Cleanup chunk size cannot exceed ${MAX_CLEANUP_EXECUTION_CHUNK_SIZE}`
+    );
+  }
+  return size;
+}
+function isExpired(expiresAt, now) {
+  if (!expiresAt) {
+    return false;
+  }
+  const expiresMs = Date.parse(expiresAt);
+  const nowMs = Date.parse(now);
+  if (!Number.isFinite(expiresMs) || !Number.isFinite(nowMs)) {
+    return true;
+  }
+  return expiresMs <= nowMs;
+}
+function pushAuditEvent(auditEvents, input) {
+  const item = input.item;
+  const undoItem = input.undoItem;
+  auditEvents.push({
+    schemaVersion: CLEANUP_BULK_REVIEW_SCHEMA_VERSION,
+    eventId: `${input.executionId ?? input.undoId ?? "cleanup"}:${auditEvents.length + 1}`,
+    eventType: input.eventType,
+    emittedAt: input.emittedAt,
+    actorUserId: input.actorUserId,
+    planHash: input.planHash,
+    executionId: input.executionId,
+    undoId: input.undoId,
+    itemKey: item?.itemKey ?? undoItem?.itemKey,
+    provider: item?.snapshot.provider ?? undoItem?.provider,
+    operationKind: item?.operation.kind ?? undoItem?.operationKind,
+    risk: item?.operation.risk,
+    outcome: input.outcome,
+    code: input.code,
+    message: input.message,
+    metadata: input.metadata
+  });
+}
+function rejectedExecution(args) {
+  const auditEvents = [...args.auditEvents ?? []];
+  pushAuditEvent(auditEvents, {
+    eventType: "cleanup.bulk_review.rejected",
+    emittedAt: args.now,
+    actorUserId: args.actorUserId,
+    planHash: args.plan.planHash,
+    executionId: args.executionId,
+    outcome: "rejected",
+    code: args.code,
+    message: args.reason
+  });
+  return {
+    executionId: args.executionId,
+    planId: args.plan.id,
+    planHash: args.plan.planHash,
+    mode: args.mode,
+    status: "rejected",
+    actorUserId: args.actorUserId,
+    requestedItemCount: 0,
+    eligibleItemCount: 0,
+    skippedItems: [],
+    results: [],
+    chunks: [],
+    auditEvents,
+    createdAt: args.now,
+    completedAt: args.now,
+    rejectionCode: args.code,
+    rejectionReason: args.reason
+  };
+}
+function selectedItemsForRequest(request) {
+  if (request.mode === "execute") {
+    return request.confirmation?.selectedItems ?? null;
+  }
+  return request.selection?.selectedItems ?? null;
+}
+function getRequestedPlanHash(request) {
+  if (request.mode === "execute") {
+    return request.confirmation?.planHash;
+  }
+  return request.selection?.planHash;
+}
+function assertSameUserForConfirmation(request) {
+  if (request.mode !== "execute") {
+    return null;
+  }
+  const confirmation = request.confirmation;
+  if (!confirmation) {
+    return "A user confirmation is required before executing cleanup operations";
+  }
+  if (confirmation.confirmedByUserId !== request.actorUserId) {
+    return "Cleanup confirmation belongs to a different user";
+  }
+  return null;
+}
+function resolveSelectedItems(args) {
+  if (args.selectedItems.length === 0) {
+    return {
+      items: [],
+      code: "EMPTY_SELECTION",
+      error: "Select at least one item"
+    };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const selected of args.selectedItems) {
+    if (seen.has(selected.itemKey)) {
+      return {
+        items: [],
+        code: "DUPLICATE_SELECTION",
+        error: `Duplicate selected cleanup item: ${selected.itemKey}`
+      };
+    }
+    seen.add(selected.itemKey);
+    const item = args.itemByKey.get(selected.itemKey);
+    if (!item) {
+      return {
+        items: [],
+        code: "UNKNOWN_SELECTED_ITEM",
+        error: `Selected cleanup item is not in the bound plan: ${selected.itemKey}`
+      };
+    }
+    if (item.snapshotHash !== selected.snapshotHash) {
+      return {
+        items: [],
+        code: "SELECTED_SNAPSHOT_MISMATCH",
+        error: `Selected cleanup item snapshot does not match the bound plan: ${selected.itemKey}`
+      };
+    }
+    items.push(item);
+  }
+  return { items };
+}
+function approvalCoversItem(args) {
+  if (!args.approval) {
+    return false;
+  }
+  if (args.approval.approvedByUserId !== args.actorUserId) {
+    return false;
+  }
+  if (args.approval.planHash !== args.planHash) {
+    return false;
+  }
+  return args.approval.approvedItemSnapshotHashes.includes(
+    args.item.snapshotHash
+  );
+}
+async function validatePlanBinding(plan) {
+  if (plan.schemaVersion !== CLEANUP_BULK_REVIEW_SCHEMA_VERSION) {
+    return "Cleanup plan schema version is not supported";
+  }
+  for (const cluster of plan.clusters) {
+    for (const item of cluster.items) {
+      const expectedKey = getCleanupItemKey(item.snapshot);
+      if (item.itemKey !== expectedKey) {
+        return `Cleanup item key is not bound to its snapshot: ${item.itemKey}`;
+      }
+      const expectedSnapshotHash = await hashCleanupItemSnapshot(item.snapshot);
+      if (item.snapshotHash !== expectedSnapshotHash) {
+        return `Cleanup item snapshot hash is invalid: ${item.itemKey}`;
+      }
+    }
+  }
+  const expectedPlanHash = await computeCleanupPlanHash(plan);
+  if (plan.planHash !== expectedPlanHash) {
+    return "Cleanup plan hash is invalid";
+  }
+  return null;
+}
+async function applyPolicyGate(args) {
+  const eligibleItems = [];
+  const skippedItems = [];
+  for (const item of args.items) {
+    const decision = args.request.policyGate ? await args.request.policyGate({
+      actorUserId: args.request.actorUserId,
+      mode: args.request.mode,
+      planHash: args.request.plan.planHash,
+      item,
+      requestedAt: args.request.now
+    }) : { outcome: "allow" };
+    if (decision.outcome === "allow") {
+      eligibleItems.push(item);
+      continue;
+    }
+    if (decision.outcome === "require_user_approval") {
+      const approved = approvalCoversItem({
+        approval: args.request.confirmation?.policyApproval,
+        actorUserId: args.request.actorUserId,
+        planHash: args.request.plan.planHash,
+        item
+      });
+      if (approved) {
+        eligibleItems.push(item);
+        continue;
+      }
+      skippedItems.push({
+        itemKey: item.itemKey,
+        provider: item.snapshot.provider,
+        operationKind: item.operation.kind,
+        snapshotHash: item.snapshotHash,
+        reasonCode: decision.code,
+        reason: decision.reason
+      });
+      pushAuditEvent(args.auditEvents, {
+        eventType: "cleanup.bulk_review.policy_approval_required",
+        emittedAt: args.request.now,
+        actorUserId: args.request.actorUserId,
+        planHash: args.request.plan.planHash,
+        executionId: args.executionId,
+        item,
+        outcome: "skipped",
+        code: decision.code,
+        message: decision.reason,
+        metadata: decision.auditMetadata
+      });
+      continue;
+    }
+    skippedItems.push({
+      itemKey: item.itemKey,
+      provider: item.snapshot.provider,
+      operationKind: item.operation.kind,
+      snapshotHash: item.snapshotHash,
+      reasonCode: decision.code,
+      reason: decision.reason
+    });
+    pushAuditEvent(args.auditEvents, {
+      eventType: "cleanup.bulk_review.policy_denied",
+      emittedAt: args.request.now,
+      actorUserId: args.request.actorUserId,
+      planHash: args.request.plan.planHash,
+      executionId: args.executionId,
+      item,
+      outcome: "skipped",
+      code: decision.code,
+      message: decision.reason,
+      metadata: decision.auditMetadata
+    });
+  }
+  return { eligibleItems, skippedItems };
+}
+async function verifyCurrentSnapshots(args) {
+  const byProvider = groupItemsByProvider(args.items);
+  for (const [provider, items] of byProvider) {
+    const adapter = args.adapters[provider];
+    if (!adapter) {
+      return {
+        code: "ADAPTER_MISSING",
+        reason: `No cleanup adapter is registered for ${provider}`
+      };
+    }
+    let snapshots;
+    try {
+      snapshots = await adapter.readCurrentSnapshots(items);
+    } catch (error) {
+      return {
+        code: "SNAPSHOT_READ_FAILED",
+        reason: error instanceof Error ? error.message : "Cleanup adapter failed to read current snapshots"
+      };
+    }
+    const currentByKey = /* @__PURE__ */ new Map();
+    for (const snapshot of snapshots) {
+      currentByKey.set(getCleanupItemKey(snapshot), snapshot);
+    }
+    for (const item of items) {
+      const current = currentByKey.get(item.itemKey);
+      if (!current) {
+        return {
+          code: "ITEM_SNAPSHOT_MISSING",
+          reason: `Cleanup item no longer exists or cannot be read: ${item.itemKey}`
+        };
+      }
+      const currentHash = await hashCleanupItemSnapshot(current);
+      if (currentHash !== item.snapshotHash) {
+        return {
+          code: "ITEM_SNAPSHOT_DRIFT",
+          reason: `Cleanup item changed after review: ${item.itemKey}`
+        };
+      }
+    }
+  }
+  return {};
+}
+function groupItemsByProvider(items) {
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const existing = byProvider.get(item.snapshot.provider);
+    if (existing) {
+      existing.push(item);
+    } else {
+      byProvider.set(item.snapshot.provider, [item]);
+    }
+  }
+  return byProvider;
+}
+function groupUndoItemsByProvider(items) {
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const existing = byProvider.get(item.provider);
+    if (existing) {
+      existing.push(item);
+    } else {
+      byProvider.set(item.provider, [item]);
+    }
+  }
+  return byProvider;
+}
+function chunkItems(items, chunkSize) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += chunkSize) {
+    chunks.push(items.slice(index, index + chunkSize));
+  }
+  return chunks;
+}
+function toAdapterOperations(args) {
+  return args.items.map((item) => ({
+    planId: args.plan.id,
+    planHash: args.plan.planHash,
+    actorUserId: args.actorUserId,
+    mode: args.mode,
+    item
+  }));
+}
+function adapterResultFor(operation, resultByItemKey) {
+  return resultByItemKey.get(operation.item.itemKey) ?? {
+    itemKey: operation.item.itemKey,
+    outcome: "failed",
+    code: "ADAPTER_RESULT_MISSING",
+    message: "Cleanup adapter did not return a result for this item"
+  };
+}
+function chunkStatus(mode, results) {
+  if (mode === "dry_run" && results.every((result) => result.outcome === "planned")) {
+    return "planned";
+  }
+  const succeeded = results.some(
+    (result) => result.outcome === "succeeded" || result.outcome === "planned"
+  );
+  const failed = results.some((result) => result.outcome === "failed");
+  if (succeeded && failed) {
+    return "partially_failed";
+  }
+  if (failed) {
+    return "failed";
+  }
+  return "succeeded";
+}
+function executionStatus(mode, results) {
+  const failed = results.some((result) => result.outcome === "failed");
+  const succeeded = results.some(
+    (result) => result.outcome === "succeeded" || result.outcome === "planned"
+  );
+  if (mode === "dry_run" && !failed) {
+    return "dry_run";
+  }
+  if (succeeded && failed) {
+    return "partially_failed";
+  }
+  if (failed) {
+    return "failed";
+  }
+  return "succeeded";
+}
+async function runAdapterChunks(args) {
+  const results = [];
+  const chunks = [];
+  let chunkIndex = 0;
+  for (const [provider, providerItems] of groupItemsByProvider(args.items)) {
+    const adapter = args.request.adapters[provider];
+    if (!adapter) {
+      for (const item of providerItems) {
+        results.push({
+          itemKey: item.itemKey,
+          provider,
+          operationKind: item.operation.kind,
+          snapshotHash: item.snapshotHash,
+          outcome: "failed",
+          code: "ADAPTER_MISSING",
+          message: `No cleanup adapter is registered for ${provider}`
+        });
+      }
+      continue;
+    }
+    for (const chunk of chunkItems(providerItems, args.chunkSize)) {
+      const startedAt = args.request.now;
+      const operations = toAdapterOperations({
+        plan: args.request.plan,
+        actorUserId: args.request.actorUserId,
+        mode: args.request.mode,
+        items: chunk
+      });
+      let adapterResults;
+      try {
+        const chunkResult = args.request.mode === "dry_run" ? await adapter.dryRunChunk({
+          executionId: args.executionId,
+          provider,
+          chunkIndex,
+          operations
+        }) : await adapter.executeChunk({
+          executionId: args.executionId,
+          provider,
+          chunkIndex,
+          operations
+        });
+        adapterResults = chunkResult.results;
+      } catch (error) {
+        adapterResults = operations.map((operation) => ({
+          itemKey: operation.item.itemKey,
+          outcome: "failed",
+          code: "ADAPTER_CHUNK_FAILED",
+          message: error instanceof Error ? error.message : "Cleanup adapter chunk failed"
+        }));
+      }
+      const resultByItemKey = /* @__PURE__ */ new Map();
+      for (const result of adapterResults) {
+        resultByItemKey.set(result.itemKey, result);
+      }
+      const chunkResults = [];
+      for (const operation of operations) {
+        const adapterResult = adapterResultFor(operation, resultByItemKey);
+        const outcome = adapterResult.outcome === "succeeded" ? args.request.mode === "dry_run" ? "planned" : "succeeded" : "failed";
+        const executionResult = {
+          itemKey: operation.item.itemKey,
+          provider,
+          operationKind: operation.item.operation.kind,
+          snapshotHash: operation.item.snapshotHash,
+          outcome,
+          code: adapterResult.code,
+          message: adapterResult.message,
+          undoToken: adapterResult.undoToken,
+          undoExpiresAt: adapterResult.undoExpiresAt
+        };
+        chunkResults.push(executionResult);
+        results.push(executionResult);
+        pushAuditEvent(args.auditEvents, {
+          eventType: outcome === "failed" ? "cleanup.bulk_review.item_failed" : args.request.mode === "dry_run" ? "cleanup.bulk_review.item_dry_run" : "cleanup.bulk_review.item_executed",
+          emittedAt: args.request.now,
+          actorUserId: args.request.actorUserId,
+          planHash: args.request.plan.planHash,
+          executionId: args.executionId,
+          item: operation.item,
+          outcome,
+          code: adapterResult.code,
+          message: adapterResult.message,
+          metadata: adapterResult.metadata
+        });
+      }
+      chunks.push({
+        chunkIndex,
+        provider,
+        itemKeys: operations.map((operation) => operation.item.itemKey),
+        status: chunkStatus(args.request.mode, chunkResults),
+        startedAt,
+        completedAt: args.request.now
+      });
+      chunkIndex += 1;
+    }
+  }
+  return { results, chunks };
+}
+function buildCleanupUndo(args) {
+  const undoItems = [];
+  for (const result of args.results) {
+    if (result.outcome !== "succeeded") {
+      continue;
+    }
+    const item = args.itemsByKey.get(result.itemKey);
+    if (!item) {
+      continue;
+    }
+    if (item.operation.undoSupported && result.undoToken && result.undoExpiresAt) {
+      undoItems.push({
+        itemKey: result.itemKey,
+        provider: result.provider,
+        operationKind: result.operationKind,
+        snapshotHash: result.snapshotHash,
+        undoToken: result.undoToken,
+        undoExpiresAt: result.undoExpiresAt,
+        eligibility: "eligible"
+      });
+      continue;
+    }
+    undoItems.push({
+      itemKey: result.itemKey,
+      provider: result.provider,
+      operationKind: result.operationKind,
+      snapshotHash: result.snapshotHash,
+      eligibility: "unsupported",
+      reason: item.operation.undoSupported ? "Cleanup adapter did not return undo material" : "Cleanup operation does not support undo"
+    });
+  }
+  if (undoItems.length === 0) {
+    return void 0;
+  }
+  const eligibleItems = undoItems.filter(
+    (item) => item.eligibility === "eligible"
+  );
+  const expiresAt = eligibleItems.map((item) => item.undoExpiresAt).filter((value) => Boolean(value)).sort()[0];
+  const status = eligibleItems.length === 0 ? "unsupported" : eligibleItems.length === undoItems.length ? "eligible" : "partially_eligible";
+  return {
+    undoId: createUndoId(args.executionId),
+    executionId: args.executionId,
+    planHash: args.planHash,
+    createdAt: args.createdAt,
+    expiresAt,
+    status,
+    items: undoItems
+  };
+}
+async function executeCleanupPlan(request) {
+  const executionId = request.executionId ?? createExecutionId(request.plan.planHash, request.now);
+  const auditEvents = [];
+  let chunkSize;
+  try {
+    chunkSize = normalizeChunkSize(request.chunkSize);
+  } catch (error) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: "INVALID_CHUNK_SIZE",
+      reason: error instanceof Error ? error.message : "Cleanup chunk size is invalid"
+    });
+  }
+  const planBindingError = await validatePlanBinding(request.plan);
+  if (planBindingError) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: "PLAN_HASH_INVALID",
+      reason: planBindingError
+    });
+  }
+  const index = makePlanIndex(request.plan);
+  const maxPlanItems = request.maxPlanItems ?? DEFAULT_CLEANUP_PLAN_ITEM_LIMIT;
+  if (index.itemCount > maxPlanItems) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: "PLAN_TOO_LARGE",
+      reason: `Cleanup plan contains ${index.itemCount} items, limit is ${maxPlanItems}`
+    });
+  }
+  if (isExpired(request.plan.expiresAt, request.now)) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: "PLAN_EXPIRED",
+      reason: "Cleanup plan has expired and must be regenerated"
+    });
+  }
+  const userError = assertSameUserForConfirmation(request);
+  if (userError) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: "CONFIRMATION_REQUIRED",
+      reason: userError
+    });
+  }
+  const requestedPlanHash = getRequestedPlanHash(request);
+  if (requestedPlanHash && requestedPlanHash !== request.plan.planHash) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: "CONFIRMATION_HASH_MISMATCH",
+      reason: "Cleanup confirmation hash does not match the bound plan"
+    });
+  }
+  if (request.mode === "execute" && !requestedPlanHash) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: "CONFIRMATION_HASH_REQUIRED",
+      reason: "Cleanup execution requires a user-confirmed plan hash"
+    });
+  }
+  const selectedItems = selectedItemsForRequest(request);
+  if (!selectedItems) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: "SELECTION_REQUIRED",
+      reason: "Cleanup review requires an explicit item selection"
+    });
+  }
+  const selection = resolveSelectedItems({
+    itemByKey: index.itemByKey,
+    selectedItems
+  });
+  if (selection.error) {
+    return rejectedExecution({
+      plan: request.plan,
+      actorUserId: request.actorUserId,
+      mode: request.mode,
+      now: request.now,
+      executionId,
+      code: selection.code ?? "SELECTION_INVALID",
+      reason: selection.error
+    });
+  }
+  const policyResult = await applyPolicyGate({
+    items: selection.items,
+    request,
+    executionId,
+    auditEvents
+  });
+  if (policyResult.eligibleItems.length === 0) {
+    return {
+      executionId,
+      planId: request.plan.id,
+      planHash: request.plan.planHash,
+      mode: request.mode,
+      status: "rejected",
+      actorUserId: request.actorUserId,
+      requestedItemCount: selection.items.length,
+      eligibleItemCount: 0,
+      skippedItems: policyResult.skippedItems,
+      results: [],
+      chunks: [],
+      auditEvents,
+      createdAt: request.now,
+      completedAt: request.now,
+      rejectionCode: "NO_ELIGIBLE_ITEMS",
+      rejectionReason: "No selected cleanup items passed policy checks"
+    };
+  }
+  if (request.mode === "execute") {
+    const unapprovedDestructiveItem = policyResult.eligibleItems.find(
+      (item) => item.operation.requiresUserApproval && !approvalCoversItem({
+        approval: request.confirmation?.destructiveApproval,
+        actorUserId: request.actorUserId,
+        planHash: request.plan.planHash,
+        item
+      })
+    );
+    if (unapprovedDestructiveItem) {
+      return rejectedExecution({
+        plan: request.plan,
+        actorUserId: request.actorUserId,
+        mode: request.mode,
+        now: request.now,
+        executionId,
+        code: "DESTRUCTIVE_APPROVAL_REQUIRED",
+        reason: `Destructive cleanup operation requires user approval: ${unapprovedDestructiveItem.itemKey}`,
+        auditEvents
+      });
+    }
+    const snapshotValidation = await verifyCurrentSnapshots({
+      items: policyResult.eligibleItems,
+      adapters: request.adapters
+    });
+    if (snapshotValidation.code) {
+      return rejectedExecution({
+        plan: request.plan,
+        actorUserId: request.actorUserId,
+        mode: request.mode,
+        now: request.now,
+        executionId,
+        code: snapshotValidation.code,
+        reason: snapshotValidation.reason ?? "Cleanup item snapshot verification failed",
+        auditEvents
+      });
+    }
+  }
+  const adapterRun = await runAdapterChunks({
+    request,
+    executionId,
+    items: policyResult.eligibleItems,
+    chunkSize,
+    auditEvents
+  });
+  const undo = request.mode === "execute" ? buildCleanupUndo({
+    executionId,
+    planHash: request.plan.planHash,
+    createdAt: request.now,
+    itemsByKey: index.itemByKey,
+    results: adapterRun.results
+  }) : void 0;
+  return {
+    executionId,
+    planId: request.plan.id,
+    planHash: request.plan.planHash,
+    mode: request.mode,
+    status: executionStatus(request.mode, adapterRun.results),
+    actorUserId: request.actorUserId,
+    requestedItemCount: selection.items.length,
+    eligibleItemCount: policyResult.eligibleItems.length,
+    skippedItems: policyResult.skippedItems,
+    results: adapterRun.results,
+    chunks: adapterRun.chunks,
+    auditEvents,
+    undo,
+    createdAt: request.now,
+    completedAt: request.now
+  };
+}
+function getCleanupUndoEligibility(undo, now) {
+  if (undo.status === "unsupported") {
+    return {
+      eligible: false,
+      code: "UNDO_UNSUPPORTED",
+      reason: "Cleanup execution did not produce undoable operations"
+    };
+  }
+  if (isExpired(undo.expiresAt, now)) {
+    return {
+      eligible: false,
+      code: "UNDO_EXPIRED",
+      reason: "Cleanup undo window has expired"
+    };
+  }
+  const hasEligibleItems = undo.items.some(
+    (item) => item.eligibility === "eligible"
+  );
+  if (!hasEligibleItems) {
+    return {
+      eligible: false,
+      code: "UNDO_UNSUPPORTED",
+      reason: "Cleanup execution did not produce undoable operations"
+    };
+  }
+  return { eligible: true };
+}
+function rejectedUndoExecution(args) {
+  const auditEvents = [];
+  pushAuditEvent(auditEvents, {
+    eventType: "cleanup.bulk_review.undo_rejected",
+    emittedAt: args.now,
+    actorUserId: args.actorUserId,
+    planHash: args.undo.planHash,
+    executionId: args.undo.executionId,
+    undoId: args.undo.undoId,
+    outcome: "rejected",
+    code: args.code,
+    message: args.reason
+  });
+  return {
+    undoId: args.undo.undoId,
+    executionId: args.undo.executionId,
+    planHash: args.undo.planHash,
+    actorUserId: args.actorUserId,
+    status: "rejected",
+    results: [],
+    auditEvents,
+    createdAt: args.now,
+    completedAt: args.now,
+    rejectionCode: args.code,
+    rejectionReason: args.reason
+  };
+}
+function undoExecutionStatus(results) {
+  const failed = results.some((result) => result.outcome === "failed");
+  const succeeded = results.some((result) => result.outcome === "succeeded");
+  if (succeeded && failed) {
+    return "partially_failed";
+  }
+  if (failed) {
+    return "failed";
+  }
+  return "succeeded";
+}
+async function undoCleanupExecution(request) {
+  let chunkSize;
+  try {
+    chunkSize = normalizeChunkSize(request.chunkSize);
+  } catch (error) {
+    return rejectedUndoExecution({
+      undo: request.undo,
+      actorUserId: request.actorUserId,
+      now: request.now,
+      code: "INVALID_CHUNK_SIZE",
+      reason: error instanceof Error ? error.message : "Cleanup undo chunk size is invalid"
+    });
+  }
+  if (request.confirmation.confirmedByUserId !== request.actorUserId) {
+    return rejectedUndoExecution({
+      undo: request.undo,
+      actorUserId: request.actorUserId,
+      now: request.now,
+      code: "UNDO_CONFIRMATION_USER_MISMATCH",
+      reason: "Cleanup undo confirmation belongs to a different user"
+    });
+  }
+  if (request.confirmation.planHash !== request.undo.planHash || request.confirmation.undoId !== request.undo.undoId || request.confirmation.executionId !== request.undo.executionId) {
+    return rejectedUndoExecution({
+      undo: request.undo,
+      actorUserId: request.actorUserId,
+      now: request.now,
+      code: "UNDO_CONFIRMATION_MISMATCH",
+      reason: "Cleanup undo confirmation does not match the undo record"
+    });
+  }
+  const eligibility = getCleanupUndoEligibility(request.undo, request.now);
+  if (!eligibility.eligible) {
+    return rejectedUndoExecution({
+      undo: request.undo,
+      actorUserId: request.actorUserId,
+      now: request.now,
+      code: eligibility.code ?? "UNDO_UNAVAILABLE",
+      reason: eligibility.reason ?? "Cleanup undo is unavailable"
+    });
+  }
+  const auditEvents = [];
+  const results = [];
+  let chunkIndex = 0;
+  const eligibleItems = request.undo.items.filter(
+    (item) => item.eligibility === "eligible"
+  );
+  for (const [provider, providerItems] of groupUndoItemsByProvider(
+    eligibleItems
+  )) {
+    const adapter = request.adapters[provider];
+    if (!adapter?.undoChunk) {
+      for (const item of providerItems) {
+        const failed = {
+          itemKey: item.itemKey,
+          outcome: "failed",
+          code: "UNDO_UNSUPPORTED_BY_ADAPTER",
+          message: `Cleanup adapter for ${provider} does not support undo`
+        };
+        results.push(failed);
+        pushAuditEvent(auditEvents, {
+          eventType: "cleanup.bulk_review.undo_failed",
+          emittedAt: request.now,
+          actorUserId: request.actorUserId,
+          planHash: request.undo.planHash,
+          executionId: request.undo.executionId,
+          undoId: request.undo.undoId,
+          undoItem: item,
+          outcome: "failed",
+          code: failed.code,
+          message: failed.message
+        });
+      }
+      continue;
+    }
+    for (const chunk of chunkItems(providerItems, chunkSize)) {
+      let adapterResults;
+      try {
+        const chunkResult = await adapter.undoChunk({
+          undoId: request.undo.undoId,
+          provider,
+          chunkIndex,
+          operations: chunk.map((item) => ({
+            undoId: request.undo.undoId,
+            planHash: request.undo.planHash,
+            actorUserId: request.actorUserId,
+            item
+          }))
+        });
+        adapterResults = chunkResult.results;
+      } catch (error) {
+        adapterResults = chunk.map((item) => ({
+          itemKey: item.itemKey,
+          outcome: "failed",
+          code: "UNDO_CHUNK_FAILED",
+          message: error instanceof Error ? error.message : "Cleanup adapter undo chunk failed"
+        }));
+      }
+      const resultByItemKey = /* @__PURE__ */ new Map();
+      for (const result of adapterResults) {
+        resultByItemKey.set(result.itemKey, result);
+      }
+      for (const item of chunk) {
+        const result = resultByItemKey.get(item.itemKey) ?? {
+          itemKey: item.itemKey,
+          outcome: "failed",
+          code: "UNDO_RESULT_MISSING",
+          message: "Cleanup adapter did not return an undo result for this item"
+        };
+        results.push(result);
+        pushAuditEvent(auditEvents, {
+          eventType: result.outcome === "succeeded" ? "cleanup.bulk_review.undo_executed" : "cleanup.bulk_review.undo_failed",
+          emittedAt: request.now,
+          actorUserId: request.actorUserId,
+          planHash: request.undo.planHash,
+          executionId: request.undo.executionId,
+          undoId: request.undo.undoId,
+          undoItem: item,
+          outcome: result.outcome,
+          code: result.code,
+          message: result.message,
+          metadata: result.metadata
+        });
+      }
+      chunkIndex += 1;
+    }
+  }
+  return {
+    undoId: request.undo.undoId,
+    executionId: request.undo.executionId,
+    planHash: request.undo.planHash,
+    actorUserId: request.actorUserId,
+    status: undoExecutionStatus(results),
+    results,
+    auditEvents,
+    createdAt: request.now,
+    completedAt: request.now
+  };
+}
+export {
+  CLEANUP_BULK_REVIEW_SCHEMA_VERSION,
+  DEFAULT_CLEANUP_EXECUTION_CHUNK_SIZE,
+  DEFAULT_CLEANUP_PLAN_ITEM_LIMIT,
+  MAX_CLEANUP_EXECUTION_CHUNK_SIZE,
+  bindCleanupPlanHash,
+  computeCleanupPlanHash,
+  executeCleanupPlan,
+  getCleanupItemKey,
+  getCleanupUndoEligibility,
+  hashCleanupItemSnapshot,
+  undoCleanupExecution
+};
+//# sourceMappingURL=bulk-review.js.map