bunqueue 2.8.50 → 2.8.52

package/dist/application/operations/ack.d.ts

@@ -9,6 +9,7 @@ import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { RWLock } from '../../shared/lock';
 import type { SetLike, MapLike } from '../../shared/lru';
 import type { DependencyResultTracker } from '../dependencyResultTracker';
+import { type DependencyCompletionTracker } from '../dependencyCompletions';
 /** Ack operation context */
 export interface AckContext {
     storage: SqliteStorage | null;
@@ -19,7 +20,8 @@ export interface AckContext {
     completedJobs: SetLike<JobId>;
     completedJobsData: MapLike<JobId, Job>;
     /** Bare completion ids for removeOnComplete jobs so dependents can unblock */
-    depCompletions?: SetLike<JobId>;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
     jobResults: MapLike<JobId, unknown>;
     dependencyResults: DependencyResultTracker;
     jobIndex: Map<JobId, JobLocation>;

package/dist/application/operations/ack.js

@@ -8,6 +8,7 @@ import { shardIndex, processingShardIndex } from '../../shared/hash';
 import { latencyTracker } from '../latencyTracker';
 import { throughputTracker } from '../throughputTracker';
 import { groupByProcShard, groupItemsByProcShard, extractJobs, extractJobsWithResults, groupByQueueShard, releaseResources, finalizeBatchAck, } from './ackHelpers';
+import { commitRemovedCompletion, } from '../dependencyCompletions';
 /**
  * Acknowledge job completion
  */
@@ -52,13 +53,12 @@ export async function ackJob(jobId, result, ctx) {
         ctx.storage?.markCompleted(jobId, now, job.timeline);
     }
     else {
+        commitRemovedCompletion(job, ctx);
         ctx.jobIndex.delete(jobId);
-        ctx.storage?.deleteJob(jobId);
         // removeOnComplete drops the full job (index + data + persisted row) to bound
         // memory, but dependent jobs gate readiness on completedJobs.has(parentId).
         // Record the bare completion id (no payload) so dependents still unblock,
         // without making the job appear in state/stats queries.
-        ctx.depCompletions?.add(jobId);
     }
     if (result !== undefined)
         ctx.dependencyResults.retain(jobId, result);

package/dist/application/operations/ackHelpers.d.ts

@@ -1,6 +1,4 @@
-/**
- * Ack Helpers - Shared batch processing utilities
- */
+/** Shared batch acknowledgement utilities. */
 import type { Job, JobId } from '../../domain/types/job';
 import type { JobLocation, EventType } from '../../domain/types/queue';
 import type { Shard } from '../../domain/queue/shard';
@@ -8,6 +6,7 @@ import type { RWLock } from '../../shared/lock';
 import type { SetLike, MapLike } from '../../shared/lru';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { DependencyResultTracker } from '../dependencyResultTracker';
+import { type DependencyCompletionTracker } from '../dependencyCompletions';
 export interface ExtractedJob<T = unknown> {
     id: JobId;
     job: Job;
@@ -53,10 +52,12 @@ export declare function releaseResources(byQueueShard: Map<number, Job[]>, ctx:
 /** Context for finalize operations */
 export interface FinalizeContext {
     storage: SqliteStorage | null;
+    shards: Shard[];
     completedJobs: SetLike<JobId>;
     completedJobsData: MapLike<JobId, Job>;
     /** Bare completion ids for removeOnComplete jobs so dependents can unblock */
-    depCompletions?: SetLike<JobId>;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
     jobResults: MapLike<JobId, unknown>;
     dependencyResults?: DependencyResultTracker;
     jobIndex: Map<JobId, JobLocation>;

package/dist/application/operations/ackHelpers.js

@@ -1,10 +1,8 @@
-/**
- * Ack Helpers - Shared batch processing utilities
- */
 import { MAX_TIMELINE_ENTRIES } from '../../domain/types/job';
 import { withWriteLock } from '../../shared/lock';
 import { shardIndex, processingShardIndex } from '../../shared/hash';
 import { throughputTracker } from '../throughputTracker';
+import { commitRemovedCompletion, } from '../dependencyCompletions';
 /**
  * Group job IDs by processing shard
  * Returns Map<shardIndex, jobIds[]>
@@ -161,14 +159,10 @@ export function finalizeBatchAck(extractedJobs, ctx, includeResults) {
             ctx.completedJobs.add(jobId);
         }
         else {
+            commitRemovedCompletion(job, ctx, now);
             ctx.jobIndex.delete(jobId);
-            if (hasStorage)
-                storage.deleteJob(jobId);
-            // removeOnComplete drops the full job to bound memory, but dependents gate
-            // readiness on completedJobs.has(parentId). Record the bare completion id
-            // (no payload) so dependent jobs still unblock, without surfacing the job
-            // in state/stats queries.
-            ctx.depCompletions?.add(jobId);
+            // The helper publishes payload-free dependency evidence only after its
+            // durable job-removal transaction commits.
         }
     }
     for (let i = 0; i < jobCount; i++) {

package/dist/application/operations/customId.d.ts

@@ -3,11 +3,14 @@ import { type Job, type JobId, type JobInput } from '../../domain/types/job';
 import type { JobLocation } from '../../domain/types/queue';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { MapLike, SetLike } from '../../shared/lru';
+import { type DependencyCompletionTracker } from '../dependencyCompletions';
 export interface CustomIdContext {
     storage: SqliteStorage | null;
     shards: Shard[];
     completedJobs: SetLike<JobId>;
     completedJobsData: MapLike<JobId, Job>;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
     timedOutJobs?: SetLike<JobId>;
     jobResults: MapLike<JobId, unknown>;
     customIdMap: MapLike<string, JobId>;

package/dist/application/operations/customId.js

@@ -1,5 +1,6 @@
 import { generateJobId, jobId } from '../../domain/types/job';
 import { shardIndex } from '../../shared/hash';
+import { releaseDependencyCompletionPins, } from '../dependencyCompletions';
 /**
  * Enforce custom-ID idempotency while the caller holds the target shard lock.
  * Live generations are returned unchanged; terminal generations are retired
@@ -50,6 +51,15 @@ export function handleCustomId(input, ctx, lockedShardIndexes) {
         // id. The fresh jobs row is inserted only after this retirement completes.
         ctx.storage?.deleteDlqEntry(id);
     }
+    if (ctx.depCompletions?.has(id)) {
+        const hasUnresolvedConsumers = ctx.shards.some((shard) => (shard.getJobsWaitingFor(id)?.size ?? 0) > 0);
+        if (hasUnresolvedConsumers) {
+            throw new Error(`Custom ID ${String(id)} still has unresolved dependency consumers`);
+        }
+        releaseDependencyCompletionPins([id], ctx);
+        ctx.storage?.deleteDependencyCompletion(id);
+        ctx.depCompletions.delete(id);
+    }
     // A durable jobs row may outlive its in-memory tracking after an interrupted
     // cleanup. The storage insert upserts that orphan without adding a DELETE to
     // every custom-ID push.

package/dist/application/operations/jobManagement.d.ts

@@ -10,6 +10,7 @@ import type { WebhookManager } from '../webhookManager';
 import type { EventsManager } from '../eventsManager';
 import { type RWLock } from '../../shared/lock';
 import type { DependencyResultTracker } from '../dependencyResultTracker';
+import { type DependencyCompletionTracker } from '../dependencyCompletions';
 export { discardJob, moveJobToDelayed } from './jobMoveOperations';
 /** Context for job management operations */
 export interface JobManagementContext {
@@ -25,6 +26,8 @@ export interface JobManagementContext {
     eventsManager: EventsManager;
     repeatChain?: Map<JobId, JobId>;
     dependencyResults: DependencyResultTracker;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
 }
 /** Cancel a job (remove from queue) */
 export declare function cancelJob(jobId: JobId, ctx: JobManagementContext): Promise<boolean>;

package/dist/application/operations/jobManagement.js

@@ -5,6 +5,7 @@
 import { processingShardIndex } from '../../shared/hash';
 import { webhookLog } from '../../shared/logger';
 import { withWriteLock } from '../../shared/lock';
+import { releaseDependencyCompletionPins, } from '../dependencyCompletions';
 export { discardJob, moveJobToDelayed } from './jobMoveOperations';
 /** Cancel a job (remove from queue) */
 export async function cancelJob(jobId, ctx) {
@@ -23,7 +24,7 @@ export async function cancelJob(jobId, ctx) {
                 ctx.jobIndex.delete(jobId);
                 ctx.storage?.deleteJob(jobId);
                 ctx.dependencyResults.releaseConsumer(jobId);
-                return { success: true, queueName: location.queueName };
+                return { success: true, queueName: location.queueName, released: [] };
             }
             // Not in the run queue — it may be parked in waitingChildren (moved via
             // moveToWaitingChildren, which already released its resources and does not
@@ -34,7 +35,7 @@ export async function cancelJob(jobId, ctx) {
                 ctx.jobIndex.delete(jobId);
                 ctx.storage?.deleteJob(jobId);
                 ctx.dependencyResults.releaseConsumer(jobId);
-                return { success: true, queueName: location.queueName };
+                return { success: true, queueName: location.queueName, released: [] };
             }
             // Or parked in waitingDeps (flow-chain dependent inserted by push.ts while
             // its predecessors are unresolved). These are NOT counted in the queued
@@ -50,11 +51,16 @@ export async function cancelJob(jobId, ctx) {
                 ctx.jobIndex.delete(jobId);
                 ctx.storage?.deleteJob(jobId);
                 ctx.dependencyResults.releaseConsumer(jobId);
-                return { success: true, queueName: location.queueName };
+                return {
+                    success: true,
+                    queueName: location.queueName,
+                    released: waiting.dependsOn,
+                };
             }
-            return { success: false, queueName: location.queueName };
+            return { success: false, queueName: location.queueName, released: [] };
         });
         if (result.success) {
+            releaseDependencyCompletionPins(result.released, ctx);
             // Emit removed event (BullMQ v5)
             ctx.eventsManager.broadcast({
                 eventType: "removed" /* EventType.Removed */,

package/dist/application/operations/push.d.ts

@@ -9,6 +9,7 @@ import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { RWLock } from '../../shared/lock';
 import type { SetLike, MapLike } from '../../shared/lru';
 import type { DependencyResultTracker } from '../dependencyResultTracker';
+import type { DependencyCompletionTracker } from '../dependencyCompletions';
 /** Push operation context */
 export interface PushContext {
     storage: SqliteStorage | null;
@@ -19,7 +20,8 @@ export interface PushContext {
     completedJobs: SetLike<JobId>;
     completedJobsData: MapLike<JobId, Job>;
     /** Bare completion ids for removeOnComplete jobs so dependents start ready */
-    depCompletions?: SetLike<JobId>;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
     /** Timeout markers — cleared on custom-id reuse so a recycled id starts clean */
     timedOutJobs?: SetLike<JobId>;
     jobResults: MapLike<JobId, unknown>;

package/dist/application/operations/pushInsert.d.ts

@@ -4,9 +4,12 @@ import type { JobLocation } from '../../domain/types/queue';
 import type { SetLike } from '../../shared/lru';
 import type { MapLike } from '../../shared/lru';
 import type { DependencyResultTracker } from '../dependencyResultTracker';
+import { type DependencyCompletionTracker } from '../dependencyCompletions';
+import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 export interface PushInsertContext {
+    storage: SqliteStorage | null;
     completedJobs: SetLike<JobId>;
-    depCompletions?: SetLike<JobId>;
+    depCompletions?: DependencyCompletionTracker;
     jobResults: MapLike<JobId, unknown>;
     dependencyResults: DependencyResultTracker;
     jobIndex: Map<JobId, JobLocation>;

package/dist/application/operations/pushInsert.js

@@ -1,3 +1,4 @@
+import { pinReferencedCompletions, } from '../dependencyCompletions';
 /** Resolve the first externally visible state without mutating queue structures. */
 export function initialJobState(job, ctx, now = Date.now()) {
     const needsWaiting = job.dependsOn.length > 0 &&
@@ -14,6 +15,7 @@ export function insertJobToShard(job, target, ctx, recordTimeline = true) {
     const now = Date.now();
     const state = initialJobState(job, ctx, now);
     if (state === 'waiting-children') {
+        pinReferencedCompletions(job.dependsOn, ctx);
         shard.waitingDeps.set(job.id, job);
         shard.registerDependencies(job.id, job.dependsOn);
         if (recordTimeline)

package/dist/application/queueManager.d.ts

@@ -187,6 +187,8 @@ export declare class QueueManager {
     listQueues(): string[];
     private registerQueueName;
     private unregisterQueueName;
+    private releaseCompletionPins;
+    private reconcileCompletionPins;
     clean(queue: string, graceMs: number, state?: string, limit?: number): JobId[];
     getCountsPerPriority(queue: string): Record<number, number>;
     getJobs(queue: string, options?: {

package/dist/application/queueManager.js

@@ -37,6 +37,8 @@ import { processPendingDependencies } from './dependencyProcessor';
 import { handleTaskError, handleTaskSuccess } from './taskErrorTracking';
 import { DependencyResultTracker } from './dependencyResultTracker';
 import { recoverFlowFailures } from './flowFailureRecovery';
+import { assertFlowParentOwnership, backpatchDeclaredFlowChild, canAcceptRemovedFlowChild, flowChildFailureError, isDeclaredFlowChild, } from './flowParentBackpatch';
+import { commitRemovedCompletion, DependencyCompletionTracker, reconcileDependencyCompletionPins, releaseDependencyCompletionPins, } from './dependencyCompletions';
 /**
  * QueueManager - Central coordinator
  */
@@ -53,9 +55,8 @@ export class QueueManager {
     jobIndex = new Map();
     completedJobs;
     completedJobsData;
-    // Bare completion ids of removeOnComplete jobs — kept ONLY so dependent jobs
-    // can unblock (no payload, not surfaced in state/stats). Bounded like
-    // completedJobs; entries are pruned by the dependency processor once consumed.
+    // Bare removeOnComplete evidence: bounded recent IDs plus IDs pinned by live
+    // dependency edges. It is never surfaced as completed job data or statistics.
     depCompletions;
     // Ids of jobs failed by the timeout sweep. A late ACK whose lock token no
     // longer matches (the job was requeued for retry) is discarded for these,
@@ -128,7 +129,9 @@ export class QueueManager {
             this.jobIndex.delete(jobId);
             this.completedJobsData.delete(jobId);
         });
-        this.depCompletions = new BoundedSet(this.config.maxCompletedJobs);
+        this.depCompletions = new DependencyCompletionTracker(this.config.maxCompletedJobs, (jobId) => {
+            this.storage?.deleteDependencyCompletion(jobId);
+        });
         this.timedOutJobs = new BoundedSet(this.config.maxCompletedJobs);
         this.perQueueMetrics = new LRUMap(this.config.maxCustomIds);
         this.jobResults = new LRUMap(this.config.maxJobResults);
@@ -171,6 +174,8 @@ export class QueueManager {
                 shards: this.shards,
                 jobIndex: this.jobIndex,
                 completedJobs: this.completedJobs,
+                depCompletions: this.depCompletions,
+                maxDependencyCompletions: this.config.maxCompletedJobs,
                 dependencyResults: this.dependencyResults,
                 failedChildrenValues: this.failedChildrenValues,
                 ignoredChildrenFailures: this.ignoredChildrenFailures,
@@ -564,8 +569,8 @@ export class QueueManager {
             ctx.storage?.markCompleted(jId, Date.now(), job.timeline);
         }
         else {
+            commitRemovedCompletion(job, ctx);
             ctx.jobIndex.delete(jId);
-            ctx.storage?.deleteJob(jId);
         }
         if (result !== undefined)
             ctx.dependencyResults.retain(jId, result);
@@ -686,94 +691,110 @@ export class QueueManager {
     async updateJobParent(childJobId, parentJobId) {
         if (childJobId === parentJobId)
             throw new Error('A flow job cannot be its own parent');
-        const childJob = await this.getJob(childJobId);
-        if (!childJob)
-            throw new Error(`Child job not found: ${String(childJobId)}`);
+        let childJob = await this.getJob(childJobId);
         const parentJob = await this.getJob(parentJobId);
+        if (!childJob) {
+            if (canAcceptRemovedFlowChild(parentJob, childJobId, this.depCompletions))
+                return;
+            throw new Error(`Child job not found: ${String(childJobId)}`);
+        }
         if (!parentJob)
             throw new Error(`Parent job not found: ${String(parentJobId)}`);
-        const priorParent = childJob.parentId;
-        if (priorParent && String(priorParent) !== 'pending' && priorParent !== parentJobId) {
-            throw new Error(`Child job ${String(childJobId)} already belongs to parent ${String(priorParent)}`);
-        }
-        const parentLocation = this.jobIndex.get(parentJobId);
-        if (parentLocation?.type !== 'queue') {
-            throw new Error(`Parent job ${String(parentJobId)} is not linkable`);
+        assertFlowParentOwnership(childJob, parentJobId);
+        if (isDeclaredFlowChild(parentJob, childJobId)) {
+            childJob = await backpatchDeclaredFlowChild(childJob, parentJob, {
+                storage: this.storage,
+                customIdLock: this.customIdLock,
+                shards: this.shards,
+                shardLocks: this.shardLocks,
+                processingShards: this.processingShards,
+                processingLocks: this.processingLocks,
+                jobIndex: this.jobIndex,
+                completedJobsData: this.completedJobsData,
+                depCompletions: this.depCompletions,
+            });
         }
-        const childLocation = this.jobIndex.get(childJobId);
-        const shardIndexes = [
-            ...new Set([shardIndex(childJob.queue), shardIndex(parentJob.queue)]),
-        ].sort((a, b) => a - b);
-        const processingIndexes = childLocation?.type === 'processing' ? [processingShardIndex(childJobId)] : [];
-        const guards = [await this.customIdLock.acquireWrite()];
-        try {
-            for (const index of shardIndexes)
-                guards.push(await this.shardLocks[index].acquireWrite());
-            for (const index of processingIndexes) {
-                guards.push(await this.processingLocks[index].acquireWrite());
-            }
-            if (this.jobIndex.get(parentJobId)?.type !== 'queue') {
-                throw new Error(`Parent job ${String(parentJobId)} changed state while linking`);
+        else {
+            const parentLocation = this.jobIndex.get(parentJobId);
+            if (parentLocation?.type !== 'queue') {
+                throw new Error(`Parent job ${String(parentJobId)} is not linkable`);
             }
-            const childData = {
-                ...childJob.data,
-                __parentId: String(parentJobId),
-                __parentQueue: parentJob.queue,
-            };
-            const childrenIds = parentJob.childrenIds.includes(childJobId)
-                ? [...parentJob.childrenIds]
-                : [...parentJob.childrenIds, childJobId];
-            const dependsOn = parentJob.dependsOn.includes(childJobId)
-                ? [...parentJob.dependsOn]
-                : [...parentJob.dependsOn, childJobId];
-            const parentData = {
-                ...parentJob.data,
-                __childrenIds: childrenIds.map(String),
-            };
-            const linkedChild = { ...childJob, data: childData, parentId: parentJobId };
-            const linkedParent = { ...parentJob, data: parentData, childrenIds, dependsOn };
-            const childFinished = this.completedJobs.has(childJobId) || this.depCompletions.has(childJobId);
-            const parentState = childFinished
-                ? parentJob.runAt > Date.now()
-                    ? 'delayed'
-                    : parentJob.priority > 0
-                        ? 'prioritized'
-                        : 'waiting'
-                : 'waiting-children';
-            this.storage?.updateFlowLink(linkedChild, linkedParent, parentState);
-            childJob.parentId = parentJobId;
-            childJob.data = childData;
-            parentJob.childrenIds = childrenIds;
-            parentJob.dependsOn = dependsOn;
-            parentJob.data = parentData;
-            if (!childFinished) {
-                const shard = this.shards[shardIndex(parentJob.queue)];
-                if (!shard.waitingDeps.has(parentJobId)) {
-                    const removed = shard.getQueue(parentJob.queue).remove(parentJobId);
-                    if (removed)
-                        shard.decrementQueued(parentJobId);
-                    shard.waitingDeps.set(parentJobId, parentJob);
+            const childLocation = this.jobIndex.get(childJobId);
+            const shardIndexes = [
+                ...new Set([shardIndex(childJob.queue), shardIndex(parentJob.queue)]),
+            ].sort((a, b) => a - b);
+            const processingIndexes = childLocation?.type === 'processing' ? [processingShardIndex(childJobId)] : [];
+            const guards = [await this.customIdLock.acquireWrite()];
+            try {
+                for (const index of shardIndexes)
+                    guards.push(await this.shardLocks[index].acquireWrite());
+                for (const index of processingIndexes) {
+                    guards.push(await this.processingLocks[index].acquireWrite());
+                }
+                if (this.jobIndex.get(parentJobId)?.type !== 'queue') {
+                    throw new Error(`Parent job ${String(parentJobId)} changed state while linking`);
+                }
+                const childData = {
+                    ...childJob.data,
+                    __parentId: String(parentJobId),
+                    __parentQueue: parentJob.queue,
+                };
+                const childrenIds = [...parentJob.childrenIds, childJobId];
+                const dependsOn = parentJob.dependsOn.includes(childJobId)
+                    ? [...parentJob.dependsOn]
+                    : [...parentJob.dependsOn, childJobId];
+                const parentData = {
+                    ...parentJob.data,
+                    __childrenIds: childrenIds.map(String),
+                };
+                const linkedChild = { ...childJob, data: childData, parentId: parentJobId };
+                const linkedParent = { ...parentJob, data: parentData, childrenIds, dependsOn };
+                const childFinished = this.completedJobs.has(childJobId) || this.depCompletions.has(childJobId);
+                const parentState = childFinished
+                    ? parentJob.runAt > Date.now()
+                        ? 'delayed'
+                        : parentJob.priority > 0
+                            ? 'prioritized'
+                            : 'waiting'
+                    : 'waiting-children';
+                this.storage?.updateFlowLink(linkedChild, linkedParent, parentState);
+                childJob.parentId = parentJobId;
+                childJob.data = childData;
+                parentJob.childrenIds = childrenIds;
+                parentJob.dependsOn = dependsOn;
+                parentJob.data = parentData;
+                if (!childFinished) {
+                    const shard = this.shards[shardIndex(parentJob.queue)];
+                    if (!shard.waitingDeps.has(parentJobId)) {
+                        const removed = shard.getQueue(parentJob.queue).remove(parentJobId);
+                        if (removed)
+                            shard.decrementQueued(parentJobId);
+                        shard.waitingDeps.set(parentJobId, parentJob);
+                    }
+                    shard.registerDependencies(parentJobId, [childJobId]);
+                    this.dependencyResults.registerConsumer(parentJobId, dependsOn);
                 }
-                shard.registerDependencies(parentJobId, [childJobId]);
-                this.dependencyResults.registerConsumer(parentJobId, dependsOn);
             }
-        }
-        finally {
-            for (let index = guards.length - 1; index >= 0; index--)
-                guards[index].release();
+            finally {
+                for (let index = guards.length - 1; index >= 0; index--)
+                    guards[index].release();
+            }
         }
         // Handle race condition: child may have already terminally failed
         // before parent linkage was established (parentId was 'pending').
         // If so, propagate failParentOnFailure now with the real parent ID.
         const childLoc = this.jobIndex.get(childJobId);
+        const childFailureError = childLoc?.type === 'dlq'
+            ? (flowChildFailureError(childJob, this.shards) ?? 'Child job failed')
+            : 'Child job failed';
         if (childLoc?.type === 'dlq' && childJob.failParentOnFailure) {
-            await this.moveParentToFailed(parentJobId, childJob, 'Child job failed');
+            await this.moveParentToFailed(parentJobId, childJob, childFailureError);
         }
         if (childLoc?.type === 'dlq' &&
             (childJob.removeDependencyOnFailure ||
                 childJob.ignoreDependencyOnFailure ||
                 childJob.continueParentOnFailure)) {
-            await this.onChildDependencyOption(childJob, 'Child job failed');
+            await this.onChildDependencyOption(childJob, childFailureError);
         }
     }
     getJobByCustomId(customId) {
@@ -869,6 +890,12 @@ export class QueueManager {
         }
         for (const cid of customIdsToDelete)
             this.customIdMap.delete(cid);
+        // removeOnComplete jobs have no jobIndex entry, but their bounded durable
+        // dependency proofs still belong to the obliterated queue.
+        const removedCompletions = this.storage?.deleteDependencyCompletionsForQueue(queue) ?? [];
+        for (const jobId of removedCompletions)
+            this.depCompletions.delete(jobId);
+        this.reconcileCompletionPins();
         // Per-queue cumulative counters are keyed by queue name and never expire on
         // their own; obliterate is the documented way to reclaim ALL state for a
         // queue, so drop its metrics entry too (prevents unbounded growth for
@@ -900,6 +927,22 @@ export class QueueManager {
     unregisterQueueName(queue) {
         this.queueNamesCache.delete(queue);
     }
+    releaseCompletionPins(dependencyIds) {
+        releaseDependencyCompletionPins(dependencyIds, {
+            storage: this.storage,
+            shards: this.shards,
+            depCompletions: this.depCompletions,
+            maxDependencyCompletions: this.config.maxCompletedJobs,
+        });
+    }
+    reconcileCompletionPins() {
+        reconcileDependencyCompletionPins({
+            storage: this.storage,
+            shards: this.shards,
+            depCompletions: this.depCompletions,
+            maxDependencyCompletions: this.config.maxCompletedJobs,
+        });
+    }
     clean(queue, graceMs, state, limit) {
         return queueControl.cleanQueue(queue, graceMs, this.contextFactory.getQueueControlContext(), state, limit);
     }
@@ -1337,6 +1380,7 @@ export class QueueManager {
         if (parentLoc.type !== 'queue')
             return;
         const idx = shardIndex(parentJob.queue);
+        let releasedDependencies = [];
         await withWriteLock(this.shardLocks[idx], () => {
             // Re-check inside lock to prevent duplicate DLQ entries (TOCTOU guard)
             if (this.jobIndex.get(parentId)?.type !== 'queue')
@@ -1344,6 +1388,7 @@ export class QueueManager {
             const shard = this.shards[idx];
             // Remove from waitingDeps if present
             if (shard.waitingDeps.has(parentId)) {
+                releasedDependencies = [...parentJob.dependsOn];
                 shard.waitingDeps.delete(parentId);
                 shard.unregisterDependencies(parentId, parentJob.dependsOn);
             }
@@ -1365,6 +1410,7 @@ export class QueueManager {
             this.storage?.deleteJob(parentId);
             this.storage?.deleteFlowFailure(parentId, childJob.id);
         });
+        this.releaseCompletionPins(releasedDependencies);
         // Parent reached a terminal (DLQ) state — release its flow-failure tracking.
         this.failedChildrenValues.delete(parentId);
         this.ignoredChildrenFailures.delete(parentId);
@@ -1419,11 +1465,13 @@ export class QueueManager {
         existing[childKey] = error ?? 'unknown error';
         this.failedChildrenValues.set(parentId, existing);
         const idx = shardIndex(parentJob.queue);
+        let releasedDependencies = [];
         await withWriteLock(this.shardLocks[idx], () => {
             if (this.jobIndex.get(parentId)?.type !== 'queue')
                 return;
             const shard = this.shards[idx];
             const dependencies = [...parentJob.dependsOn];
+            releasedDependencies = dependencies;
             shard.unregisterDependencies(parentId, dependencies);
             for (const dependency of dependencies) {
                 this.dependencyResults.releaseDependency(parentId, dependency);
@@ -1431,6 +1479,7 @@ export class QueueManager {
             parentJob.dependsOn = [];
             this.storage?.updateFlowParentResolution(parentJob);
         });
+        this.releaseCompletionPins(releasedDependencies);
         await this.promoteParentAfterChildFailure(parentId, parentJob, idx);
     }
     /**
@@ -1445,6 +1494,7 @@ export class QueueManager {
             timer.unref?.();
         });
         let promoted = false;
+        let releasedDependencies = [];
         await withWriteLock(this.shardLocks[idx], () => {
             // TOCTOU guard
             if (this.jobIndex.get(parentId)?.type !== 'queue')
@@ -1452,6 +1502,7 @@ export class QueueManager {
             const shard = this.shards[idx];
             // Remove from waitingDeps
             if (shard.waitingDeps.has(parentId)) {
+                releasedDependencies = [...parentJob.dependsOn];
                 shard.waitingDeps.delete(parentId);
                 shard.unregisterDependencies(parentId, parentJob.dependsOn);
             }
@@ -1472,6 +1523,7 @@ export class QueueManager {
                 promoted = true;
             }
         });
+        this.releaseCompletionPins(releasedDependencies);
         if (promoted) {
             this.eventsManager.broadcast({
                 eventType: 'waiting',
@@ -1507,6 +1559,7 @@ export class QueueManager {
         // Remove the failed child from the parent's pending deps synchronously so
         // dependency tracking stays consistent; defer only the promotion decision.
         let readyToPromote = false;
+        let releasedDependency = null;
         await withWriteLock(this.shardLocks[idx], () => {
             if (this.jobIndex.get(parentId)?.type !== 'queue')
                 return;
@@ -1519,6 +1572,7 @@ export class QueueManager {
             if (depIndex !== -1) {
                 parentJob.dependsOn.splice(depIndex, 1);
                 shard.unregisterDependencies(parentId, [childJob.id]);
+                releasedDependency = childJob.id;
                 this.dependencyResults.releaseDependency(parentId, childJob.id);
                 this.storage?.updateFlowParentResolution(parentJob);
             }
@@ -1527,6 +1581,8 @@ export class QueueManager {
                 parentJob.dependsOn.length === 0 ||
                     parentJob.dependsOn.every((dep) => this.completedJobs.has(dep));
         });
+        if (releasedDependency)
+            this.releaseCompletionPins([releasedDependency]);
         if (readyToPromote) {
             await this.promoteParentAfterChildFailure(parentId, parentJob, idx);
         }
@@ -1572,6 +1628,7 @@ export class QueueManager {
         const guards = [];
         let removed = false;
         let promoted = false;
+        let releasedDependencies = [];
         try {
             for (const index of shardIndexes)
                 guards.push(await this.shardLocks[index].acquireWrite());
@@ -1590,6 +1647,7 @@ export class QueueManager {
                 !this.completedJobs.has(dependency) &&
                 !this.depCompletions.has(dependency));
             const released = parentJob.dependsOn.filter((dependency) => !unresolved.includes(dependency));
+            releasedDependencies = released;
             const childrenIds = parentJob.childrenIds.filter((childId) => childId !== childJobId);
             const childData = { ...childJob.data };
             delete childData.__parentId;
@@ -1642,6 +1700,7 @@ export class QueueManager {
             for (let index = guards.length - 1; index >= 0; index--)
                 guards[index].release();
         }
+        this.releaseCompletionPins(releasedDependencies);
         if (promoted) {
             this.eventsManager.broadcast({
                 eventType: 'waiting',