Moltaro.Package.NET.Tasks

Tasks commands for Package and Net Operation Project functions. The host captures the execution identity; every method invokes the ordinary transactional Tasks runtime. Reuse OperationId after an uncertain outcome and call ThrowIfFailed to fail the function.

Moves a Task relative to an explicit anchor or the ends of its shared Manual Queue sequence.

Transfers unassigned Idle or Blocked work under its Definition ChangeQueue grant.

Sets or clears the earliest assignment instant for unassigned Idle Queue work.

Creates Direct Idle work. An active Queue-mode Definition is rejected with tasks.runtime.queue.required and a QueueId field error; use .

Creates Queue Idle work with a current Queue residence and no Executor. See for Queue admission and managing Responsible rules.

Assigns the exact current Queue candidate to the calling Worker as Executor. The Task stays Idle in its Queue and keeps its Queue order facts. Assigned-Task capacity is checked; execution limits are not. See .

Takes the exact current Queue candidate for the calling Worker and starts it atomically: the assignment, the Idle to InProgress transition, history and receipt commit together or not at all. The Definition's Start grant, the Worker Profile execution limit and the Queue's in-progress maximum are checked with the assignment. It never starts work for another Worker.

Assignment, change or removal of the Executor of an unfinished Queue Task by a Queue dispatcher or Task administrator; running work stops and a pause or postponement ends first, while a block stays. See . The managing Responsible and the Owner of Queue work change through and .

The calling Executor gives their Queue work back where the Queue's return policy allows it; the comment is the required reason (tasks.runtime.executor.reasonRequired on field Comment). Running work stops and a pause or postponement ends first, all arriving Idle in the same Queue place; a block stays. A Queue that does not allow returns answers tasks.runtime.queue.returnNotAllowed; anyone but the current Executor, trusted automation included, receives tasks.runtime.forbidden. A Worker who returned work may no longer see it: the result is then null, and a repeated call with the same operation id still replays.

Assigns or clears the Direct Responsible, or the managing Responsible of Queue work; it never changes the Queue Executor. When a Queue Definition does not use the managing Responsible, only a Task administrator can clear a value retained from earlier configuration, and no other change is accepted.

"Make ready": ends a pause and returns the task to Idle with the same performer. It does not release the Queue Executor; see .

Postpones Idle, InProgress or Paused work of an assigned performer for the Definition's fixed delay with a Postponed reason. It uses one lifetime attempt and keeps the assignment; the Worker host returns the Task to Idle when due.

Ends a postponement early and returns the Task to Idle; anyone but the performer must give a comment as the reason.

Ends a postponement early and starts the work in the same transaction under the ordinary Start checks; anyone but the performer must give a comment as the reason.

Replaces Subject and Description under the Definition details grant.

Sets or clears the due instant under the Definition due-date grant and mode.

Sets the exact Priority/SubPriority pair under the Definition priority grant.

Replaces or clears the admitted Context; Task access never grants Context access.

Patches the owned Input Part under the Definition Input edit grant.

Patches the owned Working Part under the Definition Working edit grant.

Protected Task instance reads through the host application runtime.

Current routing rights, safe transfer destinations and protected shared order version.

Operational Queues currently discoverable by the actor, with their unfinished visible-Task count and whether the actor can acquire or dispatch there; this is not the administration catalog and grants no Task access.

The current global load of a Queue's visible pool Workers for its Dispatchers and the Task administrators of the Definitions it admits; any other caller receives a not-found result.

A bounded page of Tasks from the caller's SQL-authorized scope. with a Queue returns that Queue's current acquisition candidates for the caller; filters, count, sorting and pagination apply after the candidates are fixed.

Current lifecycle actions, active reasons and Outcomes for an existing task. For Queue work the actions also include take for a pool Worker when the Task is the exact current candidate (with take-and-start when the Definition would let that Worker start it), assign for a dispatcher of its Queue or a Task administrator of its Definition (with ReasonRequired once an Executor is assigned), and return for the Executor where the Queue allows returns. Each action carries its enabled state and reason code.

A bounded page of real operational evidence with protected participant labels.

Current readable values and version of one owned Part.

Current Definition instructions and protected file references for an authorized task.

Property/Part operations the caller may perform now, with the versions their commands must carry.

Full creation policy and both Entity forms for a Definition the caller may create.

Re-evaluates initial Working availability for intended participants; the command rechecks it.

A bounded page of readable targets admitted for creation, after current actor authorization.

A bounded page of readable targets admitted under the existing task's Context edit grant.

Application-level Task Definition reads for trusted .NET automation.

Returns due-date policy and saved Context admissions without granting runtime data access.

Returns supported metadata-only Context families; requires Task Definition management permission.

Searches minimal definition metadata for one Context family; requires Task Definition management permission.

Lists Task Definitions visible to the current runtime principal.

Returns one Task Definition, including its mode, outcomes, and interruption reasons.

Returns execution and interruption policies for one Task Definition.

Returns the fixed transition matrix and actor grants.

Lists completion-eligibility rules for one owned Outcome Definition.

Returns server-owned authoring metadata for one Outcome Definition.

Validates a completion-eligibility expression without executing it against runtime data.

Application-level Task Definition commands for trusted .NET automation.

Updates scalar creation policies with Definition concurrency and replay checks.

Adds one metadata-only Context definition admission without granting runtime data access.

Removes one owned admission without implicitly relaxing Context requiredness.

Creates an inactive Task Definition in its immutable Direct or Queue execution mode.

Updates mutable Task Definition properties while preserving its execution mode.

Deletes an unreferenced Task Definition and its governed owned resources.

Activates or deactivates a Task Definition after enforcing readiness requirements.

Creates a Pause, Blocked, or Postponed reason owned by a Task Definition.

Updates an unused interruption reason with Definition and reason concurrency checks.

Deletes an unreferenced interruption reason with Definition and reason concurrency checks.

Creates an Outcome Definition owned by a Task Definition.

Updates an owned Outcome Definition.

Deletes an unreferenced Outcome Definition.

Updates Definition-level execution and interruption policies.

Updates one supported transition rule.

Replaces actor grants for one Outcome.

Creates one completion-eligibility rule for an owned Outcome Definition.

Updates one completion-eligibility rule with parent and rule concurrency checks.

Deletes one completion-eligibility rule with parent and rule concurrency checks.

Registers Task Definition automation services.

Registers Task Definition query and command automation services.

Current requester receipt and safe Queue assignment diagnostics through the application principal.

Reads the current actor's own work request by its submitted OperationId.

Reads the safe Auto summary by its opaque receipt row Id, under current monitoring authority.

Idempotent Queue-owned intents. Calls use a separate application transaction and require current runtime authority.

Submits or replays work for the current actor's Worker. Poll the returned submitted key until terminal.

Submits a manual Auto intent under this Queue's current explicit manual capability.

Submits a distinct retry key for a failed Auto receipt row Id, rechecking current retry authority.

Authorized Queue configuration reads through the current application principal.

Reads configured sources, without resolving runtime membership.

Searches authorized metadata candidates of one explicit source kind.

Authorized, idempotent Queue configuration commands, never runtime assignment.

