@memberjunction/task-graph 0.0.0 → 6.1.0-edge.2

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright (c) 2023 MemberJunction
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,45 +1,185 @@
 # @memberjunction/task-graph
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+Durable execution of task graphs: submission, the dispatcher, the claim protocol, and the runners
+that turn a node into work.
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+> **New to workflows?** Start with the [Workflows and Task Graphs
+> Guide](../../guides/WORKFLOW_AND_TASK_GRAPH_GUIDE.md), which covers what a workflow is, when to
+> use one, and every rule that decides what happens next. This README is the package tour.
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+---
+
+## What this package is for
+
+A task graph is work that has to **outlive the thing that asked for it**. Before durable execution,
+a multi-step agent plan lived inside one agent run: a page reload lost it, a server restart orphaned
+it, and no channel other than the one that started it could see it.
+
+This package is the other half of that split. Something else *produces* a graph; this package makes
+it durable and runs it.
+
+```mermaid
+graph TB
+    subgraph Producers["Producers — anyone"]
+        P1["Flow agent<br/><i>compiled</i>"]
+        P2["Loop agent<br/><i>emitted</i>"]
+        P3["Entity action"]
+        P4["TaskGraph.Submit<br/><i>remote op</i>"]
+    end
+
+    P1 & P2 & P3 & P4 --> SVC["<b>TaskGraphService.Submit</b><br/>validate · resolve · persist"]
+    SVC --> ROWS["Task + TaskDependency"]
+    ROWS --> DISP["<b>TaskGraphDispatcher</b><br/>poll · claim · execute · settle"]
+
+    DISP --> R1["TaskAgentRunner"]
+    DISP --> R2["TaskActionRunner"]
+    DISP --> R3["TaskLoopExecutor"]
+    DISP --> R4["a person"]
+
+    style SVC fill:#7c5295,stroke:#563a6b,color:#fff
+    style ROWS fill:#2d8659,stroke:#1a5c3a,color:#fff
+    style DISP fill:#b8762f,stroke:#8a5722,color:#fff
+```
+
+**Submission never waits for execution.** `Submit` returns as soon as the graph is durable. That
+split is what makes the engine invocation-agnostic: an agent, a scheduled job, a Slack message and a
+manual UI all call the same method, and whichever dispatcher instance is running picks the work up.
+
+---
+
+## What it deliberately does not do
+
+**It does not decide graph semantics.** Eligibility, failure propagation, parent rollup, skip
+cascade, exclusive-group resolution and stall detection all come from pure, dependency-free
+functions in [`@memberjunction/ai-core-plus`](../AI/CorePlus). That is not tidiness — it is what
+stops the in-run executor and the durable executor from drifting apart. Neither owns the rules.
+
+**It does not import MJServer.** Provider minting and agent execution arrive as injected seams
+(`ProviderFactory`, `TaskAgentRunner`, `TaskActionRunner`), so the dependency runs
+MJServer → task-graph and never the reverse. That is also what keeps the dispatcher unit-testable
+without standing up the agent framework.
+
+---
+
+## The pieces
+
+| File | Responsibility |
+|---|---|
+| `TaskGraphService.ts` | Validate a spec, resolve names to IDs, write parent + children + edges. The only write path. |
+| `TaskGraphDispatcher.ts` | Poll, claim, execute, evaluate edges, propagate, roll up, settle, credit cost. |
+| `TaskClaimStore.ts` | The atomic claim protocol — guarded writes so two instances cannot run the same task. |
+| `TaskLoopExecutor.ts` | `ForEach` / `While` semantics: bounds, ordering, concurrency, delay, failure. |
+| `DispatcherConditionEvaluator.ts` | Edge conditions, over the superset context both dialects can read. |
+| `TaskGraphSubmitterImpl.ts` | Registers the durable submitter under the `ClassFactory` seam. |
+| `operations/` | The `TaskGraph.*` remote operations. |
 
