@wangxiaocuo/dsh-session-trash 0.6.0 → 0.6.2

package/lib/inventory.js

@@ -1,6 +1,11 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
+import { mapLimit } from './concurrency.js'
 import { entryKind, isSafeDirectoryPath, isSafeMemberId, isSafeTrashId, samePath } from './fsops.js'
+import { memberList } from './members.js'
+
+/** Maximum concurrent object directories inspected during a scan. */
+const SCAN_CONCURRENCY = 4
 
 /** Every state the durable index understands. */
 export const ENTRY_STATES = new Set(['trashing', 'trashed', 'restoring', 'purging', 'missing'])
@@ -220,6 +225,22 @@ export async function memberPresence(store, entry) {
   return { total: members.length, present, missing }
 }
 
+/**
+ * Whether two member lists name the same directories in the same order, so a
+ * presence probe taken for one can be reused for the other.
+ *
+ * @param {readonly object[]} left first member list.
+ * @param {readonly object[]} right second member list.
+ * @returns {boolean} whether both lists describe the same members.
+ */
+function sameMembers(left, right) {
+  if (left.length !== right.length) return false
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index]?.sessionId !== right[index]?.sessionId) return false
+  }
+  return true
+}
+
 /**
  * Reconcile a rebuilt entry with the object directory observed on disk.
  *
@@ -271,13 +292,8 @@ export async function scanObjects(store, logger) {
     if (error !== null && error !== undefined && error.code === 'ENOENT') return { objects: [], unindexed: 0 }
     throw error
   }
-  const objects = []
-  let unindexed = 0
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !isSafeTrashId(entry.name)) {
-      unindexed += 1
-      continue
-    }
+  const scanned = await mapLimit(entries, SCAN_CONCURRENCY, async (entry) => {
+    if (!entry.isDirectory() || !isSafeTrashId(entry.name)) return { unindexed: 1 }
     const trashId = entry.name
     let meta
     try {
@@ -286,15 +302,11 @@ export async function scanObjects(store, logger) {
       logger.warn(`cannot read the trash metadata for ${trashId}: ${error instanceof Error ? error.message : String(error)}`)
       // Keep the directory in the inventory so reconcile never mistakes an
       // unreadable sidecar for a vanished object directory.
-      objects.push({ trashId, sessionExists: false, meta: undefined, metaValid: false })
-      unindexed += 1
-      continue
+      return { object: { trashId, sessionExists: false, meta: undefined, metaValid: false }, unindexed: 1 }
     }
     const metaValid = meta !== undefined && isValidMeta(meta, trashId)
     if (!metaValid) {
-      objects.push({ trashId, sessionExists: false, meta, metaValid: false })
-      unindexed += 1
-      continue
+      return { object: { trashId, sessionExists: false, meta, metaValid: false }, unindexed: 1 }
     }
     let presence
     try {
@@ -303,14 +315,23 @@ export async function scanObjects(store, logger) {
       logger.warn(`cannot inspect the trash copy ${trashId}: ${error instanceof Error ? error.message : String(error)}`)
       presence = { total: 0, present: 0, missing: [] }
     }
-    objects.push({
-      trashId,
-      sessionExists: presence.total > 0 && presence.present === presence.total,
-      meta,
-      metaValid,
-      entry: toEntry(meta),
-      presence,
-    })
+    return {
+      object: {
+        trashId,
+        sessionExists: presence.total > 0 && presence.present === presence.total,
+        meta,
+        metaValid,
+        entry: toEntry(meta),
+        presence,
+      },
+      unindexed: 0,
+    }
+  })
+  const objects = []
+  let unindexed = 0
+  for (const result of scanned) {
+    unindexed += result.unindexed
+    if (result.object !== undefined) objects.push(result.object)
   }
   return { objects, unindexed }
 }
@@ -321,12 +342,15 @@ export async function scanObjects(store, logger) {
  * directory.
  *
  * @param {{ store: import('./store.js').TrashStore, logger: { warn: Function }, now?: number }} input trash store and diagnostics.
- * @returns {Promise<{ imported: number, markedMissing: number, unindexed: number, changed: number }>} reconcile summary.
+ * @returns {Promise<{ imported: number, markedMissing: number, unindexed: number, changed: number, presence: Map<string, object> }>} reconcile summary plus the presence probe per object.
  */
 export async function reconcileIndex({ store, logger, now = Date.now() }) {
-  if (store.isProtected()) return { imported: 0, markedMissing: 0, unindexed: store.unindexed, changed: 0 }
+  if (store.isProtected()) {
+    return { imported: 0, markedMissing: 0, unindexed: store.unindexed, changed: 0, presence: new Map() }
+  }
   const { objects, unindexed: invalidObjects } = await scanObjects(store, logger)
   const byTrashId = new Map(objects.map((object) => [object.trashId, object]))
+  const presenceByTrashId = new Map()
   const nextEntries = [...store.entries()]
   const indexedTrashIds = new Set(nextEntries.map((entry) => entry.trashId))
   const sessionIds = new Set(nextEntries.map((entry) => entry.sessionId))
@@ -351,7 +375,16 @@ export async function reconcileIndex({ store, logger, now = Date.now() }) {
       changed = true
       continue
     }
-    const presence = await memberPresence(store, entry)
+    // The scan already probed every member directory of this object. Reuse that
+    // answer when the sidecar and the index entry describe the same members;
+    // otherwise probe again rather than trust a mismatched snapshot.
+    const presence =
+      object.presence !== undefined &&
+      object.entry !== undefined &&
+      sameMembers(memberList(object.entry), memberList(entry))
+        ? object.presence
+        : await memberPresence(store, entry)
+    presenceByTrashId.set(object.trashId, presence)
     if (entry.state === 'missing' && presence.total > 0 && presence.present === presence.total) {
       nextEntries[index] = {
         ...entry,
@@ -392,7 +425,7 @@ export async function reconcileIndex({ store, logger, now = Date.now() }) {
     }
   }
   store.unindexed = unindexed
-  return { imported, markedMissing, unindexed, changed: changed ? 1 : 0 }
+  return { imported, markedMissing, unindexed, changed: changed ? 1 : 0, presence: presenceByTrashId }
 }
 
 /**

package/lib/state.js

@@ -1,30 +1,10 @@
 import fs from 'node:fs/promises'
+import { mapLimit } from './concurrency.js'
 import { memberList } from './members.js'
 
 /** Maximum concurrent filesystem probes while describing entries. */
 const PROBE_CONCURRENCY = 3
 
-/**
- * @param {readonly T[]} items input items.
- * @param {number} limit maximum in-flight operations.
- * @param {(item: T) => Promise<R>} worker per-item operation.
- * @returns {Promise<R[]>} results in input order.
- * @template T, R
- */
-async function mapLimit(items, limit, worker) {
-  const results = new Array(items.length)
-  let next = 0
-  const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
-    while (next < items.length) {
-      const index = next
-      next += 1
-      results[index] = await worker(items[index])
-    }
-  })
-  await Promise.all(runners)
-  return results
-}
-
 /**
  * @param {string | null | undefined} directory candidate workspace directory.
  * @returns {Promise<boolean>} whether the directory exists right now.

package/lib/trash-service.js

@@ -13,6 +13,7 @@ import {
   moveDirectory,
   samePath,
 } from './fsops.js'
+import { mapLimit } from './concurrency.js'
 import { reconcileIndex, rebuildIndex, memberPresence } from './inventory.js'
 import { aggregateMetrics, memberList } from './members.js'
 
@@ -22,6 +23,9 @@ const VISIBILITY_RETRIES = 5
 /** Delay between visibility probes. */
 const VISIBILITY_DELAY_MS = 100
 