Moves the Queue between Active, Draining and Inactive. Active accepts new Tasks; Draining accepts none but still serves retained work; Inactive serves none. Inactive is rejected with tasks.queue.state.openTasks while the Queue retains unfinished Tasks: move it to Draining first.

Adds an active Queue Definition to the allowed composition.

Adds a Worker, role, or group source without materializing membership.

Maps a workspace role to the dispatcher role of this queue only.

Removes one definition admission, worker source, or dispatcher mapping.

Registers the Queue automation facade with shared query/command scope identity.

Availability of one capability delivered by the installed contract.

Machine-readable prerequisite state from a module dependency.

Machine-readable capability state from a module dependency.

Safe readiness status of one Tasks dependency.

Safe Tasks lifecycle and readiness status.

Read-only Tasks status for authorized application automation.

Returns safe lifecycle, readiness, and dependency status for the installed Tasks contract.

Registers the Tasks application-automation facade.

Registers Tasks status plus Task Definition query and command automation services.

Signal configuration read with the current caller's configuration permission.

Authorized, versioned and idempotent signal configuration commands.

Authorized profile configuration queries through the current application principal.

Atomic profile configuration commands, not runtime Task assignment.

One scoped facade with query/command aliases sharing the same instance.

Fixed operational roles. These keys do not grant module configuration permissions.

Task participant positions. Owner and Responsible are governed by the Definition; the Queue Executor is governed by the Queue and appears in runtime history and evidence, not in Definition admission or assignment settings.

Owner or requester.

Direct Responsible, who performs Direct work; for Queue work, the managing Responsible, who never performs it.

Queue Executor, the Worker who performs Queue work.

Kind of capacity policy that permitted a dispatcher capacity exception. This version produces only Worker Profile exceptions; Queue-owned capacity exceptions are not produced.

The recipient's effective Worker Profile, whose dispatcher exception settings permit exceeding its limit.

A Queue policy. Reserved; this version does not produce Queue-owned capacity exceptions.

Existing workspace membership sources eligible for a participant position.

Explicit categories allowed to perform an assignment.

Fixed assignment operations, not an extensible permission expression language.

Assignment grants; candidate eligibility is always checked separately.

A scoped association from the module's authoritative association store.

A Definition-owned participant admission, never an individual Worker assignment.

Configuration snapshot only; current membership and Worker/User facts are not cached here.

Immutable saved rules, without membership, source existence, or Worker/User facts.

Minimal metadata available to a Task Definition configurator, without runtime object access.

Canonical Resource Catalog definition identity, without a runtime object identifier.

Minimal metadata for a definition that may be admitted as Task Context.

One metadata-provider-supported Resource Catalog family.

One saved admission with current minimal target metadata and availability.

Task creation policy with its definition-owned Context allowlist.

Immutable creation-policy facts; these do not establish runtime target existence or authorization.

Updates due-date mode and Context requiredness without replacing the allowlist. ResponsibleRequiredOnCreate is writable for Direct only; Queue preserves its current value, configured atomically with participant availability through execution policy.

Adds one canonical Context definition admission.

Removes one owned Context definition admission.

Actions available for one Task Definition.

Actions available for one Task Definition Outcome.

Actions available for one transition rule.

Actions available for one completion eligibility rule.

Collection-level Task Definition actions.

One Task Definition Outcome returned to administration clients.

One localized execution-configuration diagnostic.

Server-owned default actor grants for one Outcome meta-type.

Definition-owned policies used by future Task runtime.

Whether a new Task must have a Responsible. Queue availability is carried by the historical QueueResponsibleRequired field.

One fixed state-pair configuration.

Complete fixed transition matrix for one Task Definition.

Compact Task Definition list projection.

Complete unpaged Task Definition collection.

Task Definition detail and its owned Outcomes and interruption reasons.

Explicit profile binding; takes precedence over the Queue profile without merging.

Successful Task Definition mutation.

Successful deletion of one Task Definition.

Creates one inactive Task Definition with an explicit, required execution mode.

Updates presentation and defaults. ExecutionMode must match the saved immutable mode.

Deletes one Task Definition when no external resource references it.

Activates or deactivates one Task Definition.

Adds one owned Outcome Definition.

Updates one owned Outcome Definition.

Deletes one owned Outcome Definition when no external resource references it.

Updates Definition-level execution and interruption policies.

Queue creation requiredness, independent of availability. Omission preserves the current value; an omitted value when enabling Queue Responsible retains the original required-on-create behavior. Disabling the participant clears this flag. Direct creation policy is changed through its own route.

Updates enabled state and actor grants for one fixed transition pair.

Replaces actor grants for one Outcome without changing its business meaning.

Immutable Task Definition snapshot intended for runtime decisions.

Immutable Outcome Definition inside a runtime snapshot.

Immutable execution policy inside a runtime snapshot.

Immutable transition rule inside a runtime snapshot.

One compiler diagnostic for a completion eligibility expression or dependency.

One compiler-owned stable dependency projected to clients and cache consumers.

Persisted completion eligibility rule returned to administration clients.

Successful completion eligibility rule mutation.

Successful completion eligibility rule deletion.

Immutable completion eligibility rule inside the Tasks runtime cache.

Owner-scoped metadata for one Task Data Designer direction.

One Working Data field available to completion eligibility authoring.

Server-authored description of the Tasks completion eligibility DSL.

Creates one completion eligibility rule for an Outcome.

Updates one completion eligibility rule and its compiler artifact.

Deletes one completion eligibility rule.

Validates an unsaved completion eligibility expression.

Existing rule whose stable bindings are retained for field paths kept in the expression.

Validation result for one completion eligibility expression.

Current Definition instructions. File identities reference existing File Storage placements; they grant no access.

Replaces instructions without uploading, copying or deleting source files.

Actor-safe file presentation. Unavailable references expose no source metadata.

Authoring projection evaluated with the current user's File Storage access.

Server-computed administration actions for an interruption reason.

One interruption reason returned to Definition administration clients.

Immutable reason inside its owning runtime Definition snapshot.

Creates one reason without seeding any other reasons or runtime policy.

Updates an owned reason using optimistic Definition and reason versions.

Deletes an unused reason using optimistic Definition and reason versions.

Fixed Task operations. Content read operations include their source explicitly.

Changes the earliest assignment instant for unassigned Idle Queue work.

Explicit participant or operational role facts, never configuration permissions.

Semantic content destination resolved by runtime, not a new resource identity.

Selected content sources or additional publication destinations.

One exact permitted actor/state pair. Independent lists must not be cross joined.

One finite operation and its explicitly stored grants.

Definition data/property permissions.

Independent reading, ownership and related publication settings for one content channel.

Stored collaboration configuration; disabling does not remove settings or content.

Replaces the full actor/state grant set of the route-selected operation.

Atomically updates channel settings without replacing permission grants.

Creates Direct/Idle work. OperationId is a stable business key across retries. No acting user, roles, arbitrary Part ids or execution state can be supplied.

Explicit UTC due instant; required, optional or rejected by the Definition due-date mode.

Admitted business Context the caller can read; null when optional and absent.

Input Part field values keyed by field key.