-## Purpose
+---
+
+## Claiming: why a task runs exactly once
+
+Multiple dispatcher instances poll the same table. Correctness comes from a **guarded write**, not
+from coordination: claiming is an update that only succeeds if the row still looks the way the
+claimer expects.
+
+```mermaid
+sequenceDiagram
+    participant A as Instance A
+    participant B as Instance B
+    participant DB as Task row
+
+    A->>DB: claim if unclaimed / expired
+    B->>DB: claim if unclaimed / expired
+    DB-->>A: 1 row updated ✅
+    DB-->>B: 0 rows updated ❌
+    Note over B: defers — no lock, no retry storm
+    loop while running
+        A->>DB: heartbeat (extends ClaimExpiresAt)
+    end
+    A->>DB: complete IF still owned by A
+```
+
+If A dies, its claim expires and reconciliation makes the task claimable again. If A finishes but
+the row changed underneath it (cancelled, reassigned, reclaimed), the guarded completion refuses and
+A defers — overwriting would undo a newer, deliberate decision.
+
+---
+
+## Runners are seams, not implementations
+
+| Seam | Implemented by | Absent means |
+|---|---|---|
+| `TaskAgentRunner` | `TaskGraphAgentRunner` (MJServer) | agent nodes cannot run here |
+| `TaskActionRunner` | `TaskGraphActionRunner` (MJServer) | action nodes stay `Pending`, **not** Failed |
+| `ProviderFactory` | `TaskGraphProviderFactory` (MJServer) | required |
+| `TaskContinuationDeliverer` | `TaskGraphContinuationDeliverer` (MJServer) | outcomes are recorded but not announced |
+| `TaskGraphObserver` | the frame resolver (MJServer) | nobody is watching; behaviour identical |
+
+**A host with no runner is limited, not broken.** "Nobody here can run this" is not the same as
+"this ran and did not work", so those tasks stay visible and claimable by an instance that can.
+
+> **An Agent node starts a brand-new `AIAgentRun`** — a root run, linked from `Task.AgentRunID`
+> rather than nested under the submitting run. The relationship is expressed by the Task row.
+
+---
+
+## Starting a dispatcher
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@memberjunction/task-graph`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+MJAPI does this for you (`StartTaskGraphDispatcher`). For a custom host:
 
-## What is OIDC Trusted Publishing?
+```typescript
+import { TaskGraphDispatcher, LoadTaskGraphOperations } from '@memberjunction/task-graph';
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+LoadTaskGraphOperations();   // registers the remote operations + the durable submitter
 
