@push.rocks/taskbuffer 5.0.0 → 6.0.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/taskbuffer',
-    version: '5.0.0',
+    version: '6.0.0',
     description: 'A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDhJQUE4STtDQUM1SixDQUFBIn0=

package/dist_ts/index.d.ts

@@ -8,6 +8,6 @@ export { TaskDebounced } from './taskbuffer.classes.taskdebounced.js';
 export { TaskConstraintGroup } from './taskbuffer.classes.taskconstraintgroup.js';
 export { TaskStep } from './taskbuffer.classes.taskstep.js';
 export type { ITaskStep } from './taskbuffer.classes.taskstep.js';
-export type { ITaskMetadata, ITaskExecutionReport, IScheduledTaskInfo, ITaskEvent, TTaskEventType, ITaskConstraintGroupOptions } from './taskbuffer.interfaces.js';
+export type { ITaskMetadata, ITaskExecutionReport, IScheduledTaskInfo, ITaskEvent, TTaskEventType, ITaskConstraintGroupOptions, ITaskExecution } from './taskbuffer.interfaces.js';
 import * as distributedCoordination from './taskbuffer.classes.distributedcoordinator.js';
 export { distributedCoordination };

package/dist_ts/taskbuffer.classes.taskconstraintgroup.d.ts

@@ -4,11 +4,13 @@ export declare class TaskConstraintGroup<TData extends Record<string, unknown> =
     name: string;
     maxConcurrent: number;
     cooldownMs: number;
-    private constraintKeyForTask;
+    private constraintKeyForExecution;
+    private shouldExecuteFn?;
     private runningCounts;
     private lastCompletionTimes;
     constructor(options: ITaskConstraintGroupOptions<TData>);
-    getConstraintKey(task: Task<any, any, TData>): string | null;
+    getConstraintKey(task: Task<any, any, TData>, input?: any): string | null;
+    checkShouldExecute(task: Task<any, any, TData>, input?: any): Promise<boolean>;
     canRun(subGroupKey: string): boolean;
     acquireSlot(subGroupKey: string): void;
     releaseSlot(subGroupKey: string): void;

package/dist_ts/taskbuffer.classes.taskconstraintgroup.js

@@ -3,14 +3,21 @@ export class TaskConstraintGroup {
         this.runningCounts = new Map();
         this.lastCompletionTimes = new Map();
         this.name = options.name;
-        this.constraintKeyForTask = options.constraintKeyForTask;
+        this.constraintKeyForExecution = options.constraintKeyForExecution;
         this.maxConcurrent = options.maxConcurrent ?? Infinity;
         this.cooldownMs = options.cooldownMs ?? 0;
+        this.shouldExecuteFn = options.shouldExecute;
     }