Initial Working Part values, accepted only under the Definition's Working edit rule.

Creates Idle work in one Queue, with a current Queue residence and no Executor. The Queue must be Active, admit the active Queue-mode Definition and use Any, First or Last selection. A Queue with Manual prioritization appends the Task after its current last rank. The caller needs Creator authority on the Definition; Worker-pool membership is not required. OperationId is a stable business key across retries; no acting user, roles, Part ids or execution state can be supplied.

Stable idempotency key; reuse it only to retry the same intent after an unknown outcome. Active Queue-mode Task Definition. Active Queue that admits the Definition. It becomes the Task's current Queue. Optional managing Responsible, a Worker distinct from the Executor who performs the work. It must be omitted when the Definition does not use this participant and supplied when the Definition requires it at creation. Optional admitted Owner. Subject, required, optional or rejected by the Definition Subject mode.

Stable idempotency key; reuse it only to retry the same intent after an unknown outcome.

Active Queue-mode Task Definition.

Active Queue that admits the Definition. It becomes the Task's current Queue.

Optional managing Responsible, a Worker distinct from the Executor who performs the work. It must be omitted when the Definition does not use this participant and supplied when the Definition requires it at creation.

Optional admitted Owner.

Subject, required, optional or rejected by the Definition Subject mode.

Optional description, validated as for Direct creation.

Explicit UTC due instant; required, optional or rejected by the Definition due-date mode.

Earliest assignment instant, normalized to UTC; null or a past instant is immediately available.

Admitted business Context the caller can read; null when optional and absent.

Input Part field values keyed by field key. An omitted key receives the field's configured default; an explicit null leaves it empty.

Initial Working Part values, accepted only under the Definition's Working edit rule.

Typed runtime projection with current Task scope and protected participant labels.

The caller must send a reason: a comment with any block or resolution, when ending another performer's postponement early and with a return to the Queue (return); the assignment request's Reason when changing or removing an assigned Executor (assign).

Changes one participant, or atomically stops and reassigns the Responsible.

Removes Owner or Responsible instead of selecting a Worker. WorkerId must be null; state and assignment grants still apply. Not supported by StopAndReassignAsync.

Sets the earliest assignment instant for unassigned Idle Queue work under the Definition ChangeAvailability grant. Offsets normalize to UTC; null clears the restriction, and past instants are immediately available. This never postpones, starts or assigns a Task. The field is required even when explicitly clearing it.

Typed runtime projection with current Task scope and protected participant labels.

The Task's lifetime postponement allowance; null while its Definition does not allow postponement.

Postponements the Task has used under its Definition's current policy. Used may exceed Maximum after the maximum was lowered; a new Postpone is then refused. Every postponement lasts DelayMinutes and returns the Task to Idle.

Postponements committed for this Task over its lifetime. Lifetime maximum of the Definition. Fixed postponement delay of the Definition.

Postponements committed for this Task over its lifetime.

Lifetime maximum of the Definition.

Fixed postponement delay of the Definition.

Completes a task through a configured Outcome and its completion requirements.

Replaces or clears the admitted business Context; the caller's own target access is required.

Creation policies and complete Entity form wire models for one creatable Definition. InputForm and WorkingForm are detached JSON trees using the same PascalCase Entity form schema as the HTTP creation form, including defaults, validation rules and field options. WorkingCapability describes the default participants; query it again when participants change.

Initial Working grant for the requested participants. The create command rechecks it.

Participants intended for a new task; null means unassigned.

Current Context requiredness and the exact admitted definitions.

One admitted Context definition with current family and display labels.

One currently readable target of an admitted Context definition.

A bounded page and the exact total of actor-readable Context targets.

Creation Context search; Skip must be a bounded multiple of Take, zero for the first page.

Context replacement search under the task's current edit grant; Skip must be a bounded multiple of Take.

Current readable values of one owned Part. Fields the caller cannot read are omitted.

The owned data Part of a task addressed by a data command or query.

Reads one owned Part of an authorized task.

Patches the owned Input or Working Part. Omitted keys stay unchanged and explicit null clears a value. PartRowVersion is the Entity record version returned by GetDataAsync; RowVersion is the Task version.

Replaces Subject and Description together; whitespace-only values clear them.

Sets the explicit UTC due instant; null clears it where the Definition allows it.

Current property/Part operations permitted for the caller and the versions its commands must carry.

One changed key of a property or data action. Property keys (see ) carry typed previous and new values; a changed Part field key has , its current schema when known and never a value.

Changed property key or Part field key. Scalar kind of the values, fixed by the key. Value before the change; null when the property was not set. Value after the change; null when the property was cleared.

One changed key of a property or data action. Property keys (see ) carry typed previous and new values; a changed Part field key has , its current schema when known and never a value.

Changed property key or Part field key.

Scalar kind of the values, fixed by the key.

Value before the change; null when the property was not set.

Value after the change; null when the property was cleared.

Current Part schema display name of a Part field key; null for property keys.

Typed runtime projection with current Task scope and protected participant labels.

One entry per changed key of a property or data action, in presentation order; empty for other actions. The same server-side projection feeds the runtime History and the Collaboration feed, so all three show the same facts.

Capacity exception used by a dispatcher's Executor assignment recorded in this entry; null for every other entry, including ordinary assignments within capacity.

Actor-shaped routing facts; no ranks or anchor identities cross this boundary.

The accepted return time of the postponement this entry started; null for every other entry.

Immutable evidence of a Queue dispatcher's explicit, reason-bearing capacity exception: an Executor assignment that took the recipient above a capacity limit because the owning policy permitted the exception. The dispatcher's reason is the history entry's Comment.

Kind of policy that permitted the exception; this version records Worker Profile policies only. Identity of the policy owner, the recipient's effective Worker Profile in this version. Exact policy version evaluated by the command. Limit that was exceeded; the assigned-Task limit in this version. Configured maximum of that limit when the command ran. Recipient's counted Tasks before the assignment. Recipient's counted Tasks after the assignment; greater than the configured maximum. Queue whose dispatcher authority scoped the exception. Worker who received the assignment.

Kind of policy that permitted the exception; this version records Worker Profile policies only.

Identity of the policy owner, the recipient's effective Worker Profile in this version.

Exact policy version evaluated by the command.

Limit that was exceeded; the assigned-Task limit in this version.

Configured maximum of that limit when the command ran.

Recipient's counted Tasks before the assignment.

Recipient's counted Tasks after the assignment; greater than the configured maximum.

Queue whose dispatcher authority scoped the exception.

Worker who received the assignment.

Typed runtime projection with current Task scope and protected participant labels.

Committed routing action without raw ranks or anchor identities.

Requested relative position for a move; null for a transfer. Readable Task history includes its Queue labels without granting access to those Queues. Current source Queue name, or null when the Queue no longer exists. Current destination Queue name, or null for a move or a Queue that no longer exists.

Committed routing action without raw ranks or anchor identities.

Requested relative position for a move; null for a transfer.

Current source Queue name, or null when the Queue no longer exists.

Current destination Queue name, or null for a move or a Queue that no longer exists.