+/** Maximum concurrent object deletions and sidecar rewrites during a purge. */
+const PURGE_CONCURRENCY = 4
+
 /**
  * @param {number} milliseconds delay length.
  * @returns {Promise<void>} resolution after the delay.
@@ -219,22 +223,46 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
   }
 
   /**
+   * Probe every member directory in parallel: where the source copy and the
+   * trash copy currently live.
+   *
    * @param {object} entry index entry.
    * @returns {Promise<{ index: number, member: object, source: boolean, trash: boolean }[]>} member positions.
    */
   async function memberRows(entry) {
     const members = membersOf(entry)
-    const rows = []
-    for (let index = 0; index < members.length; index += 1) {
-      const member = members[index]
-      rows.push({
+    return Promise.all(
+      members.map(async (member, index) => {
+        const [sourceKind, trashKind] = await Promise.all([
+          kindOf(member.originalSessionDir),
+          kindOf(memberTrashPath(entry, index)),
+        ])
+        return {
+          index,
+          member,
+          source: sourceKind === 'directory',
+          trash: trashKind === 'directory',
+        }
+      }),
+    )
+  }
+
+  /**
+   * Probe only the original session directories of every member, in parallel.
+   * Used by recovery after the trash copies were already proven present.
+   *
+   * @param {object} entry index entry.
+   * @returns {Promise<{ index: number, member: object, source: boolean }[]>} member source positions.
+   */
+  async function sourceRows(entry) {
+    const members = membersOf(entry)
+    return Promise.all(
+      members.map(async (member, index) => ({
         index,
         member,
         source: (await kindOf(member.originalSessionDir)) === 'directory',
-        trash: (await kindOf(memberTrashPath(entry, index))) === 'directory',
-      })
-    }
-    return rows
+      })),
+    )
   }
 
   /**
@@ -382,14 +410,14 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
    * @returns {Promise<{ hidden: boolean, sessionId?: string }>} whether session storage stopped reporting every member.
    */
   async function waitForMembersHidden(entry) {
-    for (const member of membersOf(entry)) {
-      const hidden = await waitForVisibility(
-        member.sessionId,
-        (current) => current === undefined || current === null,
-      )
-      if (!hidden) return { hidden: false, sessionId: member.sessionId }
-    }
-    return { hidden: true }
+    const results = await Promise.all(
+      membersOf(entry).map(async (member) => ({
+        sessionId: member.sessionId,
+        hidden: await waitForVisibility(member.sessionId, (current) => current === undefined || current === null),
+      })),
+    )
+    const failed = results.find((result) => !result.hidden)
+    return failed === undefined ? { hidden: true } : { hidden: false, sessionId: failed.sessionId }
   }
 
   /**
@@ -397,14 +425,17 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
    * @returns {Promise<{ visible: boolean, sessionId?: string }>} whether session storage reports every member again.
    */
   async function waitForMembersVisible(entry) {
-    for (const member of membersOf(entry)) {
-      const visible = await waitForVisibility(
-        member.sessionId,
-        (current) => current !== undefined && current !== null && current.location !== undefined,
-      )
-      if (!visible) return { visible: false, sessionId: member.sessionId }
-    }
-    return { visible: true }
+    const results = await Promise.all(
+      membersOf(entry).map(async (member) => ({
+        sessionId: member.sessionId,
+        visible: await waitForVisibility(
+          member.sessionId,
+          (current) => current !== undefined && current !== null && current.location !== undefined,
+        ),
+      })),
+    )
+    const failed = results.find((result) => !result.visible)
+    return failed === undefined ? { visible: true } : { visible: false, sessionId: failed.sessionId }
   }
 
   /**
@@ -826,6 +857,99 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
     return entry.trashedAt + config.retentionDays * 86_400_000 <= now
   }
 
+  /**
+   * Permanently remove a batch of object directories and their index entries in
+   * a bounded number of index writes. Every entry is first committed as
+   * `purging` in one write, so a crash still settles forward on the next
+   * recovery; successes are dropped and failures annotated in one final write.
+   * The caller owns the trash lock.
+   *
+   * @param {readonly object[]} targets `trashed` entries to purge.
+   * @returns {Promise<{ purged: number, failures: { entry: object, error: unknown, phase: string }[] }>} per-entry outcome.
+   */
+  async function purgeManyInsideLock(targets) {
+    const failures = []
+    const purging = []
+    for (const entry of targets) {
+      try {
+        await assertSafeObject(entry)
+        purging.push({ ...entry, state: 'purging', lastError: null })
+      } catch (error) {
+        failures.push({ entry, error, phase: 'validate' })
+      }
+    }
+    if (purging.length === 0) return { purged: 0, failures }
+
+    let marked = store.entries()
+    for (const entry of purging) marked = upsertEntry(marked, entry)
+    try {
+      await store.commit(marked)
+    } catch (error) {
+      const failure = new TrashError(
+        'INDEX_WRITE_FAILED',
+        'The session logs were not deleted because the trash index could not be updated.',
+        { code: error instanceof TrashError ? error.code : null },
+      )
+      for (const entry of purging) failures.push({ entry, error: failure, phase: 'mark' })
+      return { purged: 0, failures }
+    }
+    await mapLimit(purging, PURGE_CONCURRENCY, async (entry) => {
+      await store.writeMeta(entry).catch((error) => {
+        logger.warn(`cannot rewrite trash metadata for ${entry.trashId}: ${messageOf(error)}`)
+      })
+    })
+
+    const deleted = await mapLimit(purging, PURGE_CONCURRENCY, async (entry) => {
+      try {
+        await store.removeObjectDir(entry.trashId)
+        return { entry, deleted: true }
+      } catch (error) {
+        return { entry, deleted: false, error }
+      }
+    })
+    const completed = []
+    const annotated = []
+    for (const result of deleted) {
+      if (result.deleted) {
+        completed.push(result.entry)
+        logger.info(`permanently deleted ${result.entry.sessionId} (${result.entry.trashId})`)
+        continue
+      }
+      annotated.push({
+        ...result.entry,
+        lastError: errorText(`The session log could not be deleted: ${messageOf(result.error)}`),
+      })
+      failures.push({
+        entry: result.entry,
+        error: new TrashError('IO_ERROR', 'The session log could not be deleted.', { trashId: result.entry.trashId }),
+        phase: 'delete',
+      })
+    }
+
+    let settled = store.entries()
+    for (const entry of completed) settled = dropEntry(settled, entry.sessionId)
+    for (const entry of annotated) settled = upsertEntry(settled, entry)
+    try {
+      await store.commit(settled)
+    } catch (error) {
+      const failure = new TrashError(
+        'INDEX_WRITE_FAILED',
+        'The session logs were deleted, but the trash index could not be updated.',
+        { code: error instanceof TrashError ? error.code : null },
+      )
+      for (const entry of completed) failures.push({ entry, error: failure, phase: 'drop' })
+      // The deleted objects no longer match the purging entries; the next
+      // recovery drops them, so nothing is reported as successfully purged.
+      return { purged: 0, failures }
+    }
+    await mapLimit(annotated, PURGE_CONCURRENCY, async (entry) => {
+      await store.writeMeta(entry).catch((error) => {
+        logger.warn(`cannot rewrite trash metadata for ${entry.trashId}: ${messageOf(error)}`)
+      })
+    })
+    return { purged: completed.length, failures }
+  }
+
   /**
    * Permanently remove one object directory and its index entry. The caller
    * owns the trash lock.
@@ -834,26 +958,35 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
    * @returns {Promise<void>} resolution once the object and entry are gone.
    */
   async function purgeInsideLock(entry) {
-    await assertSafeObject(entry)
-    const purging = { ...entry, state: 'purging', lastError: null }
-    await store.commit(upsertEntry(store.entries(), purging))
-    await store.writeMeta(purging).catch((error) => {
-      logger.warn(`cannot rewrite trash metadata for ${entry.trashId}: ${messageOf(error)}`)
-    })
-    try {
-      await store.removeObjectDir(entry.trashId)
-    } catch (error) {
-      await markFailure(purging, `The session log could not be deleted: ${messageOf(error)}`)
-      throw new TrashError('IO_ERROR', 'The session log could not be deleted.', { trashId: entry.trashId })
-    }
+    const result = await purgeManyInsideLock([entry])
+    if (result.failures.length > 0) throw result.failures[0].error
+  }
+
+  /**
+   * Drop a batch of `missing` entries from the index in one write and remove
+   * their plugin-owned remnants. No session file is deleted. The caller owns
+   * the trash lock.
+   *
+   * @param {readonly object[]} entries `missing` index entries to forget.
+   * @returns {Promise<number>} how many entries were removed from the index.
+   */
+  async function forgetManyInsideLock(entries) {
+    if (entries.length === 0) return 0
+    let next = store.entries()
+    for (const entry of entries) next = dropEntry(next, entry.sessionId)
     try {
-      await store.commit(dropEntry(store.entries(), entry.sessionId))
+      await store.commit(next)
     } catch (error) {
-      throw new TrashError('INDEX_WRITE_FAILED', 'The session log was deleted, but the trash index could not be updated.', {
+      throw new TrashError('INDEX_WRITE_FAILED', 'The trash index could not be updated.', {
         code: error instanceof TrashError ? error.code : null,
       })
     }
-    logger.info(`permanently deleted ${entry.sessionId} (${entry.trashId})`)
+    for (const entry of entries) {
+      await store.removeObjectRemnants(entry.trashId).catch((error) => {
+        logger.warn(`cannot remove the remnants of ${entry.trashId}: ${messageOf(error)}`)
+      })
+    }
+    return entries.length
   }
 
   /**
@@ -864,16 +997,7 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
    * @returns {Promise<{ sessionId: string, title: string }>} the removed identity.
    */
   async function forgetInsideLock(entry) {
-    try {
-      await store.commit(dropEntry(store.entries(), entry.sessionId))
-    } catch (error) {
-      throw new TrashError('INDEX_WRITE_FAILED', 'The trash index could not be updated.', {
-        code: error instanceof TrashError ? error.code : null,
-      })
-    }
-    await store.removeObjectRemnants(entry.trashId).catch((error) => {
-      logger.warn(`cannot remove the remnants of ${entry.trashId}: ${messageOf(error)}`)
-    })
+    await forgetManyInsideLock([entry])
     return { sessionId: entry.sessionId, title: entry.title }
   }
 
@@ -1222,12 +1346,16 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
   /**
    * Apply the crash matrix to every index entry. The caller must hold the trash
    * lock. It never deletes an unindexed object and never removes a `missing`
-   * entry on its own.
+   * entry on its own. An optional presence map lets the caller reuse the probe
+   * results from the preceding reconcile instead of stat-ing every member
+   * directory again.
    *
+   * @param {Map<string, { total: number, present: number, missing: string[] }>} [presenceByTrashId] reconcile probe results keyed by object identity.
    * @returns {Promise<{ changed: number, completed: number, rolledBack: number, missing: number }>} recovery summary.
    */
-  async function recoverInsideLock() {
+  async function recoverInsideLock(presenceByTrashId = new Map()) {
     let entries = [...store.entries()]
+    const metaUpdates = []
     let changed = 0
     let completed = 0
     let rolledBack = 0
@@ -1235,6 +1363,7 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
     const commit = (next) => {
       if (next === undefined) return
       entries = upsertEntry(entries, next)
+      metaUpdates.push(next)
     }
     const drop = (sessionId) => {
       entries = dropEntry(entries, sessionId)
@@ -1300,7 +1429,7 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
 
         if (original.state === 'trashed') {
           await assertSafeObject(original)
-          const presence = await memberPresence(store, original)
+          const presence = presenceByTrashId.get(original.trashId) ?? (await memberPresence(store, original))
           if (presence.present < presence.total) {
             commit({
               ...original,
@@ -1314,8 +1443,8 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
             changed += 1
             continue
           }
-          const rows = await memberRows(original)
-          if (rows.some((row) => row.source)) {
+          const sources = await sourceRows(original)
+          if (sources.some((row) => row.source)) {
             commit(fail(original, 'An original session directory unexpectedly exists alongside the trash copy; both were kept.'))
             changed += 1
           }
@@ -1328,7 +1457,7 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
 
     if (changed > 0) {
       await store.commit(entries)
-      for (const entry of entries) {
+      for (const entry of metaUpdates) {
         await store.writeMeta(entry).catch((error) => {
           logger.warn(`cannot refresh trash metadata for ${entry.trashId}: ${messageOf(error)}`)
         })
@@ -1355,7 +1484,7 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
       return summary
     } catch (error) {
       logger.warn(`trash index reconciliation failed: ${messageOf(error)}`)
-      return { imported: 0, markedMissing: 0, unindexed: store.unindexed, changed: 0 }
+      return { imported: 0, markedMissing: 0, unindexed: store.unindexed, changed: 0, presence: new Map() }
     }
   }
 
@@ -1372,18 +1501,17 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
         throw new TrashError('INDEX_CORRUPT', 'The trash index is unreadable, so protection mode refuses cleanup.')
       }
       const reconcile = await reconcileInsideLock(now)
-      const recovery = await recoverInsideLock()
+      const recovery = await recoverInsideLock(reconcile.presence)
       let purged = 0
       let failed = 0
       if (allowPurge) {
-        for (const entry of [...store.entries()]) {
-          if (!isExpired(entry, now)) continue
-          try {
-            await purgeInsideLock(entry)
-            purged += 1
-          } catch (error) {
-            failed += 1
-            logger.warn(`cannot purge the expired session ${entry.sessionId}: ${messageOf(error)}`)
+        const expired = [...store.entries()].filter((entry) => isExpired(entry, now))
+        if (expired.length > 0) {
+          const result = await purgeManyInsideLock(expired)
+          purged = result.purged
+          failed = result.failures.length
+          for (const failure of result.failures) {
+            logger.warn(`cannot purge the expired session ${failure.entry.sessionId}: ${messageOf(failure.error)}`)
           }
         }
       }
@@ -1453,34 +1581,59 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
         throw new TrashError('INDEX_CORRUPT', 'The trash index is unreadable, so protection mode refuses deletion.')
       }
       const reconcile = await reconcileInsideLock(Date.now())
-      const recovery = await recoverInsideLock()
-      let purged = 0
-      let forgotten = 0
-      let failed = 0
+      const recovery = await recoverInsideLock(reconcile.presence)
       const failures = []
+      const purgeTargets = []
+      const forgetTargets = []
+      let failed = 0
       for (const entry of [...store.entries()]) {
+        if (entry.state === 'trashed') {
+          purgeTargets.push(entry)
+          continue
+        }
+        if (entry.state === 'missing') {
+          forgetTargets.push(entry)
+          continue
+        }
         const title = typeof entry.title === 'string' ? entry.title : ''
-        try {
-          if (entry.state === 'trashed') {
-            await purgeInsideLock(entry)
-            purged += 1
-            continue
-          }
-          if (entry.state === 'missing') {
-            await forgetInsideLock(entry)
-            forgotten += 1
-            continue
-          }
+        const message = `The trash entry is in state "${entry.state}" and cannot be cleaned up.`
+        failed += 1
+        failures.push({ sessionId: entry.sessionId, title, message })
+        logger.warn(`cannot purge the session ${entry.sessionId}: ${message}`)
+      }
+
+      let purged = 0
+      if (purgeTargets.length > 0) {
+        const result = await purgeManyInsideLock(purgeTargets)
+        purged = result.purged
+        for (const failure of result.failures) {
           failed += 1
-          const message = `The trash entry is in state "${entry.state}" and cannot be cleaned up.`
-          failures.push({ sessionId: entry.sessionId, title, message })
-          logger.warn(`cannot purge the session ${entry.sessionId}: ${message}`)
+          failures.push({
+            sessionId: failure.entry.sessionId,
+            title: typeof failure.entry.title === 'string' ? failure.entry.title : '',
+            message: messageOf(failure.error),
+          })
+          logger.warn(`cannot purge the trashed session ${failure.entry.sessionId}: ${messageOf(failure.error)}`)
+        }
+      }
+
+      let forgotten = 0
+      if (forgetTargets.length > 0) {
+        try {
+          forgotten = await forgetManyInsideLock(forgetTargets)
         } catch (error) {
-          failed += 1
-          failures.push({ sessionId: entry.sessionId, title, message: messageOf(error) })
-          logger.warn(`cannot purge the trashed session ${entry.sessionId}: ${messageOf(error)}`)
+          failed += forgetTargets.length
+          for (const entry of forgetTargets) {
+            failures.push({
+              sessionId: entry.sessionId,
+              title: typeof entry.title === 'string' ? entry.title : '',
+              message: messageOf(error),
+            })
+            logger.warn(`cannot forget the missing session ${entry.sessionId}: ${messageOf(error)}`)
+          }
         }
       }
+
       logger.info(`bulk purge finished: purged ${purged}, forgotten ${forgotten}, failed ${failed}`)
       return {
         purged,
@@ -1569,8 +1722,8 @@ export function createTrashService({ ctx, store, eligibility, config, logger, pa
     try {
       summary = await store.withLock(async () => {
         if (store.isProtected()) return { changed: 0, completed: 0, rolledBack: 0, missing: 0 }
-        await reconcileInsideLock(Date.now())
-        return await recoverInsideLock()
+        const reconcile = await reconcileInsideLock(Date.now())
+        return await recoverInsideLock(reconcile.presence)
       })
     } catch (error) {
       if (error instanceof TrashError && error.code === 'LOCKED') {