-    getConstraintKey(task) {
-        const key = this.constraintKeyForTask(task);
+    getConstraintKey(task, input) {
+        const key = this.constraintKeyForExecution(task, input);
         return key ?? null;
     }
+    async checkShouldExecute(task, input) {
+        if (!this.shouldExecuteFn) {
+            return true;
+        }
+        return this.shouldExecuteFn(task, input);
+    }
     canRun(subGroupKey) {
         const running = this.runningCounts.get(subGroupKey) ?? 0;
         if (running >= this.maxConcurrent) {
@@ -61,4 +68,4 @@ export class TaskConstraintGroup {
         this.lastCompletionTimes.clear();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/taskbuffer.classes.taskmanager.d.ts

@@ -29,6 +29,7 @@ export declare class TaskManager {
     addConstraintGroup(group: TaskConstraintGroup<any>): void;
     removeConstraintGroup(name: string): void;
     triggerTaskConstrained(task: Task<any, any, any>, input?: any): Promise<any>;
+    private checkAllShouldExecute;
     private executeWithConstraintTracking;
     private drainConstraintQueue;
     triggerTaskByName(taskName: string): Promise<any>;

package/dist_ts/taskbuffer.classes.taskmanager.js

@@ -56,13 +56,17 @@ export class TaskManager {
         // Gather applicable constraints
         const applicableGroups = [];
         for (const group of this.constraintGroups) {
-            const key = group.getConstraintKey(task);
+            const key = group.getConstraintKey(task, input);
             if (key !== null) {
                 applicableGroups.push({ group, key });
             }
         }
-        // No constraints apply → trigger directly
+        // No constraints apply → check shouldExecute then trigger directly
         if (applicableGroups.length === 0) {
+            const shouldRun = await this.checkAllShouldExecute(task, input);
+            if (!shouldRun) {
+                return undefined;
+            }
             return task.trigger(input);
         }
         // Check if all constraints allow running
@@ -70,16 +74,39 @@ export class TaskManager {
         if (allCanRun) {
             return this.executeWithConstraintTracking(task, input, applicableGroups);
         }
-        // Blocked → enqueue with deferred promise
+        // Blocked → enqueue with deferred promise and cached constraint keys
         const deferred = plugins.smartpromise.defer();
-        this.constraintQueue.push({ task, input, deferred });
+        const constraintKeys = new Map();
+        for (const { group, key } of applicableGroups) {
+            constraintKeys.set(group.name, key);
+        }
+        this.constraintQueue.push({ task, input, deferred, constraintKeys });
         return deferred.promise;
     }
+    async checkAllShouldExecute(task, input) {
+        for (const group of this.constraintGroups) {
+            const shouldRun = await group.checkShouldExecute(task, input);
+            if (!shouldRun) {
+                return false;
+            }
+        }
+        return true;
+    }
     async executeWithConstraintTracking(task, input, groups) {
-        // Acquire slots
+        // Acquire slots synchronously to prevent race conditions
         for (const { group, key } of groups) {
             group.acquireSlot(key);
         }
+        // Check shouldExecute after acquiring slots
+        const shouldRun = await this.checkAllShouldExecute(task, input);
+        if (!shouldRun) {
+            // Release slots and drain queue
+            for (const { group, key } of groups) {
+                group.releaseSlot(key);
+            }
+            this.drainConstraintQueue();
+            return undefined;
+        }
         try {
             return await task.trigger(input);
         }
@@ -97,18 +124,25 @@ export class TaskManager {
         for (const entry of this.constraintQueue) {
             const applicableGroups = [];
             for (const group of this.constraintGroups) {
-                const key = group.getConstraintKey(entry.task);
+                const key = group.getConstraintKey(entry.task, entry.input);
                 if (key !== null) {
                     applicableGroups.push({ group, key });
                 }
             }
-            // No constraints apply anymore (group removed?) → run directly
+            // No constraints apply anymore (group removed?) → check shouldExecute then run
             if (applicableGroups.length === 0) {
-                entry.task.trigger(entry.input).then((result) => entry.deferred.resolve(result), (err) => entry.deferred.reject(err));
+                this.checkAllShouldExecute(entry.task, entry.input).then((shouldRun) => {
+                    if (!shouldRun) {
+                        entry.deferred.resolve(undefined);
+                        return;
+                    }
+                    entry.task.trigger(entry.input).then((result) => entry.deferred.resolve(result), (err) => entry.deferred.reject(err));
+                });
                 continue;
             }
             const allCanRun = applicableGroups.every(({ group, key }) => group.canRun(key));
             if (allCanRun) {
+                // executeWithConstraintTracking handles shouldExecute check internally
                 this.executeWithConstraintTracking(entry.task, entry.input, applicableGroups).then((result) => entry.deferred.resolve(result), (err) => entry.deferred.reject(err));
             }
             else {
@@ -334,4 +368,4 @@ export class TaskManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taskbuffer.classes.taskmanager.js","sourceRoot":"","sources":["../ts/taskbuffer.classes.taskmanager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taskbuffer.classes.taskmanager.js","sourceRoot":"","sources":["../ts/taskbuffer.classes.taskmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/taskbuffer.interfaces.d.ts

@@ -2,14 +2,20 @@ import type { ITaskStep } from './taskbuffer.classes.taskstep.js';
 import type { Task } from './taskbuffer.classes.task.js';
 export interface ITaskConstraintGroupOptions<TData extends Record<string, unknown> = Record<string, unknown>> {
     name: string;
-    constraintKeyForTask: (task: Task<any, any, TData>) => string | null | undefined;
+    constraintKeyForExecution: (task: Task<any, any, TData>, input?: any) => string | null | undefined;
     maxConcurrent?: number;
     cooldownMs?: number;
+    shouldExecute?: (task: Task<any, any, TData>, input?: any) => boolean | Promise<boolean>;
+}
+export interface ITaskExecution<TData extends Record<string, unknown> = Record<string, unknown>> {
+    task: Task<any, any, TData>;
+    input: any;
 }
 export interface IConstrainedTaskEntry {
     task: Task<any, any, any>;
     input: any;
     deferred: import('@push.rocks/smartpromise').Deferred<any>;
+    constraintKeys: Map<string, string>;
 }
 export interface ITaskMetadata {
     name: string;

package/dist_ts_web/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/taskbuffer',
-    version: '5.0.0',
+    version: '6.0.0',
     description: 'A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsd0JBQXdCO0lBQzlCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSw4SUFBOEk7Q0FDNUosQ0FBQSJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/taskbuffer",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "private": false,
   "description": "A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.",
   "main": "dist_ts/index.js",

package/readme.hints.md

@@ -12,11 +12,13 @@
 - Typed data bag accessible as `task.data`
 
 ### TaskConstraintGroup
-- `new TaskConstraintGroup<TData>({ name, constraintKeyForTask, maxConcurrent?, cooldownMs? })`
-- `constraintKeyForTask(task)` returns a string key (constraint applies) or `null` (skip)
+- `new TaskConstraintGroup<TData>({ name, constraintKeyForExecution, maxConcurrent?, cooldownMs?, shouldExecute? })`
+- `constraintKeyForExecution(task, input?)` returns a string key (constraint applies) or `null` (skip). Receives both task and runtime input.
+- `shouldExecute(task, input?)` — optional pre-execution check. Returns `false` to skip (deferred resolves `undefined`). Can be async.
 - `maxConcurrent` (default: `Infinity`) — max concurrent tasks per key
 - `cooldownMs` (default: `0`) — minimum ms gap between completions per key
-- Methods: `canRun(key)`, `acquireSlot(key)`, `releaseSlot(key)`, `getCooldownRemaining(key)`, `getRunningCount(key)`, `reset()`
+- Methods: `getConstraintKey(task, input?)`, `checkShouldExecute(task, input?)`, `canRun(key)`, `acquireSlot(key)`, `releaseSlot(key)`, `getCooldownRemaining(key)`, `getRunningCount(key)`, `reset()`
+- `ITaskExecution<TData>` type exported from index — `{ task, input }` tuple
 
 ### TaskManager Constraint Integration
 - `manager.addConstraintGroup(group)` / `manager.removeConstraintGroup(name)`

package/readme.md

@@ -120,7 +120,7 @@ const manager = new TaskManager();
 const domainMutex = new TaskConstraintGroup<{ domain: string }>({
   name: 'domain-mutex',
   maxConcurrent: 1,
-  constraintKeyForTask: (task) => task.data.domain,
+  constraintKeyForExecution: (task, input?) => task.data.domain,
 });
 
 manager.addConstraintGroup(domainMutex);
@@ -156,7 +156,7 @@ Cap how many tasks can run concurrently across a group:
 const dnsLimit = new TaskConstraintGroup<{ group: string }>({
   name: 'dns-concurrency',
   maxConcurrent: 3,
-  constraintKeyForTask: (task) =>
+  constraintKeyForExecution: (task) =>
     task.data.group === 'dns' ? 'dns' : null, // null = skip constraint
 });
 
@@ -173,7 +173,7 @@ const rateLimiter = new TaskConstraintGroup<{ domain: string }>({
   name: 'api-rate-limit',
   maxConcurrent: 1,
   cooldownMs: 11000,
-  constraintKeyForTask: (task) => task.data.domain,
+  constraintKeyForExecution: (task) => task.data.domain,
 });
 
 manager.addConstraintGroup(rateLimiter);
@@ -187,7 +187,7 @@ Limit total concurrent tasks system-wide:
 const globalCap = new TaskConstraintGroup({
   name: 'global-cap',
   maxConcurrent: 10,
-  constraintKeyForTask: () => 'all', // same key = shared limit
+  constraintKeyForExecution: () => 'all', // same key = shared limit
 });
 
 manager.addConstraintGroup(globalCap);
@@ -208,26 +208,119 @@ await manager.triggerTask(dnsTask);
 
 ### Selective Constraints
 
-Return `null` from `constraintKeyForTask` to exempt a task from a constraint group:
+Return `null` from `constraintKeyForExecution` to exempt a task from a constraint group:
 
 ```typescript
 const constraint = new TaskConstraintGroup<{ priority: string }>({
   name: 'low-priority-limit',
   maxConcurrent: 2,
-  constraintKeyForTask: (task) =>
+  constraintKeyForExecution: (task) =>
     task.data.priority === 'low' ? 'low-priority' : null, // high priority tasks skip this constraint
 });
 ```
 
+### Input-Aware Constraints 🎯
+
+The `constraintKeyForExecution` function receives both the **task** and the **runtime input** passed to `trigger(input)`. This means the same task triggered with different inputs can be constrained independently:
+
+```typescript
+const extractTLD = (domain: string) => {
+  const parts = domain.split('.');
+  return parts.slice(-2).join('.');
+};
+
+// Same TLD → serialized. Different TLDs → parallel.
+const tldMutex = new TaskConstraintGroup({
+  name: 'tld-mutex',
+  maxConcurrent: 1,
+  constraintKeyForExecution: (task, input?: string) => {
+    if (!input) return null;
+    return extractTLD(input); // "example.com", "other.org", etc.
+  },
+});
+
+manager.addConstraintGroup(tldMutex);
+
+// These two serialize (same TLD "example.com")
+const p1 = manager.triggerTaskConstrained(getCert, 'app.example.com');
+const p2 = manager.triggerTaskConstrained(getCert, 'api.example.com');
+
+// This runs in parallel (different TLD "other.org")
+const p3 = manager.triggerTaskConstrained(getCert, 'my.other.org');
+```
+
+You can also combine `task.data` and `input` for composite keys:
+
+```typescript
+const providerDomain = new TaskConstraintGroup<{ provider: string }>({
+  name: 'provider-domain',
+  maxConcurrent: 1,
+  constraintKeyForExecution: (task, input?: string) => {
+    return `${task.data.provider}:${input || 'default'}`;
+  },
+});
+```
+
+### Pre-Execution Check with `shouldExecute` ✅
+
+The `shouldExecute` callback runs right before a queued task executes. If it returns `false`, the task is skipped and its promise resolves with `undefined`. This is perfect for scenarios where a prior execution's outcome makes subsequent queued tasks unnecessary:
+
+```typescript
+const certCache = new Map<string, string>();
+
+const certConstraint = new TaskConstraintGroup({
+  name: 'cert-mutex',
+  maxConcurrent: 1,
+  constraintKeyForExecution: (task, input?: string) => {
+    if (!input) return null;
+    return extractTLD(input);
+  },
+  shouldExecute: (task, input?: string) => {
+    if (!input) return true;
+    // Skip if a wildcard cert already covers this TLD
+    return certCache.get(extractTLD(input)) !== 'wildcard';
+  },
+});
+
+const getCert = new Task({
+  name: 'get-certificate',
+  taskFunction: async (domain: string) => {
+    const cert = await acme.getCert(domain);
+    if (cert.isWildcard) certCache.set(extractTLD(domain), 'wildcard');
+    return cert;
+  },
+});
+
+manager.addConstraintGroup(certConstraint);
+manager.addTask(getCert);
+
+const r1 = manager.triggerTaskConstrained(getCert, 'app.example.com'); // runs, gets wildcard
+const r2 = manager.triggerTaskConstrained(getCert, 'api.example.com'); // queued → skipped!
+const r3 = manager.triggerTaskConstrained(getCert, 'my.other.org');    // parallel (different TLD)
+
+const [cert1, cert2, cert3] = await Promise.all([r1, r2, r3]);
+// cert2 === undefined (skipped because wildcard already covers example.com)
+```
+
+**`shouldExecute` semantics:**
+
+- Runs right before execution (after slot acquisition, before `trigger()`)
+- Also checked on immediate (non-queued) triggers
+- Returns `false` → skip execution, deferred resolves with `undefined`
+- Can be async (return `Promise<boolean>`)
+- Has closure access to external state modified by prior executions
+- If multiple constraint groups have `shouldExecute`, **all** must return `true`
+
 ### How It Works
 
 When you trigger a task through `TaskManager` (via `triggerTask`, `triggerTaskByName`, `addExecuteRemoveTask`, or cron), the manager:
 
-1. Evaluates all registered constraint groups against the task
-2. If no constraints apply (all matchers return `null`) → runs immediately
-3. If all applicable constraints have capacity → acquires slots and runs
+1. Evaluates all registered constraint groups against the task and input
+2. If no constraints apply (all matchers return `null`) → checks `shouldExecute` → runs or skips
+3. If all applicable constraints have capacity → acquires slots → checks `shouldExecute` → runs or skips
 4. If any constraint blocks → enqueues the task; when a running task completes, the queue is drained
 5. Cooldown-blocked tasks auto-retry after the shortest remaining cooldown expires
+6. Queued tasks re-check `shouldExecute` when their turn comes — stale work is automatically pruned
 
 ## 🎯 Core Concepts
 
@@ -732,7 +825,7 @@ const manager = new TaskManager();
 const tenantLimit = new TaskConstraintGroup<{ tenantId: string }>({
   name: 'tenant-concurrency',
   maxConcurrent: 2,
-  constraintKeyForTask: (task) => task.data.tenantId,
+  constraintKeyForExecution: (task, input?) => task.data.tenantId,
 });
 manager.addConstraintGroup(tenantLimit);
 
@@ -829,15 +922,17 @@ const acmeTasks = manager.getTasksMetadataByLabel('tenantId', 'acme');
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
 | `name` | `string` | *required* | Constraint group identifier |
-| `constraintKeyForTask` | `(task) => string \| null` | *required* | Returns key for grouping, or `null` to skip |
+| `constraintKeyForExecution` | `(task, input?) => string \| null` | *required* | Returns key for grouping, or `null` to skip. Receives both the task and runtime input. |
 | `maxConcurrent` | `number` | `Infinity` | Max concurrent tasks per key |
 | `cooldownMs` | `number` | `0` | Minimum ms between completions per key |
+| `shouldExecute` | `(task, input?) => boolean \| Promise<boolean>` | — | Pre-execution check. Return `false` to skip; deferred resolves `undefined`. |
 
 ### TaskConstraintGroup Methods
 
 | Method | Returns | Description |
 | --- | --- | --- |
-| `getConstraintKey(task)` | `string \| null` | Get the constraint key for a task |
+| `getConstraintKey(task, input?)` | `string \| null` | Get the constraint key for a task + input |
+| `checkShouldExecute(task, input?)` | `Promise<boolean>` | Run the `shouldExecute` callback (defaults to `true`) |
 | `canRun(key)` | `boolean` | Check if a slot is available |
 | `acquireSlot(key)` | `void` | Claim a running slot |
 | `releaseSlot(key)` | `void` | Release a slot and record completion time |
@@ -884,6 +979,7 @@ const acmeTasks = manager.getTasksMetadataByLabel('tenantId', 'acme');
 import type {
   ITaskMetadata,
   ITaskExecutionReport,
+  ITaskExecution,
   IScheduledTaskInfo,
   ITaskEvent,
   TTaskEventType,

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/taskbuffer',
-  version: '5.0.0',
+  version: '6.0.0',
   description: 'A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.'
 }

package/ts/index.ts

@@ -12,7 +12,7 @@ export { TaskStep } from './taskbuffer.classes.taskstep.js';
 export type { ITaskStep } from './taskbuffer.classes.taskstep.js';
 
 // Metadata interfaces
-export type { ITaskMetadata, ITaskExecutionReport, IScheduledTaskInfo, ITaskEvent, TTaskEventType, ITaskConstraintGroupOptions } from './taskbuffer.interfaces.js';
+export type { ITaskMetadata, ITaskExecutionReport, IScheduledTaskInfo, ITaskEvent, TTaskEventType, ITaskConstraintGroupOptions, ITaskExecution } from './taskbuffer.interfaces.js';
 
 import * as distributedCoordination from './taskbuffer.classes.distributedcoordinator.js';
 export { distributedCoordination };

package/ts/taskbuffer.classes.taskconstraintgroup.ts

@@ -5,23 +5,32 @@ export class TaskConstraintGroup<TData extends Record<string, unknown> = Record<
   public name: string;
   public maxConcurrent: number;
   public cooldownMs: number;
-  private constraintKeyForTask: (task: Task<any, any, TData>) => string | null | undefined;
+  private constraintKeyForExecution: (task: Task<any, any, TData>, input?: any) => string | null | undefined;
+  private shouldExecuteFn?: (task: Task<any, any, TData>, input?: any) => boolean | Promise<boolean>;
 
   private runningCounts = new Map<string, number>();
   private lastCompletionTimes = new Map<string, number>();
 
   constructor(options: ITaskConstraintGroupOptions<TData>) {
     this.name = options.name;
-    this.constraintKeyForTask = options.constraintKeyForTask;
+    this.constraintKeyForExecution = options.constraintKeyForExecution;
     this.maxConcurrent = options.maxConcurrent ?? Infinity;
     this.cooldownMs = options.cooldownMs ?? 0;
+    this.shouldExecuteFn = options.shouldExecute;
   }
 
-  public getConstraintKey(task: Task<any, any, TData>): string | null {
-    const key = this.constraintKeyForTask(task);
+  public getConstraintKey(task: Task<any, any, TData>, input?: any): string | null {
+    const key = this.constraintKeyForExecution(task, input);
     return key ?? null;
   }
 
+  public async checkShouldExecute(task: Task<any, any, TData>, input?: any): Promise<boolean> {
+    if (!this.shouldExecuteFn) {
+      return true;
+    }
+    return this.shouldExecuteFn(task, input);
+  }
+
   public canRun(subGroupKey: string): boolean {
     const running = this.runningCounts.get(subGroupKey) ?? 0;
     if (running >= this.maxConcurrent) {

package/ts/taskbuffer.classes.taskmanager.ts

@@ -80,14 +80,18 @@ export class TaskManager {
     // Gather applicable constraints
     const applicableGroups: Array<{ group: TaskConstraintGroup<any>; key: string }> = [];
     for (const group of this.constraintGroups) {
-      const key = group.getConstraintKey(task);
+      const key = group.getConstraintKey(task, input);
       if (key !== null) {
         applicableGroups.push({ group, key });
       }
     }
 
-    // No constraints apply → trigger directly
+    // No constraints apply → check shouldExecute then trigger directly
     if (applicableGroups.length === 0) {
+      const shouldRun = await this.checkAllShouldExecute(task, input);
+      if (!shouldRun) {
+        return undefined;
+      }
       return task.trigger(input);
     }
 
@@ -97,22 +101,47 @@ export class TaskManager {
       return this.executeWithConstraintTracking(task, input, applicableGroups);
     }
 
-    // Blocked → enqueue with deferred promise
+    // Blocked → enqueue with deferred promise and cached constraint keys
     const deferred = plugins.smartpromise.defer<any>();
-    this.constraintQueue.push({ task, input, deferred });
+    const constraintKeys = new Map<string, string>();
+    for (const { group, key } of applicableGroups) {
+      constraintKeys.set(group.name, key);
+    }
+    this.constraintQueue.push({ task, input, deferred, constraintKeys });
     return deferred.promise;
   }
 
+  private async checkAllShouldExecute(task: Task<any, any, any>, input?: any): Promise<boolean> {
+    for (const group of this.constraintGroups) {
+      const shouldRun = await group.checkShouldExecute(task, input);
+      if (!shouldRun) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   private async executeWithConstraintTracking(
     task: Task<any, any, any>,
     input: any,
     groups: Array<{ group: TaskConstraintGroup<any>; key: string }>,
   ): Promise<any> {
-    // Acquire slots
+    // Acquire slots synchronously to prevent race conditions
     for (const { group, key } of groups) {
       group.acquireSlot(key);
     }
 
+    // Check shouldExecute after acquiring slots
+    const shouldRun = await this.checkAllShouldExecute(task, input);
+    if (!shouldRun) {
+      // Release slots and drain queue
+      for (const { group, key } of groups) {
+        group.releaseSlot(key);
+      }
+      this.drainConstraintQueue();
+      return undefined;
+    }
+
     try {
       return await task.trigger(input);
     } finally {
@@ -131,23 +160,30 @@ export class TaskManager {
     for (const entry of this.constraintQueue) {
       const applicableGroups: Array<{ group: TaskConstraintGroup<any>; key: string }> = [];
       for (const group of this.constraintGroups) {
-        const key = group.getConstraintKey(entry.task);
+        const key = group.getConstraintKey(entry.task, entry.input);
         if (key !== null) {
           applicableGroups.push({ group, key });
         }
       }
 
-      // No constraints apply anymore (group removed?) → run directly
+      // No constraints apply anymore (group removed?) → check shouldExecute then run
       if (applicableGroups.length === 0) {
-        entry.task.trigger(entry.input).then(
-          (result) => entry.deferred.resolve(result),
-          (err) => entry.deferred.reject(err),
-        );
+        this.checkAllShouldExecute(entry.task, entry.input).then((shouldRun) => {
+          if (!shouldRun) {
+            entry.deferred.resolve(undefined);
+            return;
+          }
+          entry.task.trigger(entry.input).then(
+            (result) => entry.deferred.resolve(result),
+            (err) => entry.deferred.reject(err),
+          );
+        });
         continue;
       }
 
       const allCanRun = applicableGroups.every(({ group, key }) => group.canRun(key));
       if (allCanRun) {
+        // executeWithConstraintTracking handles shouldExecute check internally
         this.executeWithConstraintTracking(entry.task, entry.input, applicableGroups).then(
           (result) => entry.deferred.resolve(result),
           (err) => entry.deferred.reject(err),

package/ts/taskbuffer.interfaces.ts

@@ -3,15 +3,22 @@ import type { Task } from './taskbuffer.classes.task.js';
 
 export interface ITaskConstraintGroupOptions<TData extends Record<string, unknown> = Record<string, unknown>> {
   name: string;
-  constraintKeyForTask: (task: Task<any, any, TData>) => string | null | undefined;
+  constraintKeyForExecution: (task: Task<any, any, TData>, input?: any) => string | null | undefined;
   maxConcurrent?: number;  // default: Infinity
   cooldownMs?: number;     // default: 0
+  shouldExecute?: (task: Task<any, any, TData>, input?: any) => boolean | Promise<boolean>;
+}
+
+export interface ITaskExecution<TData extends Record<string, unknown> = Record<string, unknown>> {
+  task: Task<any, any, TData>;
+  input: any;
 }
 
 export interface IConstrainedTaskEntry {
   task: Task<any, any, any>;
   input: any;
   deferred: import('@push.rocks/smartpromise').Deferred<any>;
+  constraintKeys: Map<string, string>;  // groupName -> key
 }
 
 export interface ITaskMetadata {

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/taskbuffer',
-  version: '5.0.0',
+  version: '6.0.0',
   description: 'A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.'
 }