One typed history value. The members that match the change's are set: for Text, for Integer, for Instant, and with its caller-safe label in for Resource. A stored value that does not match its key's format (possible only after a trusted direct EF write) is returned in as stored.

Plain text, the caller-safe label of a Context, or a stored value that does not match its format.

Exact signed 64-bit value of an Integer key.

UTC instant of an Instant key.

Resource identity of a Context key; the caller's current target access is not implied.

Current Definition instructions read through Task authority. Unavailable files disclose only their id.

One ordered instruction file binding as visible to a Task reader.

Pause, block or postpone with an active reason of the matching kind. A block requires a comment.

Bounded current-work query. Filters and ordering execute before PostgreSQL pagination.

Limits the actor-visible relation to one Queue. Null preserves the existing cross-mode list.

Direct Responsible or, for Queue work, the managing Responsible; filter Queue Executors with .

Queue Executor identity; Direct work never matches this filter.

Optional half-open due window [DueFromUtc, DueToUtc): lower bound inclusive, upper bound exclusive, the same interval contract as the runtime list API. Both bounds are optional and a bound alone limits one side; a task without a due date never matches a window. With neither bound no due filter applies, so undated tasks are listed too (this request has no due mode; the runtime list selects dated tasks only for Due="range"). DueFromUtc later than DueToUtc is rejected.

Available fixes the Queue candidate from shared Queue order before search, filters, count and pagination. It requires QueueId and returns no work for an inactive Queue or an actor that cannot currently receive work.

Relation that a reads before its filters, count and pagination.

Every Task the caller may view, limited to one Queue when QueueId is set. This is the default; without a Queue it is the existing cross-mode list.

The caller's acquisition candidates in one Queue (QueueId required): every eligible unassigned Idle Task under Any, or only the current first or last candidate under First or Last. Candidates are fixed from the shared Queue order before search, other filters, sorting, count and pagination, so a filter never exposes a different candidate. The result is empty unless the caller is an active pool Worker within assigned-Task capacity, the Queue is Active or Draining and its selection mode is Any, First or Last.

A successful committed command. Result is absent when the current caller cannot view the instance. Replayed commands preserve the original effect without a second mutation.

Typed runtime projection with current Task scope and protected participant labels.

One authorized page and the count of matching instances.

Sets the exact signed 64-bit Priority/SubPriority pair.

One Queue the current actor can discover through the operational workbench: through Worker-pool membership, dispatcher authority, a visible Task in the Queue, or Observer or Task administrator authority on a Definition the Queue admits. Discovery grants no Task access; Queue configuration uses the separate Queue automation services.

Queue identity. Queue display name. Optional Queue description. Queue lifecycle state. Active and Draining Queues serve retained work; only an Active Queue accepts new Tasks. Configured acquisition mode. Only Any, First and Last acquisition runs in this version. Number of unfinished (not Done) Tasks of this Queue that the actor can view. full when the actor is a dispatcher of this Queue and the count covers all of its unfinished Tasks; otherwise visible, meaning the count covers only Tasks visible to the actor. Whether the actor can take work here now: an active pool Worker within assigned-Task capacity, an Active or Draining Queue and Any, First or Last selection. Whether the actor has dispatcher authority for this Queue.

Queue identity.

Queue display name.

Optional Queue description.

Queue lifecycle state. Active and Draining Queues serve retained work; only an Active Queue accepts new Tasks.

Configured acquisition mode. Only Any, First and Last acquisition runs in this version.

Number of unfinished (not Done) Tasks of this Queue that the actor can view.

full when the actor is a dispatcher of this Queue and the count covers all of its unfinished Tasks; otherwise visible, meaning the count covers only Tasks visible to the actor.

Whether the actor can take work here now: an active pool Worker within assigned-Task capacity, an Active or Draining Queue and Any, First or Last selection.

Whether the actor has dispatcher authority for this Queue.

Whether GetQueueWorkloadAsync answers for this actor: a dispatcher of this Queue or a Task administrator of a Definition it admits.

Current actor's bounded operational Queue catalog; configuration-only Queue administration is separate.

Discoverable Queues ordered by display name, then identity.

Current actor's bounded operational Queue catalog; configuration-only Queue administration is separate.

Discoverable Queues ordered by display name, then identity.

An Active admitted transfer destination. Discovery confers no View of its Tasks.

Moves unfinished Queue work in the complete shared Manual sequence. The actor must be a Dispatcher with View of the whole sequence. Send both current versions from routing options; a stale order returns a conflict. Before/After require an explicit anchor in this Queue. First/Last reject an anchor. Reuse OperationId after an unknown outcome.

Self-acquisition of one Queue Task by the calling Worker, used by TakeAsync and TakeAndStartAsync. The caller must be an active Worker in the Queue's Worker pool with assignment capacity; nobody can take work for another Worker, and a dispatcher uses AssignExecutorAsync instead. Trusted system automation has no Worker and cannot take work. The Queue must be Active or Draining and use Any, First or Last selection. TaskId must be the exact current candidate: any eligible unassigned Idle Task of the Queue under Any, or the Queue's current first or last candidate under First or Last. A stale candidate or version returns a conflict; another Task is never substituted.

Stable idempotency key; reuse it only to retry the same intent after an unknown outcome. Queue to acquire from; it must be the Task's current Queue. Exact candidate chosen by the caller, for example from an Available list. Task version the caller observed.

Stable idempotency key; reuse it only to retry the same intent after an unknown outcome.

Queue to acquire from; it must be the Task's current Queue.

Exact candidate chosen by the caller, for example from an Available list.

Task version the caller observed.

Command used by AssignExecutorAsync: assigns, changes or removes the Executor of an unfinished Queue Task. A dispatcher of the Task's current Queue or a Task administrator of its Definition may use it (trusted system automation has dispatcher authority in every Queue), and the Queue must be Active or Draining. Running work stops and a pause or postponement ends first, all arriving Idle; Blocked work keeps its block and its authority; nothing starts. Changing or removing an assigned Executor requires a . A new Executor must be an active Worker in that Queue's pool and within assigned-Task capacity unless a dispatcher requests an explicit capacity exception. A dispatcher who is also in the pool may assign the Task to themselves only within their own capacity. The Queue, its ordering facts and the managing Responsible never change.

Stable idempotency key; reuse it only to retry the same intent after an unknown outcome. Unfinished Queue Task. Task version the caller observed. New Executor. Required unless is set, and must be null when it is.

Stable idempotency key; reuse it only to retry the same intent after an unknown outcome.

Unfinished Queue Task.

Task version the caller observed.

New Executor. Required unless is set, and must be null when it is.

Removes the current Executor instead of selecting a Worker. WorkerId must be null and false.

Requests an explicit exception to the recipient's assigned-Task limit; only a dispatcher may request one. The request is invalid without a non-empty . A recipient whose Worker Profile does not permit dispatcher exceptions, or a caller who is not a dispatcher, returns tasks.runtime.capacity.overrideNotAllowed; an exception for the dispatcher's own Worker returns tasks.runtime.capacity.selfOverride; one that is no longer needed returns tasks.runtime.capacity.overrideChanged. A used exception is recorded as immutable history evidence.