-## Setup Instructions
+const dispatcher = new TaskGraphDispatcher(
+    providerFactory,
+    agentRunner,
+    contextUser,
+    { InstanceID: `worker-${process.pid}` },
+    continuationDeliverer,   // optional
+    observer,                // optional
+    actionRunner,            // optional
+);
+await dispatcher.Start();
+```
 
-To properly configure OIDC trusted publishing for this package:
+Without `LoadTaskGraphOperations()` nothing registers the submitter, and
+`GetTaskGraphSubmitter()` returns `null` — which callers must report rather than swallow.
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+---
 
-## DO NOT USE THIS PACKAGE
+## Cost rollup
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+When a graph settles, the dispatcher credits its spending back to the run that submitted it, writing
+the `…Rollup` columns on `AIAgentRun`:
 
-## More Information
+- `TotalCost` — what the submitting run itself spent. **Never rewritten here.**
+- `TotalCostRollup` — that run plus everything it caused.
 
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
+This cannot happen during the run: a submitting run *ends at submission*, so at the moment it
+computes its own totals the graph has not spent anything yet. See the guide's [cost
+section](../../guides/WORKFLOW_AND_TASK_GRAPH_GUIDE.md#cost-and-tokens-the-seam).
 
 ---
 
-**Maintained for OIDC setup purposes only**
+## Testing
+
+```bash
+cd packages/TaskGraph && pnpm test
+```
+
+Unit tests cover the pure pieces — loop semantics, dispatchable kinds, configuration persistence,
+parent metadata. The dispatcher driving **real rows against SQL Server** is covered by the `IT74`
+bundle in `@memberjunction/integration-test-suite`, which uses a stub agent runner so it stays in
+the deterministic tier: no model calls, no tokens, real claim protocol, real condition evaluator,
+real rollup.
+
+---
+
+## Related
+
+- [Workflows and Task Graphs Guide](../../guides/WORKFLOW_AND_TASK_GRAPH_GUIDE.md) — start here
+- [`@memberjunction/ai-core-plus`](../AI/CorePlus) — the spec, validator, compiler, pure algorithms,
+  payload mapping and layout
+- [`@memberjunction/ai-agents`](../AI/Agents) — the agent framework and `FlowAgentType`
+- [`packages/Actions/CLAUDE.md`](../Actions/CLAUDE.md) — Actions as boundaries

package/dist/DispatcherConditionEvaluator.d.ts

@@ -0,0 +1,10 @@
+import type { IConditionEvaluator } from '@memberjunction/ai-core-plus';
+export declare class DispatcherConditionEvaluator implements IConditionEvaluator {
+    private readonly evaluator;
+    Evaluate(expression: string, context: Record<string, unknown>): {
+        Success: boolean;
+        Value?: unknown;
+        ErrorMessage?: string;
+    };
+}
+//# sourceMappingURL=DispatcherConditionEvaluator.d.ts.map

package/dist/DispatcherConditionEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DispatcherConditionEvaluator.d.ts","sourceRoot":"","sources":["../src/DispatcherConditionEvaluator.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExE,qBAAa,4BAA6B,YAAW,mBAAmB;IACpE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;IAEpD,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE;CAUtI"}

package/dist/DispatcherConditionEvaluator.js

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Condition evaluation for durable graph edges.
+ *
+ * Wraps the same `SafeExpressionEvaluator` the design-time flow executor uses. Sharing the evaluator
+ * is not incidental — it is what makes an edge condition mean the same thing whether it was drawn in
+ * the flow editor or emitted by an agent, which is the premise Save as Workflow (D17) rests on.
+ *
+ * @module @memberjunction/task-graph
+ */
+import { SafeExpressionEvaluator } from '@memberjunction/global';
+export class DispatcherConditionEvaluator {
+    constructor() {
+        this.evaluator = new SafeExpressionEvaluator();
+    }
+    Evaluate(expression, context) {
+        try {
+            const result = this.evaluator.evaluate(expression, context);
+            return result.success
+                ? { Success: true, Value: result.value }
+                : { Success: false, ErrorMessage: String(result.error ?? 'condition evaluation failed') };
+        }
+        catch (e) {
+            return { Success: false, ErrorMessage: e instanceof Error ? e.message : String(e) };
+        }
+    }
+}
+//# sourceMappingURL=DispatcherConditionEvaluator.js.map

package/dist/DispatcherConditionEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DispatcherConditionEvaluator.js","sourceRoot":"","sources":["../src/DispatcherConditionEvaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAGjE,MAAM,OAAO,4BAA4B;IAAzC;QACqB,cAAS,GAAG,IAAI,uBAAuB,EAAE,CAAC;IAY/D,CAAC;IAVU,QAAQ,CAAC,UAAkB,EAAE,OAAgC;QAChE,IAAI,CAAC;YACD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;YAC5D,OAAO,MAAM,CAAC,OAAO;gBACjB,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE;gBACxC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,IAAI,6BAA6B,CAAC,EAAE,CAAC;QAClG,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QACxF,CAAC;IACL,CAAC;CACJ"}

package/dist/TaskClaimStore.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview The compare-and-swap claim protocol for durable task execution.
+ *
+ * This is the mechanism that lets more than one dispatcher instance work the same task table
+ * without two of them running the same task, and that lets a crashed instance's work be picked up
+ * rather than stranded. It is deliberately a small, self-contained unit: every state transition is
+ * a guarded `UPDATE ... WHERE <expected state>` whose rowcount is the answer, so correctness rests
+ * on the database's own atomicity rather than on a distributed lock manager.
+ *
+ * **Why rowcount and not read-then-write.** Reading a task, deciding it is claimable, then writing
+ * the claim is a textbook race: two instances can both read `Pending`. The single-statement form —
+ * `UPDATE Task SET ClaimedBy=@me WHERE ID=@id AND Status='Pending'` — makes the check and the write
+ * one atomic operation, so exactly one instance sees rowcount 1 and the other sees 0 and moves on.
+ *
+ * **Why every transition is guarded, not just the initial claim.** Per D20 the Task table stays
+ * user-writable: entity forms, Data Explorer, GraphQL, and any agent holding an update-record action
+ * can change `Status` or clear `ClaimedBy` underneath a running executor. A completion write that
+ * only said "set this task Complete" would happily overwrite a task someone had reassigned. Guarding
+ * on `ClaimedBy=@me` means a stale executor's write fails cleanly (rowcount 0) instead of
+ * double-completing, and the dispatcher can defer to the sweep.
+ *
+ * @module @memberjunction/task-graph
+ */
+import { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { ReconciliationEvent } from './types.js';
+/** Fields the claim protocol needs from a candidate task. */
+export type ClaimableTask = {
+    ID: string;
+    Name: string;
+    AgentID: string | null;
+    UserID: string | null;
+    InputPayload: string | null;
+};
+/**
+ * Guarded reads and writes over the `Task` claim columns.
+ *
+ * Uses direct SQL rather than `BaseEntity.Save()` on purpose, and this is the one place in the
+ * program where that is correct: the entire point is a *conditional* write whose rowcount is the
+ * return value. `Save()` issues an unconditional update and reports success for a row whose state
+ * changed underneath it, which is precisely the race being defended against. Every method here is a
+ * single statement; nothing reads-then-writes.
+ */
+export declare class TaskClaimStore {
+    private readonly instanceID;
+    private readonly claimTTLSeconds;
+    constructor(instanceID: string, claimTTLSeconds: number);
+    private sql;
+    /** Schema-qualified `Task` table for the provider's configured core schema. */
+    private taskTable;
+    /**
+     * Attempts to claim one task.
+     *
+     * The `Status='Pending'` predicate is the whole contract: a task another instance already moved
+     * to `In Progress` fails the predicate and yields rowcount 0. `ClaimedBy IS NULL OR
+     * ClaimExpiresAt < now` additionally lets an expired claim be taken over without a separate
+     * reconciliation pass having to run first.
+     *
+     * @returns true when this instance now owns the task
+     */
+    TryClaim(provider: IMetadataProvider, taskID: string, contextUser: UserInfo): Promise<boolean>;
+    /**
+     * Extends this instance's claim on a task it is actively running.
+     *
+     * Guarded on `ClaimedBy=@me` so a heartbeat can never resurrect a claim that reconciliation
+     * already released — if the sweep took the task back, the heartbeat fails and the executor
+     * learns its work is no longer owned.
+     *
+     * @returns true when the claim was extended; false means this instance no longer owns the task
+     */
+    Heartbeat(provider: IMetadataProvider, taskID: string, contextUser: UserInfo): Promise<boolean>;
+    /**
+     * Records a terminal outcome and releases the claim in one guarded statement.
+     *
+     * Guarded on both `Status='In Progress'` and `ClaimedBy=@me`: a task that was cancelled or
+     * reassigned while running fails the predicate, so a stale executor cannot overwrite the newer
+     * decision. The caller treats rowcount 0 as "someone else owns this now" rather than an error.
+     *
+     * @returns true when this instance's outcome was recorded
+     */
+    CompleteClaimed(provider: IMetadataProvider, taskID: string, outcome: {
+        Status: 'Complete' | 'Failed';
+        OutputPayload?: string | null;
+        ErrorMessage?: string | null;
+        AgentRunID?: string | null;
+        /**
+         * The step's Configuration bag, when the run produced something that belongs in it.
+         *
+         * Written in the SAME guarded UPDATE as the rest of the outcome rather than a follow-up
+         * save, because a second write could land after the row was reclaimed and would then
+         * attribute one instance's runtime artefacts to another instance's execution.
+         *
+         * Omitted leaves the column untouched — a step whose run produces no artefacts must not
+         * have its authored configuration blanked as a side effect of finishing.
+         */
+        Configuration?: string | null;
+    }, contextUser: UserInfo): Promise<boolean>;
+    /**
+     * Reclaims tasks whose claims have lapsed, returning them to `Pending` so any instance can pick
+     * them up.
+     *
+     * **Human tasks are exempt** (review round 2). A task assigned to a person (`UserID` set) never
+     * carries a claim, so `In Progress` with no claim is its *legitimate* parked shape — an approval
+     * waiting on someone. Normalizing it would reset that approval out from under the user. Their
+     * lifecycle is driven by `DueAt` notification and escalation, never by claim expiry.
+     *
+     * Only expired claims are reclaimed; a live claim is left strictly alone, which is what keeps a
+     * slow-but-healthy task from being executed twice.
+     */
+    ReleaseExpiredClaims(provider: IMetadataProvider, contextUser: UserInfo): Promise<ReconciliationEvent[]>;
+    /**
+     * Returns *agent* tasks sitting `In Progress` with no claim at all.
+     *
+     * This is the anomalous shape D20 anticipates from a human or an agent writing `Status`
+     * directly. It is reported rather than silently corrected: the row is evidence of tampering or
+     * of a bug, and Record Changes already carries the audit trail. Human-assigned tasks are
+     * excluded because for them this shape is legitimate, not anomalous.
+     */
+    FindOrphanedInProgress(provider: IMetadataProvider, contextUser: UserInfo): Promise<ReconciliationEvent[]>;
+    /** Runs the affected-rows statement, returning 0 on error rather than throwing into the loop. */
+    private affectedRows;
+    private literalOrNull;
+    /** Single-quote escaping. Inputs here are UUIDs and JSON the dispatcher itself produced. */
+    private escape;
+}
+//# sourceMappingURL=TaskClaimStore.d.ts.map

package/dist/TaskClaimStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskClaimStore.d.ts","sourceRoot":"","sources":["../src/TaskClaimStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,iBAAiB,EAA6C,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC9G,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C,6DAA6D;AAC7D,MAAM,MAAM,aAAa,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,cAAc;IAEnB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,eAAe;gBADf,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,MAAM;IAG5C,OAAO,CAAC,GAAG;IAIX,+EAA+E;IAC/E,OAAO,CAAC,SAAS;IAKjB;;;;;;;;;OASG;IACU,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB3G;;;;;;;;OAQG;IACU,SAAS,CAAC,QAAQ,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAY5G;;;;;;;;OAQG;IACU,eAAe,CACxB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;QACL,MAAM,EAAE,UAAU,GAAG,QAAQ,CAAC;QAC9B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B;;;;;;;;;WASG;QACH,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACjC,EACD,WAAW,EAAE,QAAQ,GACtB,OAAO,CAAC,OAAO,CAAC;IA6BnB;;;;;;;;;;;OAWG;IACU,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IA2CrH;;;;;;;OAOG;IACU,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAqBvH,iGAAiG;YACnF,YAAY;IAe1B,OAAO,CAAC,aAAa;IAIrB,4FAA4F;IAC5F,OAAO,CAAC,MAAM;CAGjB"}

package/dist/TaskClaimStore.js

@@ -0,0 +1,223 @@
+/**
+ * @fileoverview The compare-and-swap claim protocol for durable task execution.
+ *
+ * This is the mechanism that lets more than one dispatcher instance work the same task table
+ * without two of them running the same task, and that lets a crashed instance's work be picked up
+ * rather than stranded. It is deliberately a small, self-contained unit: every state transition is
+ * a guarded `UPDATE ... WHERE <expected state>` whose rowcount is the answer, so correctness rests
+ * on the database's own atomicity rather than on a distributed lock manager.
+ *
+ * **Why rowcount and not read-then-write.** Reading a task, deciding it is claimable, then writing
+ * the claim is a textbook race: two instances can both read `Pending`. The single-statement form —
+ * `UPDATE Task SET ClaimedBy=@me WHERE ID=@id AND Status='Pending'` — makes the check and the write
+ * one atomic operation, so exactly one instance sees rowcount 1 and the other sees 0 and moves on.
+ *
+ * **Why every transition is guarded, not just the initial claim.** Per D20 the Task table stays
+ * user-writable: entity forms, Data Explorer, GraphQL, and any agent holding an update-record action
+ * can change `Status` or clear `ClaimedBy` underneath a running executor. A completion write that
+ * only said "set this task Complete" would happily overwrite a task someone had reassigned. Guarding
+ * on `ClaimedBy=@me` means a stale executor's write fails cleanly (rowcount 0) instead of
+ * double-completing, and the dispatcher can defer to the sweep.
+ *
+ * @module @memberjunction/task-graph
+ */
+import { LogError, LogStatus } from '@memberjunction/core';
+/**
+ * Guarded reads and writes over the `Task` claim columns.
+ *
+ * Uses direct SQL rather than `BaseEntity.Save()` on purpose, and this is the one place in the
+ * program where that is correct: the entire point is a *conditional* write whose rowcount is the
+ * return value. `Save()` issues an unconditional update and reports success for a row whose state
+ * changed underneath it, which is precisely the race being defended against. Every method here is a
+ * single statement; nothing reads-then-writes.
+ */
+export class TaskClaimStore {
+    constructor(instanceID, claimTTLSeconds) {
+        this.instanceID = instanceID;
+        this.claimTTLSeconds = claimTTLSeconds;
+    }
+    sql(provider) {
+        return provider;
+    }
+    /** Schema-qualified `Task` table for the provider's configured core schema. */
+    taskTable(provider) {
+        const db = this.sql(provider);
+        return `${db.QuoteIdentifier(db.MJCoreSchemaName)}.${db.QuoteIdentifier('Task')}`;
+    }
+    /**
+     * Attempts to claim one task.
+     *
+     * The `Status='Pending'` predicate is the whole contract: a task another instance already moved
+     * to `In Progress` fails the predicate and yields rowcount 0. `ClaimedBy IS NULL OR
+     * ClaimExpiresAt < now` additionally lets an expired claim be taken over without a separate
+     * reconciliation pass having to run first.
+     *
+     * @returns true when this instance now owns the task
+     */
+    async TryClaim(provider, taskID, contextUser) {
+        const db = this.sql(provider);
+        const expires = new Date(Date.now() + this.claimTTLSeconds * 1000);
+        const sql = `
+            UPDATE ${this.taskTable(provider)}
+            SET ${db.QuoteIdentifier('Status')} = 'In Progress',
+                ${db.QuoteIdentifier('ClaimedBy')} = '${this.escape(this.instanceID)}',
+                ${db.QuoteIdentifier('ClaimExpiresAt')} = '${expires.toISOString()}',
+                ${db.QuoteIdentifier('StartedAt')} = '${new Date().toISOString()}'
+            WHERE ${db.QuoteIdentifier('ID')} = '${this.escape(taskID)}'
+              AND ${db.QuoteIdentifier('Status')} = 'Pending'
+              AND (${db.QuoteIdentifier('ClaimedBy')} IS NULL
+                   OR ${db.QuoteIdentifier('ClaimExpiresAt')} IS NULL
+                   OR ${db.QuoteIdentifier('ClaimExpiresAt')} < '${new Date().toISOString()}')`;
+        return (await this.affectedRows(db, sql, contextUser)) === 1;
+    }
+    /**
+     * Extends this instance's claim on a task it is actively running.
+     *
+     * Guarded on `ClaimedBy=@me` so a heartbeat can never resurrect a claim that reconciliation
+     * already released — if the sweep took the task back, the heartbeat fails and the executor
+     * learns its work is no longer owned.
+     *
+     * @returns true when the claim was extended; false means this instance no longer owns the task
+     */
+    async Heartbeat(provider, taskID, contextUser) {
+        const db = this.sql(provider);
+        const expires = new Date(Date.now() + this.claimTTLSeconds * 1000);
+        const sql = `
+            UPDATE ${this.taskTable(provider)}
+            SET ${db.QuoteIdentifier('ClaimExpiresAt')} = '${expires.toISOString()}'
+            WHERE ${db.QuoteIdentifier('ID')} = '${this.escape(taskID)}'
+              AND ${db.QuoteIdentifier('ClaimedBy')} = '${this.escape(this.instanceID)}'
+              AND ${db.QuoteIdentifier('Status')} = 'In Progress'`;
+        return (await this.affectedRows(db, sql, contextUser)) === 1;
+    }
+    /**
+     * Records a terminal outcome and releases the claim in one guarded statement.
+     *
+     * Guarded on both `Status='In Progress'` and `ClaimedBy=@me`: a task that was cancelled or
+     * reassigned while running fails the predicate, so a stale executor cannot overwrite the newer
+     * decision. The caller treats rowcount 0 as "someone else owns this now" rather than an error.
+     *
+     * @returns true when this instance's outcome was recorded
+     */
+    async CompleteClaimed(provider, taskID, outcome, contextUser) {
+        const db = this.sql(provider);
+        const sets = [
+            `${db.QuoteIdentifier('Status')} = '${outcome.Status}'`,
+            `${db.QuoteIdentifier('CompletedAt')} = '${new Date().toISOString()}'`,
+            `${db.QuoteIdentifier('PercentComplete')} = ${outcome.Status === 'Complete' ? 100 : 0}`,
+            // Release the claim as part of the same atomic write — a separate release could be
+            // interrupted, leaving a terminal task holding a claim that the sweep would then flag.
+            `${db.QuoteIdentifier('ClaimedBy')} = NULL`,
+            `${db.QuoteIdentifier('ClaimExpiresAt')} = NULL`,
+        ];
+        sets.push(`${db.QuoteIdentifier('OutputPayload')} = ${this.literalOrNull(outcome.OutputPayload)}`);
+        sets.push(`${db.QuoteIdentifier('ErrorMessage')} = ${this.literalOrNull(outcome.ErrorMessage)}`);
+        sets.push(`${db.QuoteIdentifier('AgentRunID')} = ${outcome.AgentRunID ? `'${this.escape(outcome.AgentRunID)}'` : 'NULL'}`);
+        // Only when supplied — see the note on the parameter. `undefined` means "leave it alone",
+        // which is not the same as an explicit null.
+        if (outcome.Configuration !== undefined) {
+            sets.push(`${db.QuoteIdentifier('Configuration')} = ${this.literalOrNull(outcome.Configuration)}`);
+        }
+        const sql = `
+            UPDATE ${this.taskTable(provider)}
+            SET ${sets.join(', ')}
+            WHERE ${db.QuoteIdentifier('ID')} = '${this.escape(taskID)}'
+              AND ${db.QuoteIdentifier('Status')} = 'In Progress'
+              AND ${db.QuoteIdentifier('ClaimedBy')} = '${this.escape(this.instanceID)}'`;
+        return (await this.affectedRows(db, sql, contextUser)) === 1;
+    }
+    /**
+     * Reclaims tasks whose claims have lapsed, returning them to `Pending` so any instance can pick
+     * them up.
+     *
+     * **Human tasks are exempt** (review round 2). A task assigned to a person (`UserID` set) never
+     * carries a claim, so `In Progress` with no claim is its *legitimate* parked shape — an approval
+     * waiting on someone. Normalizing it would reset that approval out from under the user. Their
+     * lifecycle is driven by `DueAt` notification and escalation, never by claim expiry.
+     *
+     * Only expired claims are reclaimed; a live claim is left strictly alone, which is what keeps a
+     * slow-but-healthy task from being executed twice.
+     */
+    async ReleaseExpiredClaims(provider, contextUser) {
+        const db = this.sql(provider);
+        const now = new Date().toISOString();
+        // Capture what will be reclaimed BEFORE reclaiming, so the log names the tasks. The
+        // subsequent UPDATE re-states the same predicate, so a task whose claim was refreshed in
+        // between is correctly skipped rather than reclaimed on stale information.
+        const candidates = await db.ExecuteSQL(`SELECT ${db.QuoteIdentifier('ID')}, ${db.QuoteIdentifier('Name')}, ${db.QuoteIdentifier('ClaimedBy')}
+             FROM ${this.taskTable(provider)}
+             WHERE ${db.QuoteIdentifier('Status')} = 'In Progress'
+               AND (${db.QuoteIdentifier('AgentID')} IS NOT NULL OR ${db.QuoteIdentifier('ActionID')} IS NOT NULL)
+               AND ${db.QuoteIdentifier('ClaimedBy')} IS NOT NULL
+               AND ${db.QuoteIdentifier('ClaimExpiresAt')} IS NOT NULL
+               AND ${db.QuoteIdentifier('ClaimExpiresAt')} < '${now}'`, undefined, undefined, contextUser);
+        if (!candidates || candidates.length === 0)
+            return [];
+        const sql = `
+            UPDATE ${this.taskTable(provider)}
+            SET ${db.QuoteIdentifier('Status')} = 'Pending',
+                ${db.QuoteIdentifier('ClaimedBy')} = NULL,
+                ${db.QuoteIdentifier('ClaimExpiresAt')} = NULL
+            WHERE ${db.QuoteIdentifier('Status')} = 'In Progress'
+              AND (${db.QuoteIdentifier('AgentID')} IS NOT NULL OR ${db.QuoteIdentifier('ActionID')} IS NOT NULL)
+              AND ${db.QuoteIdentifier('ClaimedBy')} IS NOT NULL
+              AND ${db.QuoteIdentifier('ClaimExpiresAt')} IS NOT NULL
+              AND ${db.QuoteIdentifier('ClaimExpiresAt')} < '${now}'`;
+        const released = await this.affectedRows(db, sql, contextUser);
+        const events = candidates.slice(0, released).map((c) => ({
+            TaskID: c.ID,
+            Action: 'ExpiredClaimReleased',
+            Detail: `Claim held by '${c.ClaimedBy}' expired; task '${c.Name}' returned to Pending.`,
+        }));
+        for (const e of events) {
+            LogStatus(`[TaskGraph reconciliation] ${e.Action}: ${e.Detail}`);
+        }
+        return events;
+    }
+    /**
+     * Returns *agent* tasks sitting `In Progress` with no claim at all.
+     *
+     * This is the anomalous shape D20 anticipates from a human or an agent writing `Status`
+     * directly. It is reported rather than silently corrected: the row is evidence of tampering or
+     * of a bug, and Record Changes already carries the audit trail. Human-assigned tasks are
+     * excluded because for them this shape is legitimate, not anomalous.
+     */
+    async FindOrphanedInProgress(provider, contextUser) {
+        const db = this.sql(provider);
+        const rows = await db.ExecuteSQL(`SELECT ${db.QuoteIdentifier('ID')}, ${db.QuoteIdentifier('Name')}
+             FROM ${this.taskTable(provider)}
+             WHERE ${db.QuoteIdentifier('Status')} = 'In Progress'
+               AND (${db.QuoteIdentifier('AgentID')} IS NOT NULL OR ${db.QuoteIdentifier('ActionID')} IS NOT NULL)
+               AND ${db.QuoteIdentifier('ClaimedBy')} IS NULL`, undefined, undefined, contextUser);
+        const events = (rows ?? []).map((r) => ({
+            TaskID: r.ID,
+            Action: 'OrphanedInProgressReleased',
+            Detail: `Agent task '${r.Name}' is In Progress with no claim — no dispatcher owns it.`,
+        }));
+        for (const e of events) {
+            LogError(`[TaskGraph reconciliation] ${e.Action}: ${e.Detail}`);
+        }
+        return events;
+    }
+    /** Runs the affected-rows statement, returning 0 on error rather than throwing into the loop. */
+    async affectedRows(db, sql, contextUser) {
+        try {
+            // Trailing SELECT is how the row count comes back as data across both dialects, rather
+            // than depending on a driver-specific rowsAffected field.
+            const rows = await db.ExecuteSQL(`${sql};\nSELECT @@ROWCOUNT AS ${db.QuoteIdentifier('AffectedRows')}`, undefined, undefined, contextUser);
+            return Number(rows?.[0]?.AffectedRows ?? 0);
+        }
+        catch (e) {
+            LogError(`[TaskGraph] guarded write failed: ${e instanceof Error ? e.message : String(e)}`);
+            return 0;
+        }
+    }
+    literalOrNull(value) {
+        return value == null ? 'NULL' : `'${this.escape(value)}'`;
+    }
+    /** Single-quote escaping. Inputs here are UUIDs and JSON the dispatcher itself produced. */
+    escape(value) {
+        return value.replace(/'/g, "''");
+    }
+}
+//# sourceMappingURL=TaskClaimStore.js.map

package/dist/TaskClaimStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskClaimStore.js","sourceRoot":"","sources":["../src/TaskClaimStore.ts"],"names":[],"mappings":"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"}