Explanation stored with the assignment evidence, at most 4000 characters. Required when an assigned Executor is changed or removed (tasks.runtime.executor.reasonRequired) and with ; optional for a first assignment.

Transfers unassigned Idle or Blocked Queue work under the Definition ChangeQueue grant. The destination must be Active and admit the Definition. State, Parts, number, block and availability are preserved. Remove an Executor explicitly before transferring assigned work. Success may have a null result when destination View is absent.

The current load of a Queue's pool Workers, readable by the Queue's Dispatchers and by Task administrators of the Definitions it admits. Only Workers visible to the reader are listed; their Tasks are never disclosed.

Queue identity. Visible pool Workers with their global load. Instant of the read.

Queue identity.

Visible pool Workers with their global load.

Instant of the read.

One Worker's global load across Direct work and every Queue, counted against the effective Worker Profile. A null maximum means unlimited.

Worker identity and protected label. Assigned unfinished Tasks, or only Idle Tasks when the profile counts Idle work. Profile maximum of assigned Tasks. Tasks in progress. Profile maximum of Tasks in progress. Paused Tasks. Profile maximum of paused Tasks. Postponed Tasks. Profile maximum of postponed Tasks. Blocked Tasks; blocking is never limited. Whether the blocked count exceeds the profile's warning threshold. Whether Assigned counts every unfinished Task rather than only Idle ones. Whether a count exceeds its maximum, for example after the maximum was lowered.

One Worker's global load across Direct work and every Queue, counted against the effective Worker Profile. A null maximum means unlimited.

Worker identity and protected label.

Assigned unfinished Tasks, or only Idle Tasks when the profile counts Idle work.

Profile maximum of assigned Tasks.

Tasks in progress.

Profile maximum of Tasks in progress.

Paused Tasks.

Profile maximum of paused Tasks.

Postponed Tasks.

Profile maximum of postponed Tasks.

Blocked Tasks; blocking is never limited.

Whether the blocked count exceeds the profile's warning threshold.

Whether Assigned counts every unfinished Task rather than only Idle ones.

Whether a count exceeds its maximum, for example after the maximum was lowered.

Typed runtime projection with current Task scope and protected participant labels.

Current routing authority. OrderVersion is absent unless the actor can see and reorder the whole Manual sequence.

Committed current facts returned by the Tasks application runtime.

Task identity. Task Definition identity. Issued Task number, including the Definition prefix used at issuance. Current Subject; null when absent. Current lifecycle state. Mode-dependent Responsible. For Direct work it is the Responsible who performs the work. For Queue work it is the managing Responsible, the same value as ; it never performs the work, and the Queue performer is . Current Owner; null when none is assigned. Signed 64-bit Priority, serialized as a decimal JSON string. Creation instant. Current optimistic version; send it with the next command for this Task.

Committed current facts returned by the Tasks application runtime.

Task identity.

Task Definition identity.

Issued Task number, including the Definition prefix used at issuance.

Current Subject; null when absent.

Current lifecycle state.

Mode-dependent Responsible. For Direct work it is the Responsible who performs the work. For Queue work it is the managing Responsible, the same value as ; it never performs the work, and the Queue performer is .

Current Owner; null when none is assigned.

Signed 64-bit Priority, serialized as a decimal JSON string.

Creation instant.

Current optimistic version; send it with the next command for this Task.

Current description; null when absent.

Current UTC due instant; null when absent.

Earliest assignment instant for Queue work; null means immediately available.

Signed 64-bit SubPriority that orders Tasks of equal Priority, serialized as a decimal JSON string.

Current business Context identity; null when absent.

Execution mode fixed by the Definition: Direct or Queue.

Current Queue of Queue work; null for Direct work.

Managing Responsible of Queue work; null for Direct work or when none is assigned.

Queue Executor, the Worker who performs Queue work; null for Direct work and unassigned Queue work.

Instant the Task entered its current Queue, from the open Queue residence; null for Direct work. Assignment, execution and other state changes inside the Queue do not reset it.

Queue-local Manual rank of the current residence, compared ordinally. It is meaningful only while the Queue uses Manual prioritization and the actor has Dispatcher authority and View of its complete sequence.

When a Postponed Task returns to Idle with the same performer; null in every other state. The return runs in the Worker host and may commit shortly after this instant.

Supported SQL sort fields; every sort has a stable instance-id tie breaker.

The selected Queue's configured prioritization; QueueId is required.

Current Queue residence entry time, independent of configured prioritization; Direct work sorts last.

Intention for a named lifecycle method. Comment is optional except as the explanation of a block resolution, as the reason when anyone but the performer ends a postponement early, and as the required reason of ReturnToQueueAsync. The method, rather than a caller-selected state, determines the transition.

Typed runtime projection with current Task scope and protected participant labels.

Current durable assignment intent status; Pending may include bounded scan continuations.

Stable client operation key. The current actor and its Worker are resolved by the application.

Current authorized requester receipt. Id is an opaque receipt identity; OperationId is the submitted key. Succeeded with Task=null is committed but currently unavailable, and never authorizes resubmission or another selection.

Safe Auto summary without Task, Worker, selector context or customer payload identities.

Explicit facts supplied by an authoritative caller, never resolved or authenticated by this pure policy.

Only a capacity verdict. Other command authorization and transactional invariants remain mandatory.

Pure arithmetic over current facts; does not authorize persisted work, count Tasks, or emit notifications.

Independent membership sources; a User is never a Queue participant identity.

One configured Worker-pool source, not its materialized membership.

A Workspace Role mapped to the fixed dispatcher role in the owning Queue.

Persisted configuration identities. Consumers must obtain current eligibility/authorization facts.

Initial configuration for a new or upgraded queue.

Reference metadata authorized for the configuration caller; unavailable sources remain removable.

Queue configuration with current, caller-safe reference diagnostics.

Minimal authorized configuration picker entry.

A bounded search page after authorization and candidate eligibility filters.

Adds an existing active Queue-mode Definition.

Adds one existing Worker, Workspace Role, or Group to the pool sources.

Maps an existing Workspace Role to this queue's dispatcher.

Removes a child reference only from its route's owning queue.

The operational role is separate from Workspace configuration roles.

Queue lifecycle configuration; no runtime admission or assignment grant is implied.

Whether an Executor may give their own work back to the Queue (D-01). A Dispatcher or Task administrator can always change or remove the Executor.

Only a Dispatcher or Task administrator releases the Executor.

The Executor may return the work with a required reason.

Authorized configuration actions, evaluated for the current caller.

Queue metadata without runtime counts or participant data.

Profile used only when the Task Definition has no profile binding.

Configuration only, not effective membership or an authorization result.

Whether Executors may return their own work to this Queue.

Authorized configuration catalog and collection action.

Creates an inactive queue with a stable, case-insensitive unique key.

Updates presentation metadata and the return policy. A queue's technical key is immutable.

Whether Executors may return their own work; omitted or null keeps the current policy.

Applies an explicit lifecycle transition, including empty-queue activation.

Deletes an inactive, unreferenced queue without deleting its audit or receipts.

Confirmed historical result of one queue mutation.

Confirmed historical result of queue deletion.

Immutable metadata for runtime consumers, not an authorization verdict.

Source identities for future consumers, which must resolve current facts.

Whether Executors may return their own work to this Queue.

Pure input and lifecycle rules shared by configuration entry points.

Returns a field name for the first invalid normalized metadata value.

Same-state commands are allowed and make no domain change.

Queue-owned exceptions only; no Task authorization or Worker profile authority is implied.

Configuration, not live load. Null maximum is unlimited; hard zero forbids an increase; warning zero disables.

Null disables. Continuous proof is required for this many minutes (1..43200).

Null disables. Measures elapsed time since Draining entry or actual retained-work reduction.

Authorized configuration and optimistic concurrency token.

Replaces the whole settings block atomically, including dispatcher exceptions.

Position in the complete shared Queue sequence, independent of personal filters and pages.

First unfinished Task.

Last unfinished Task.

Immediately before the explicit anchor Task.

Immediately after the explicit anchor Task.

Precedence based solely on Task-owned facts, independently of acquisition or dispatch.

Direction of the primary automatic key, never of the stable tie breakers.

Persisted Queue policy. Manual ordering has no direction.

Rejects unknown values and direction/mode combinations, without implicit coercion.

Authorized policy read with concurrency token and current edit capability.

Atomically replaces one Queue's prioritization configuration.

Lossless Task-owned priority pair. An unspecified sub-priority starts at zero.

Acquisition uses the effective priority order after eligibility, not a separate FIFO/LIFO ordering.

Chooses product code or a published customer function independently of invocation causes.

Product algorithms shipped with Tasks, independent of business-function publications.

Configures automatic invocation causes. Saving reconciles the Queue schedule; due triggers enqueue owned selector Jobs.

ManualEnabled is a retained transport/storage member. Dispatcher distribution is always available to authorized actors and is not controlled by that value.

Configures automatic invocation causes. Saving reconciles the Queue schedule; due triggers enqueue owned selector Jobs.

ManualEnabled is a retained transport/storage member. Dispatcher distribution is always available to authorized actors and is not controlled by that value.

Queue-owned algorithm choice, retained when a manual mode makes invocation settings inactive.

Hide future backlog from executors without broader rights in this Queue/Definition.

Require effective working time for Auto-assignment and Assignment on request; retained inactive in other modes.

Structural validation. The shared catalog and CRON/time-zone services validate external dependencies.

Live catalog diagnostics; never stored as the authoritative function availability in a Queue snapshot.

Minimal configuration metadata. Contains neither source text nor permission to enter Developer Studio.

Immutable assignment evidence, including initial assignments and previous participants.

Previously assigned Worker, or null for an initial assignment.

Assignment operation that produced this change.

Optional explanation captured when this action occurred.

Policy owner of an explicitly used capacity exception; null for an ordinary assignment.

Immutable Queue or Worker Profile identity whose policy allowed the exception.

Exact policy row version evaluated by the command.

Hard limit that was bypassed.

Configured maximum of the bypassed limit when the exception was used.

Recipient's counted Tasks before this assignment.

Recipient's counted Tasks after this assignment; greater than the configured maximum.

Queue whose dispatcher authority scoped the exception.

Participant role affected by this assignment.

Owning Task instance identifier.

Owning Task instance, when explicitly loaded.

Newly assigned Worker, or null when the assignment was explicitly removed.

Persisted command actor, including the host-authenticated automation actor.

Durable command that produced this evidence.

Command that produced this assignment.

UTC business timestamp of the recorded action.

Durable successful runtime command identity, normalized intent and replay evidence.

Authenticated caller category used in command identity.

Stable authenticated caller identity; never a client-provided actor override.

Runtime command family forming part of the replay identity.

Caller-supplied stable business operation key.

Hash of normalized command intent.

Owning Task instance identifier.

Task affected by this command, when explicitly loaded.

Queue residences opened by this command.

Original command state used for replay authorization.

Positive per-Task source revision; null identifies evidence written before operational clock tracking.

UTC business timestamp of the successful command.

Original initiating user, if any; attribution only.

Host correlation identifier.

Host function run identifier.

Published function identifier.

Immutable published function version identifier.

Published function key.

Host function contract name.

Host invocation source such as Cron or Trigger.

Published function version number, when supplied by the host.

The single immutable business outcome and completion time of a Task instance.

Owning Task instance identifier.

Owning Task instance, when explicitly loaded.

Outcome Definition used for completion.

Current outcome configuration; captured outcome facts remain historical evidence.

Outcome code captured at completion.

Outcome name captured at completion.

Success, failure or cancellation classification of the saved outcome.

Outcome version evaluated at completion.

Task Definition version evaluated at completion.

Completion comment, including cancellation explanations.

Persisted command actor, including the host-authenticated automation actor.

Actual Responsible Worker at the time of the action.

Durable command that produced this evidence.

Command that completed this task.

UTC business timestamp of the recorded action.

Rules evaluated by this completion, with their captured versions and expressions.

The exact completion rule evaluated by a successful terminal command.

Owning Task instance identifier.

Completion whose evaluated rule evidence this record preserves.

Completion rule whose evaluated form is preserved here.

Version of the evaluated completion rule.

Fingerprint of the evaluated compiled rule artifact.

Normalized expression evaluated by the completion command.

Immutable evidence of the command and actor that created a Task instance.

Owning Task instance identifier.

Owning Task instance, when explicitly loaded.

Persisted command actor, including the host-authenticated automation actor.

Durable command that produced this evidence.

Command that produced this creation evidence.

UTC business timestamp of the recorded action.

Workspace-authored definition used to create Tasks.

Execution mode, immutable after creation.

Whether Queue Tasks allow a managing Responsible. The historical field name is retained for persisted and public contracts.

Whether creation requires Responsible. Queue availability is configured independently.

Whether transitions into Postponed may be enabled.

Persisted instances; filter and load explicitly rather than loading all work.

Explicit admissions of this Definition to queues.

One admitted Resource Catalog definition identity owned by a Task Definition. It does not identify a runtime object or grant access to that object's data.

Actor category allowed to use one configured transition.

One fixed state pair configured for a Task Definition.

An actual Worker execution interval with immutable entry facts and an explicit end.

Owning Task instance identifier.

Owning Task instance, when explicitly loaded.

Worker associated with this assignment or execution.

Actor that started this execution interval.

Command that opened this interval.

Command that opened this execution interval.

UTC instant when this interval started.

UTC instant when this interval ended; null while it is open.

Actor that closed this interval.

Command that closed this interval.

Command that closed this interval, when it has ended.

Runtime action that closed this interval.

Persisted Task instance and its current operational facts. The command service is the primary application path; trusted direct EF callers own the transaction and related operational evidence.

Task Definition governing this instance.

Governing Definition, when explicitly loaded.

Operational source clock, loaded explicitly.

Immutable task number allocated from the workspace sequence.

Optional task subject captured under the Definition subject policy.

Optional task description edited together with Subject under the Definition details grant.

Immutable execution mode of this instance.

Current persisted lifecycle state.

Current Queue for Queue-mode work; null for Direct work.

Current Queue, when explicitly loaded.

Current Direct Responsible or Queue Executor, depending on .

Exact current Direct Responsible or Queue Executor assignment occurrence. Historical rows start null; a new effective assignment sets this to its immutable TaskAssignmentChange identifier.

Queue-mode managing Responsible. This is distinct from the Executor and is null for Direct work.

Current Owner Worker, or null when no Owner is assigned.

Exact owned Input Data Entity Part identifier.

Ownership claim for Input Data; not the dynamic Entity instance.

Exact owned Working Data Entity Part identifier.

Ownership claim for Working Data; not the dynamic Entity instance.

Task priority with signed 64-bit precision.

Secondary priority compared after ; zero unless explicitly changed.

Explicit due instant in UTC, or null. The Definition due-date mode governs requiredness.

Earliest Queue assignment instant in UTC; null means immediately available.

Identity of the current availability schedule, independent of the Task row version.

When the current availability occurrence produced its refresh notification.

Business Context module key of the canonical Resource Catalog identity, or null without Context. All four Context components are present together or all absent.

Business Context resource kind (for example EntityInstance or BoardItem).

Business Context definition identity (Entity Definition or Board identifier).

Business Context object identity (Entity Instance or Board Item identifier).

Optimistic concurrency token for the current instance.

Creation evidence, when present and explicitly loaded.

Terminal evidence, when the task is completed and explicitly loaded.

Assignment evidence; load or query the required window explicitly.

State transition evidence; load or query the required window explicitly.

Actual execution intervals.

Pause and block intervals.

Successful commands affecting this task.

Append-preserving Queue residence history.

Changes to this Task's shared Queue position.

Atomic transfers between Queue residences.

Property and Part change evidence; load or query the required window explicitly.

A pause, block or postponement interval preserving its reason, author, authority and resolution.

Owning Task instance identifier.

Owning Task instance, when explicitly loaded.

Pause, block or postponement interruption kind.

Original interruption reason identifier.

Current reason configuration; captured reason facts remain historical evidence.

Reason code captured on entry and unaffected by later configuration changes.

Reason name captured on entry.

Version of the reason admitted when the interval opened.

Optional explanation captured when this action occurred.

Persisted command actor, including the host-authenticated automation actor.

Worker linked to the initiating actor, when one exists.

Mode-specific performer (Direct Responsible or Queue Executor) at the time of the action.

Whether this block was imposed with management authority.

UTC instant when this interval started.

Command that opened this interval.

Command that opened this interruption.

UTC instant when this interval ended; null while it is open.

Actor that closed this interval.

Command that closed this interval.

Command that closed this interruption, when it has ended.

Runtime action that closed this interval.

Explanation supplied when resolving the block.

UTC instant when a postponement returns the Task to Idle; null for pause and block intervals.

One-based lifetime number of this postponement for its Task; null for pause and block intervals.

Fixed postponement delay in minutes applied when the postponement started; null for pause and block intervals.

Lifetime postponement maximum applied when the postponement started; null for pause and block intervals.

One administrator-authored interruption reason owned by a Task Definition.

Source clock and indexed pending evaluation, not a second AttentionSignal store.

Identity of the current normalized due-date episode. Null requires source-owned initialization before effects.

Observed normalized due instant.

Actual create/due-change command time; null for unproved legacy initialization or source repair.

At most eleven current catalog transition observations; never notification history.

Monotonic successful-command marker.

Queue condition continuity and due selection. Core owns active occurrence, acknowledgement and history.

Actor category allowed to select one Task Outcome.

One DSL rule that must pass before its owned Outcome may complete a future Task.

Compiler-owned stable dependency for one completion eligibility rule.

One selectable terminal outcome owned by a Task Definition.

Exclusive ownership of one Entity Part by a Task instance across both data slots.

Entity Part identifier reserved exclusively by this task.

Owning Task instance identifier.

One membership source admitted to a participant position of a Task Definition.

One explicit actor/state permission for an owned fixed operation.

Immutable evidence of one effective property or data Part change. The changed keys are its rows, one per key: property keys carry their typed previous and new values, Part changes list the changed field keys only; field values remain in the owned Entity record and its audit trail.

Owning Task instance identifier.

Owning Task instance, when explicitly loaded.

Changed property group or data Part.

Exact owned Part record changed by a data command; null for property changes.

Persisted command actor, including the host-authenticated automation actor.

Durable command that produced this evidence.

Command that produced this change.

UTC business timestamp of the recorded change.

One row per changed key, when explicitly loaded; an effective change has at least one.

One changed key of a ; a change has exactly one row per changed key. A property key () records its previous and new value as one scalar in the format of : Subject and Description as plain text, Priority and SubPriority as invariant decimal Int64, DueAtUtc as ISO-8601 UTC (2026-09-26T15:15:00.0000000Z) and Context as the resource-identity text; null means the property was not set before or is cleared after the change. A changed Part field key records no values: both are always null, because Part values stay in the owned Entity record and its audit trail.

Owning property change identifier.

Owning property change, when explicitly loaded.

Changed property key (see ) or changed Part field key; unique per change.

Encoded value before the change; null when the property was not set, and always null for a Part field key.

Encoded value after the change; null when the property was cleared, and always null for a Part field key.

Single configuration identity for a queue, independently of its future membership.

Source instants for null-to-positive configuration changes; positive edits retain them.

Chooses a product algorithm or a customer business function.

Product algorithm; set only when AlgorithmType is Embedded.

Require effective working time when selecting new assignments; retained inactive in manual acquisition modes.

Whether Executors may return their own work (D-01); Dispatchers and Task administrators always can.

Version of the shared unfinished sequence, independent of configuration changes.

Definitions explicitly admitted to this queue.

Configured sources of queue participants.

Current and historical Task residences in this Queue.

Tasks whose current Queue identity points to this Queue.

An explicitly accepted Definition; deletion of a referenced Definition is restricted.

Queue owning this admission.

Definition admitted to the queue.

Immutable evidence of an effective move in a Queue's shared order.

Moved Task identity.

Moved Task, when explicitly loaded.

Queue whose sequence changed.

Queue, when explicitly loaded.

Authenticated actor who made the move.

Atomic command identity.

Command evidence, when explicitly loaded.

UTC instant of the move.

Requested position in the complete sequence.

Explicit anchor, or null for an end. This identity requires independent authorization before display.

Previous ordinal rank; internal evidence, never an actor-shaped history value.

New ordinal rank; internal evidence, never an actor-shaped history value.

Append-preserving evidence that a Task entered a Queue. Exactly one residence may be open for a Queue-mode Task, and it belongs to the Task's current ; assignment, execution and other state changes do not close it. A transfer closes it and opens a new residence atomically, while a Done Task keeps its last one. The database enforces at most one open residence per Task; direct EF writers own keeping the Task's current Queue and its open residence consistent.

Task that entered the Queue.

Task, when explicitly loaded.

Queue the Task entered.

Queue, when explicitly loaded.

Instant the Task entered the Queue; the Queue-entry ordering fact of the open residence.

Instant the Task left the Queue; null while this is the Task's current residence.

Queue-local lexicographic Manual rank, compared ordinally. It is appended when a Task enters a Queue with Manual prioritization and captured for existing Tasks when a Queue switches to Manual; it is meaningful only while the Queue uses Manual prioritization.

Command that opened this residence.

Opening command record, when explicitly loaded.

Bounded Queue proof continuation; opaque reset guards never authorize a command or projection.

Bounded current exact-occurrence/step notification crossing evidence.

At most twelve current catalog transition observations; unknown Queue facts cannot create absence.

Owning schedule reset inputs for the current bounded pass; never an admission grant.

A known Working or OffShift pair, qualified by WorkSchedule and protected until KnownBoundaryUtc.

Immutable evidence joining the closed and newly opened residences of one atomic transfer.

Transferred Task identity.

Transferred Task, when explicitly loaded.

Source residence closed by this command.

Source residence, when explicitly loaded.

Destination residence opened by this command.

Destination residence, when explicitly loaded.

Authenticated actor who transferred the Task.

Atomic command identity.

Command evidence, when explicitly loaded.

UTC instant of transfer.

Configured membership source. A removed principal leaves a fail-closed reference.

Queue whose participants are supplied by this source.

Bounded source invalidation continuation. It requests recomputation; it stores no signal or authority.

Rotating bounded phase: 0 Task, 1 Queue.

Reusable current deadline and notification settings.

Typed TaskSignalPolicyModel array; only the bounded catalog is valid.

Applied Tasks security-manifest state for the workspace.

Durable identity of the generated time/results report; rename and archive never clear it.

Durable identity of the generated time/results dashboard; rename and archive never clear it.

Immutable evidence of a Task state transition and its actual performer.

Owning Task instance identifier.

Owning Task instance, when explicitly loaded.

Persisted state immediately before the transition.

Persisted state immediately after the transition.

Runtime action that caused the transition.

Persisted command actor, including the host-authenticated automation actor.

Actual Responsible Worker at the time of the action.

Optional explanation captured when this action occurred.

Durable command that produced this evidence.

Command that produced this transition.

UTC business timestamp of the recorded action.

Maps a workspace role to a Tasks internal role.

Tasks-owned global per-Worker capacity configuration; does not store a workload counter.

Only specialized membership is persisted. WorkerId is the existing system Entity Instance identity.

One admitted Task in the Queue's effective operational order. These facts are not a mutation grant.

One admitted recipient and its global assigned load, including Queue and Direct work.

A bounded, immutable candidate snapshot prepared by the Queue invocation adapter.

Governed candidate facts for the current selector invocation. The host owns eligibility and schedules.

Reads the prepared candidates for exactly this invocation, without discovering another Queue.

Cause of one Queue-owned asynchronous selection pass.

Identity and clock facts for one Queue. This context grants no access or mutation authority.

Checks identity shape and cause/recipient consistency, not authorization.

Proposes an assignment, not execution, transfer or a state change. Runtime revalidates both identities.

A selector's proposals. An empty collection is ordinary no-work, not failure.

Checks structural validity only; it does not authorize persisted Tasks or Workers.

Reusable C# Queue selector discovered through ordinary MoltaroFunction metadata. Queues select the published function through configuration; this class declares no target Queue. The Worker runtime owns invocation, admitted candidate facts and every assignment guard.

Proposes work for exactly the context Queue using supported trusted read services. Do not assign, start or transfer Tasks here. Empty output is a successful no-work decision.

Explicitly replaces a Definition or Queue binding; null removes it. Metadata updates never change this binding.

Recipient categories resolved against current source visibility; Default uses the signal catalog audience.

Explicit audience identity: user, role or responsibility group.

Transitions that request notification delivery; None leaves the active signal without transition notifications.

Configuration subject only; the producer resolves active users with current source View.

Overrides the catalog audience and explicitly enables transition delivery or acknowledgement.

Bounded operational configuration. A disabled bound profile suppresses its configured warnings and policies without falling through to another profile.

Current authorized profile settings and optimistic concurrency version.

Bounded profile page with the caller's current configuration-management capability.

Idempotent mutation receipt; Profile is absent after deletion or when no readable result remains.

Creates a profile under current configuration authority; preserve OperationId for an exact retry.

Replaces profile metadata and settings against the expected current version.

Deletes an unbound profile against its current version; exact retries reuse OperationId.

A named configuration subject, not a promise that every member currently has access to a signal.

A bounded page of 25 candidates. Users are searched by login; roles and groups by name.

Resolves at most 64 configured identities without returning unrelated user data.

Stable identifiers owned by the Tasks module.

Module lifecycle and application-dispatcher key.

Version of the public Tasks automation contract.

Supported authorization scope kinds.

Every Tasks foundation resource in the active workspace.

Operational roles for Instances of one Task Definition; never configuration access.

Operational dispatcher mappings for one queue; never configuration access.

Origin of a workspace-role association.

Created additively from the embedded manifest.

Created or changed explicitly by a workspace administrator.

Capabilities delivered by the installed Tasks foundation.

Administrative lifecycle and security configuration.

Read-only module status through application automation.

Task Definition, owned Outcome, completion requirement, and interruption-reason administration.

Queue configuration and lifecycle administration.

Global per-Worker capacity profiles and explicit specialized membership.

Safe Tasks lifecycle/configuration projection.

The module is disabled.

The module is enabled but its foundation requires repair.

The installed Tasks foundation and its dependencies are ready.

Stable Tasks foundation permission keys.

Lifecycle of an authored Task Definition.

The definition cannot be selected for new Tasks.

The definition may be selected for new Tasks.

Fixed execution mode chosen when a Task Definition is created.

Work is explicitly assigned to a Responsible without an execution queue.

Work is assigned to an Executor through an execution queue.

Product-defined classification of a Definition-owned interruption reason.

A performer pauses execution.

Work is blocked pending resolution.

Work is postponed until a later time.

How future Tasks created from a definition handle Subject.

Subject is not exposed and supplied values are rejected.

Subject is exposed but may be omitted.

Subject is exposed and must contain non-whitespace text.

Admissibility of a supplied due date when a future Task is created.

A due date is not used and supplied values are rejected.

A due date may be supplied or omitted.

A due date must be supplied at creation.

Stable outcome classification used by future Task completion.

Task-owned data directions configured by the Task Data Designer.

Data that must be available when a future Task is created.

Mutable data populated while a future Task is being performed.

Stable dependency kinds emitted by the completion eligibility compiler.

A stable Working Data field identifier.

The future Task outcome comment fact.

The future Task attachment evidence fact.

Pure projection and capacity decisions over explicit facts, never persisted Task authorization.

Preview assumes a reason will be supplied; only EvaluateIncrease authorizes a real exception.

Configuration facts only. This resolves neither Worker visibility nor current User eligibility.

Explicit reason-required exceptions for a dispatcher of the affected Task's Queue, never Direct Tasks.

Global per-performer configuration, not live workload or a profile's combined quota.

Configuration identity and current version; membership is read separately through secured projections.

Copies the exact current Default configuration shown to the author, not factory settings.

Expected effective source, including Default, captured when the Worker is selected.

Confirmed atomic transfer from each explicit source to the route's specialized target.

Returns these retained members to Default atomically, even if they are no longer eligible.

A safe configuration link; caller-invisible Worker names/numbers are never exposed.