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

package/dist/operations/TaskGraphOperations.d.ts

@@ -0,0 +1,39 @@
+import { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { TaskGraphSubmitOperation, TaskGraphCancelOperation, TaskGraphRetryTaskOperation, TaskGraphGetStatusOperation, type TaskGraphSubmitInput, type TaskGraphSubmitOutput, type TaskGraphControlInput, type TaskGraphControlOutput, type TaskGraphRetryInput, type TaskGraphStatusOutput } from '@memberjunction/core-entities';
+/**
+ * `TaskGraph.Submit` — validate and durably persist a graph, returning immediately.
+ *
+ * Returning before execution is the point: the caller is freed the moment the work is safe, and the
+ * dispatcher owns it from there. That is what lets an agent submit a graph over MCP without holding
+ * anything open.
+ */
+export declare class TaskGraphSubmitServerOperation extends TaskGraphSubmitOperation {
+    protected InternalExecute(input: TaskGraphSubmitInput, provider: IMetadataProvider, user: UserInfo): Promise<TaskGraphSubmitOutput>;
+}
+/** `TaskGraph.Cancel` — cancel a graph and every task in it that has not already settled. */
+export declare class TaskGraphCancelServerOperation extends TaskGraphCancelOperation {
+    protected InternalExecute(input: TaskGraphControlInput, provider: IMetadataProvider, user: UserInfo): Promise<TaskGraphControlOutput>;
+}
+/**
+ * `TaskGraph.RetryTask` — return a failed task to `Pending` and unblock its dependents.
+ *
+ * Unblocking is not optional: retrying a task while its dependents remain `Blocked` leaves the graph
+ * exactly as stuck as before, because nothing downstream ever becomes eligible again.
+ */
+export declare class TaskGraphRetryTaskServerOperation extends TaskGraphRetryTaskOperation {
+    protected InternalExecute(input: TaskGraphRetryInput, provider: IMetadataProvider, user: UserInfo): Promise<TaskGraphControlOutput>;
+}
+/**
+ * `TaskGraph.GetStatus` — snapshot a graph's progress without waiting for anything.
+ *
+ * This is the observation half of making execution durable. Once nobody holds a request open, a
+ * caller — a client re-attaching after reload, an agent checking work it submitted, an external MCP
+ * caller — needs a way to ask "where is it?". The rollup uses the same pure algorithm the dispatcher
+ * uses, so the reported status cannot disagree with the engine's own view.
+ */
+export declare class TaskGraphGetStatusServerOperation extends TaskGraphGetStatusOperation {
+    protected InternalExecute(input: TaskGraphControlInput, provider: IMetadataProvider, user: UserInfo): Promise<TaskGraphStatusOutput>;
+}
+/** Prevents tree-shaking of the registered operation classes. */
+export declare function LoadTaskGraphOperations(): void;
+//# sourceMappingURL=TaskGraphOperations.d.ts.map

package/dist/operations/TaskGraphOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskGraphOperations.d.ts","sourceRoot":"","sources":["../../src/operations/TaskGraphOperations.ts"],"names":[],"mappings":"AAqBA,OAAO,EAA0B,iBAAiB,EAAW,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACpG,OAAO,EAEH,wBAAwB,EACxB,wBAAwB,EACxB,2BAA2B,EAC3B,2BAA2B,EAC3B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC7B,MAAM,+BAA+B,CAAC;AAsCvC;;;;;;GAMG;AACH,qBACa,8BAA+B,SAAQ,wBAAwB;cACxD,eAAe,CAC3B,KAAK,EAAE,oBAAoB,EAC3B,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ,GACf,OAAO,CAAC,qBAAqB,CAAC;CAepC;AAED,6FAA6F;AAC7F,qBACa,8BAA+B,SAAQ,wBAAwB;cACxD,eAAe,CAC3B,KAAK,EAAE,qBAAqB,EAC5B,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ,GACf,OAAO,CAAC,sBAAsB,CAAC;CAYrC;AAED;;;;;GAKG;AACH,qBACa,iCAAkC,SAAQ,2BAA2B;cAC9D,eAAe,CAC3B,KAAK,EAAE,mBAAmB,EAC1B,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ,GACf,OAAO,CAAC,sBAAsB,CAAC;CAUrC;AAED;;;;;;;GAOG;AACH,qBACa,iCAAkC,SAAQ,2BAA2B;cAC9D,eAAe,CAC3B,KAAK,EAAE,qBAAqB,EAC5B,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ,GACf,OAAO,CAAC,qBAAqB,CAAC;CAkCpC;AAED,iEAAiE;AACjE,wBAAgB,uBAAuB,IAAI,IAAI,CAK9C"}

package/dist/operations/TaskGraphOperations.js

@@ -0,0 +1,164 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * @fileoverview Remote Operation implementations for the task-graph control plane.
+ *
+ * **Why these exist rather than bespoke GraphQL mutations.** Remote Operations are MJ's *typed
+ * control plane* — one call site reachable from MCP (external agents), from an Action wrapper
+ * (internal agents), and from the UI. Phase 2 originally shipped `SubmitTaskGraph` /
+ * `CancelTaskGraph` / `RetryTask` as GraphQL mutations, which fixed the durability problem but left
+ * the reachability one exactly where it was: callable from the Explorer client and nothing else.
+ *
+ * That was inconsistent with the closest analogous substrate — Record Set Processing exposes
+ * `Run` / `Pause` / `Resume` / `Cancel` / `Get Run Status` entirely as Remote Operations — and it
+ * undercut the program's own goal of letting agents *set up* workflows rather than only navigate to
+ * them. These operations replace those mutations.
+ *
+ * Each row is `GenerationType=Manual`, so CodeGen emits a typed base into `@memberjunction/core-entities`
+ * and these subclasses supply the body. All logic stays in `TaskGraphService`; these are thin
+ * adapters, and the last registration wins by import order per the ClassFactory contract.
+ *
+ * @module @memberjunction/task-graph
+ */
+import { RegisterClass } from '@memberjunction/global';
+import { BaseRemotableOperation, RunView } from '@memberjunction/core';
+import { TaskGraphSubmitOperation, TaskGraphCancelOperation, TaskGraphRetryTaskOperation, TaskGraphGetStatusOperation, } from '@memberjunction/core-entities';
+import { ComputeParentRollup } from '@memberjunction/ai-core-plus';
+import { TaskGraphService } from '../TaskGraphService.js';
+/**
+ * Builds the service context from the operation's provider + user.
+ *
+ * `environmentID` is empty on the cancel/retry paths and that is not a placeholder: the graph
+ * already exists, so nothing is created that would need one, and `TaskGraphService` reads the field
+ * only while persisting a new graph.
+ */
+function submitContext(provider, user, environmentID, conversationDetailID) {
+    return {
+        EnvironmentID: environmentID,
+        ConversationDetailID: conversationDetailID ?? null,
+        ContextUser: user,
+        Provider: provider,
+    };
+}
+/**
+ * `TaskGraph.Submit` — validate and durably persist a graph, returning immediately.
+ *
+ * Returning before execution is the point: the caller is freed the moment the work is safe, and the
+ * dispatcher owns it from there. That is what lets an agent submit a graph over MCP without holding
+ * anything open.
+ */
+let TaskGraphSubmitServerOperation = class TaskGraphSubmitServerOperation extends TaskGraphSubmitOperation {
+    async InternalExecute(input, provider, user) {
+        if (!input?.spec)
+            throw new Error('spec is required');
+        if (!input?.environmentID)
+            throw new Error('environmentID is required');
+        const spec = input.spec;
+        const result = await new TaskGraphService().Submit(spec, submitContext(provider, user, input.environmentID, input.conversationDetailID));
+        return {
+            success: result.Success,
+            parentTaskID: result.ParentTaskID,
+            errorMessage: result.ErrorMessage,
+        };
+    }
+};
+TaskGraphSubmitServerOperation = __decorate([
+    RegisterClass(BaseRemotableOperation, 'TaskGraph.Submit')
+], TaskGraphSubmitServerOperation);
+export { TaskGraphSubmitServerOperation };
+/** `TaskGraph.Cancel` — cancel a graph and every task in it that has not already settled. */
+let TaskGraphCancelServerOperation = class TaskGraphCancelServerOperation extends TaskGraphCancelOperation {
+    async InternalExecute(input, provider, user) {
+        if (!input?.parentTaskID)
+            throw new Error('parentTaskID is required');
+        // EnvironmentID is unused on the cancel path — the graph already exists, so nothing new is
+        // created that would need one.
+        const ok = await new TaskGraphService().Cancel(input.parentTaskID, submitContext(provider, user, ''));
+        if (!ok)
+            return { success: false, errorMessage: 'Cancel failed; see the server log for detail.' };
+        const parent = await provider.GetEntityObject('MJ: Tasks', user);
+        const loaded = await parent.Load(input.parentTaskID);
+        return { success: true, status: loaded ? parent.Status : undefined };
+    }
+};
+TaskGraphCancelServerOperation = __decorate([
+    RegisterClass(BaseRemotableOperation, 'TaskGraph.Cancel')
+], TaskGraphCancelServerOperation);
+export { TaskGraphCancelServerOperation };
+/**
+ * `TaskGraph.RetryTask` — return a failed task to `Pending` and unblock its dependents.
+ *
+ * Unblocking is not optional: retrying a task while its dependents remain `Blocked` leaves the graph
+ * exactly as stuck as before, because nothing downstream ever becomes eligible again.
+ */
+let TaskGraphRetryTaskServerOperation = class TaskGraphRetryTaskServerOperation extends TaskGraphRetryTaskOperation {
+    async InternalExecute(input, provider, user) {
+        if (!input?.taskID)
+            throw new Error('taskID is required');
+        const ok = await new TaskGraphService().Retry(input.taskID, submitContext(provider, user, ''));
+        if (!ok)
+            return { success: false, errorMessage: 'Retry failed; the task may not be in a Failed state.' };
+        const task = await provider.GetEntityObject('MJ: Tasks', user);
+        const loaded = await task.Load(input.taskID);
+        return { success: true, status: loaded ? task.Status : undefined };
+    }
+};
+TaskGraphRetryTaskServerOperation = __decorate([
+    RegisterClass(BaseRemotableOperation, 'TaskGraph.RetryTask')
+], TaskGraphRetryTaskServerOperation);
+export { TaskGraphRetryTaskServerOperation };
+/**
+ * `TaskGraph.GetStatus` — snapshot a graph's progress without waiting for anything.
+ *
+ * This is the observation half of making execution durable. Once nobody holds a request open, a
+ * caller — a client re-attaching after reload, an agent checking work it submitted, an external MCP
+ * caller — needs a way to ask "where is it?". The rollup uses the same pure algorithm the dispatcher
+ * uses, so the reported status cannot disagree with the engine's own view.
+ */
+let TaskGraphGetStatusServerOperation = class TaskGraphGetStatusServerOperation extends TaskGraphGetStatusOperation {
+    async InternalExecute(input, provider, user) {
+        if (!input?.parentTaskID)
+            throw new Error('parentTaskID is required');
+        // Read-only snapshot, so `simple` + a narrow field list — no reason to pay for entity
+        // objects here. Scoped to the operation's own provider rather than the global default.
+        const children = await RunView.FromMetadataProvider(provider).RunView({
+            EntityName: 'MJ: Tasks',
+            ExtraFilter: `ParentID='${input.parentTaskID}'`,
+            Fields: ['ID', 'Name', 'Status', 'AgentRunID', 'ErrorMessage'],
+            ResultType: 'simple',
+        }, user);
+        if (!children.Success) {
+            return { success: false, errorMessage: children.ErrorMessage ?? 'Could not load the graph.' };
+        }
+        const rows = children.Results ?? [];
+        const rollup = ComputeParentRollup(rows.map((r) => ({ id: r.ID, status: r.Status })));
+        return {
+            success: true,
+            status: rollup.status,
+            percentComplete: rollup.percentComplete,
+            tasks: rows.map((r) => ({
+                taskID: r.ID,
+                name: r.Name,
+                status: r.Status,
+                agentRunID: r.AgentRunID ?? undefined,
+                errorMessage: r.ErrorMessage ?? undefined,
+            })),
+        };
+    }
+};
+TaskGraphGetStatusServerOperation = __decorate([
+    RegisterClass(BaseRemotableOperation, 'TaskGraph.GetStatus')
+], TaskGraphGetStatusServerOperation);
+export { TaskGraphGetStatusServerOperation };
+/** Prevents tree-shaking of the registered operation classes. */
+export function LoadTaskGraphOperations() {
+    void TaskGraphSubmitServerOperation;
+    void TaskGraphCancelServerOperation;
+    void TaskGraphRetryTaskServerOperation;
+    void TaskGraphGetStatusServerOperation;
+}
+//# sourceMappingURL=TaskGraphOperations.js.map

package/dist/operations/TaskGraphOperations.js.map

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

package/dist/operations/WorkflowOperations.d.ts

@@ -0,0 +1,22 @@
+import { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { WorkflowSaveOperation, WorkflowValidateOperation, type WorkflowSaveInput, type WorkflowSaveOutput, type WorkflowValidateOutput } from '@memberjunction/core-entities';
+import { ValidateWorkflowSpec } from '@memberjunction/ai-core-plus';
+/** `Workflow.Save` — validate a workflow and reconcile every substrate it owns. */
+export declare class WorkflowSaveServerOperation extends WorkflowSaveOperation {
+    protected InternalExecute(input: WorkflowSaveInput, provider: IMetadataProvider, user: UserInfo): Promise<WorkflowSaveOutput>;
+}
+/**
+ * `Workflow.Validate` — check a workflow without saving it.
+ *
+ * Writes nothing, which is the point: an agent drafting a workflow can iterate until it is right
+ * before anything reaches the scheduler. Reports every failure at once rather than the first, so a
+ * fix takes one round-trip rather than several.
+ */
+export declare class WorkflowValidateServerOperation extends WorkflowValidateOperation {
+    protected InternalExecute(input: WorkflowSaveInput, _provider: IMetadataProvider, _user: UserInfo): Promise<WorkflowValidateOutput>;
+}
+/** Renders validation failures for a caller that wants one string. */
+export declare function FormatWorkflowErrors(errors: ReturnType<typeof ValidateWorkflowSpec>['Errors']): string;
+/** Prevents tree-shaking of the registered operation classes. */
+export declare function LoadWorkflowOperations(): void;
+//# sourceMappingURL=WorkflowOperations.d.ts.map

package/dist/operations/WorkflowOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkflowOperations.d.ts","sourceRoot":"","sources":["../../src/operations/WorkflowOperations.ts"],"names":[],"mappings":"AAiBA,OAAO,EAA0B,iBAAiB,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EACH,qBAAqB,EACrB,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC9B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAEH,oBAAoB,EAEvB,MAAM,8BAA8B,CAAC;AAmBtC,mFAAmF;AACnF,qBACa,2BAA4B,SAAQ,qBAAqB;cAClD,eAAe,CAC3B,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ,GACf,OAAO,CAAC,kBAAkB,CAAC;CAmBjC;AAED;;;;;;GAMG;AACH,qBACa,+BAAgC,SAAQ,yBAAyB;cAC1D,eAAe,CAC3B,KAAK,EAAE,iBAAiB,EACxB,SAAS,EAAE,iBAAiB,EAC5B,KAAK,EAAE,QAAQ,GAChB,OAAO,CAAC,sBAAsB,CAAC;CAWrC;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,QAAQ,CAAC,GAAG,MAAM,CAEtG;AAED,iEAAiE;AACjE,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C"}

package/dist/operations/WorkflowOperations.js

@@ -0,0 +1,99 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * @fileoverview Remote Operations for authoring workflows.
+ *
+ * **This is the hole the program set out to close.** Agents could already *navigate* to a workflow;
+ * they could not *set one up*. Today `Create Scheduled Job` cannot even set `Configuration`, so an
+ * agent asked to "run this every Monday" had nothing to call. These two operations make authoring a
+ * workflow — steps and triggers together — a single typed call reachable from MCP (external agents),
+ * an Action wrapper (internal agents), and the editor.
+ *
+ * **Two operations, not one, because drafting and committing are different acts.** `Validate` lets an
+ * agent iterate on a draft without writing anything — the draft-then-confirm shape dry-run and Plan
+ * Mode already established. `Save` commits. Both run the identical validator, so a workflow that
+ * validates cannot then be rejected on save for a different reason.
+ *
+ * @module @memberjunction/task-graph
+ */
+import { RegisterClass, MJGlobal } from '@memberjunction/global';
+import { BaseRemotableOperation } from '@memberjunction/core';
+import { WorkflowSaveOperation, WorkflowValidateOperation, } from '@memberjunction/core-entities';
+import { FormatWorkflowValidationErrors, ValidateWorkflowSpec, } from '@memberjunction/ai-core-plus';
+import { WorkflowSpecSync } from '../WorkflowSpecSync.js';
+/**
+ * Resolves the host's agent writer, or null.
+ *
+ * Looked up through the ClassFactory rather than imported so this package does not depend on the
+ * agent-manager. Null is a legitimate configuration (a worker, a test) and produces an honest
+ * failure rather than a half-saved workflow.
+ */
+function resolveAgentWriter() {
+    return MJGlobal.Instance.ClassFactory.CreateInstance(
+    // The base class is declared in the agent-manager; resolving by key alone keeps this package
+    // free of that import while still finding whatever the host registered.
+    Object, 'WorkflowAgentWriter');
+}
+/** `Workflow.Save` — validate a workflow and reconcile every substrate it owns. */
+let WorkflowSaveServerOperation = class WorkflowSaveServerOperation extends WorkflowSaveOperation {
+    async InternalExecute(input, provider, user) {
+        if (!input?.spec)
+            throw new Error('spec is required');
+        const spec = input.spec;
+        const result = await new WorkflowSpecSync(resolveAgentWriter()).Persist(spec, {
+            ContextUser: user,
+            Provider: provider,
+        });
+        return {
+            success: result.Success,
+            agentID: result.AgentID,
+            scheduledJobIDs: result.ScheduledJobIDs,
+            // Surfaced, not swallowed: a user who asked for "run this when an invoice changes" and
+            // got a workflow that never fires has no way to discover why from the UI alone.
+            unreconciled: result.Unreconciled.length ? result.Unreconciled : undefined,
+            errorMessage: result.ErrorMessage,
+        };
+    }
+};
+WorkflowSaveServerOperation = __decorate([
+    RegisterClass(BaseRemotableOperation, 'Workflow.Save')
+], WorkflowSaveServerOperation);
+export { WorkflowSaveServerOperation };
+/**
+ * `Workflow.Validate` — check a workflow without saving it.
+ *
+ * Writes nothing, which is the point: an agent drafting a workflow can iterate until it is right
+ * before anything reaches the scheduler. Reports every failure at once rather than the first, so a
+ * fix takes one round-trip rather than several.
+ */
+let WorkflowValidateServerOperation = class WorkflowValidateServerOperation extends WorkflowValidateOperation {
+    async InternalExecute(input, _provider, _user) {
+        if (!input?.spec)
+            throw new Error('spec is required');
+        const validation = ValidateWorkflowSpec(input.spec);
+        return {
+            valid: validation.Valid,
+            errors: validation.Errors.length
+                ? validation.Errors.map((e) => ({ code: e.Code, message: e.Message, triggerIndex: e.TriggerIndex }))
+                : undefined,
+        };
+    }
+};
+WorkflowValidateServerOperation = __decorate([
+    RegisterClass(BaseRemotableOperation, 'Workflow.Validate')
+], WorkflowValidateServerOperation);
+export { WorkflowValidateServerOperation };
+/** Renders validation failures for a caller that wants one string. */
+export function FormatWorkflowErrors(errors) {
+    return FormatWorkflowValidationErrors(errors);
+}
+/** Prevents tree-shaking of the registered operation classes. */
+export function LoadWorkflowOperations() {
+    void WorkflowSaveServerOperation;
+    void WorkflowValidateServerOperation;
+}
+//# sourceMappingURL=WorkflowOperations.js.map

package/dist/operations/WorkflowOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkflowOperations.js","sourceRoot":"","sources":["../../src/operations/WorkflowOperations.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAA+B,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EACH,qBAAqB,EACrB,yBAAyB,GAI5B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACH,8BAA8B,EAC9B,oBAAoB,GAEvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAA4B,MAAM,qBAAqB,CAAC;AAEjF;;;;;;GAMG;AACH,SAAS,kBAAkB;IACvB,OAAO,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,cAAc;IAChD,6FAA6F;IAC7F,wEAAwE;IACxE,MAAkD,EAClD,qBAAqB,CACxB,CAAC;AACN,CAAC;AAED,mFAAmF;AAE5E,IAAM,2BAA2B,GAAjC,MAAM,2BAA4B,SAAQ,qBAAqB;IACxD,KAAK,CAAC,eAAe,CAC3B,KAAwB,EACxB,QAA2B,EAC3B,IAAc;QAEd,IAAI,CAAC,KAAK,EAAE,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAEtD,MAAM,IAAI,GAAiB,KAAK,CAAC,IAAI,CAAC;QACtC,MAAM,MAAM,GAAG,MAAM,IAAI,gBAAgB,CAAC,kBAAkB,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE;YAC1E,WAAW,EAAE,IAAI;YACjB,QAAQ,EAAE,QAAQ;SACrB,CAAC,CAAC;QAEH,OAAO;YACH,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,eAAe,EAAE,MAAM,CAAC,eAAe;YACvC,uFAAuF;YACvF,gFAAgF;YAChF,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;YAC1E,YAAY,EAAE,MAAM,CAAC,YAAY;SACpC,CAAC;IACN,CAAC;CACJ,CAAA;AAxBY,2BAA2B;IADvC,aAAa,CAAC,sBAAsB,EAAE,eAAe,CAAC;GAC1C,2BAA2B,CAwBvC;;AAED;;;;;;GAMG;AAEI,IAAM,+BAA+B,GAArC,MAAM,+BAAgC,SAAQ,yBAAyB;IAChE,KAAK,CAAC,eAAe,CAC3B,KAAwB,EACxB,SAA4B,EAC5B,KAAe;QAEf,IAAI,CAAC,KAAK,EAAE,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAEtD,MAAM,UAAU,GAAG,oBAAoB,CAAC,KAAK,CAAC,IAAoB,CAAC,CAAC;QACpE,OAAO;YACH,KAAK,EAAE,UAAU,CAAC,KAAK;YACvB,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM;gBAC5B,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC;gBACpG,CAAC,CAAC,SAAS;SAClB,CAAC;IACN,CAAC;CACJ,CAAA;AAhBY,+BAA+B;IAD3C,aAAa,CAAC,sBAAsB,EAAE,mBAAmB,CAAC;GAC9C,+BAA+B,CAgB3C;;AAED,sEAAsE;AACtE,MAAM,UAAU,oBAAoB,CAAC,MAAyD;IAC1F,OAAO,8BAA8B,CAAC,MAAM,CAAC,CAAC;AAClD,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,sBAAsB;IAClC,KAAK,2BAA2B,CAAC;IACjC,KAAK,+BAA+B,CAAC;AACzC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,214 @@
+/**
+ * @fileoverview Contracts for task-graph submission and durable execution.
+ * @module @memberjunction/task-graph
+ */
+import { IMetadataProvider, UserInfo } from '@memberjunction/core';
+/**
+ * Mints a fresh metadata/data provider.
+ *
+ * The dispatcher runs outside any HTTP request and executes tasks concurrently, so it must never
+ * share one provider — and therefore one transaction scope — across parallel work. Rather than
+ * import MJServer (which would invert the dependency: MJServer depends on this package, not the
+ * reverse), the host supplies a factory. MJServer's implementation wraps the same
+ * `createPerRequestProviders` machinery that already mints a provider per request over the shared
+ * connection pool, which is proven cheap at request scale.
+ *
+ * Contract: every call returns a provider safe to use on its own transaction scope. Callers are
+ * responsible for nothing beyond using it — pooling and lifetime are the host's concern.
+ */
+export type ProviderFactory = {
+    CreateProvider(): Promise<IMetadataProvider>;
+};
+/**
+ * Runs one agent for one task node.
+ *
+ * Abstracted rather than taking `AgentRunner` directly so the dispatcher can be unit-tested without
+ * standing up the agent framework, and so a host with a different execution strategy (a queue, a
+ * remote worker) can supply its own.
+ */
+export type TaskAgentRunner = {
+    RunAgentForTask(params: TaskAgentRunParams): Promise<TaskAgentRunResult>;
+};
+/** What happened to a task or a graph, as a closed set a consumer can branch on. */
+export type TaskGraphFrameKind = 
+/** A task was claimed by an instance and is about to run. */
+'TaskStarted'
+/** A task finished successfully. */
+ | 'TaskCompleted'
+/** A task failed. `ErrorMessage` says why. */
+ | 'TaskFailed'
+/** A task was blocked because a prerequisite failed or became unreachable. */
+ | 'TaskBlocked'
+/** A human task became actionable and is waiting on its assignee. */
+ | 'TaskAwaitingHuman'
+/** Every node has reached a terminal state; `Status` is the graph's rolled-up outcome. */
+ | 'GraphSettled';
+/**
+ * One thing that happened, addressed by the graph it happened in.
+ *
+ * **Addressed by `ParentTaskID`, deliberately not by session.** A durable graph outlives the tab
+ * that submitted it — it may be started by a schedule with no session at all, and a user who
+ * refreshes mid-run should still see the rest. Keying on the graph means "watch this workflow run"
+ * works for anyone permitted to read it, whenever they arrive.
+ *
+ * Frames are **semantic, not cache invalidations**: a consumer renders "step 3 of 7 running" from
+ * the frame itself rather than re-reading rows and diffing them to guess what changed.
+ */
+export type TaskGraphFrame = {
+    Kind: TaskGraphFrameKind;
+    /** The graph this happened in — the subscription key. */
+    ParentTaskID: string;
+    /**
+     * Who the graph belongs to, from the parent's durable metadata.
+     *
+     * Carried on the frame rather than looked up by the consumer because a consumer's delivery
+     * filter runs per frame and synchronously — a database round trip there would make watching a
+     * run cost more than running it. Absent means the graph predates ownership being recorded, and
+     * a consumer that authorizes on it should fail closed rather than broadcast.
+     */
+    OwnerUserID?: string | null;
+    /** The node it happened to. Absent on `GraphSettled`, which is about the graph itself. */
+    TaskID?: string;
+    /** Node name, so a consumer can label the frame without loading the row. */
+    TaskName?: string;
+    /** The task's (or, for `GraphSettled`, the graph's) status after the event. */
+    Status?: string;
+    /** Failure detail on `TaskFailed`. */
+    ErrorMessage?: string;
+    /** For a human task, who it is waiting on. */
+    AssignedUserID?: string;
+    /** How many nodes have reached a terminal state, and out of how many. */
+    CompletedCount?: number;
+    TotalCount?: number;
+};
+/**
+ * Receives dispatcher lifecycle frames.
+ *
+ * Optional, and a host that supplies none loses nothing but visibility — the dispatcher's behavior
+ * is identical either way. Abstracted for the same reason execution and continuation are: publishing
+ * to subscribers is a transport concern, and this package must not acquire a dependency on the
+ * transport layer to gain observability.
+ *
+ * Implementations MUST NOT throw and MUST NOT block: a frame is an announcement about work, never a
+ * step of it, so a broken observer must not be able to stall or fail a graph.
+ */
+export type TaskGraphObserver = {
+    OnFrame(frame: TaskGraphFrame): void;
+};
+/** Everything an executor needs to run a single task node. */
+export type TaskAgentRunParams = {
+    /** The task row being executed. */
+    TaskID: string;
+    /** Agent assigned to the task. */
+    AgentID: string;
+    /** Parsed `Task.InputPayload`, if any. */
+    InputPayload: unknown;
+    /** Parsed `OutputPayload` of each completed dependency, keyed by that task's ID. */
+    DependencyOutputs: Map<string, unknown>;
+    /** Provider minted for this task alone — never shared with a sibling. */
+    Provider: IMetadataProvider;
+    /** User the work runs as. */
+    ContextUser: UserInfo;
+};
+/** Outcome of running one task node. */
+export type TaskAgentRunResult = {
+    Success: boolean;
+    /** Structured output to persist to `Task.OutputPayload`. */
+    Output?: unknown;
+    /** Failure detail to persist to `Task.ErrorMessage`. */
+    ErrorMessage?: string;
+    /** The `MJ: AI Agent Runs` row that executed this task, for `Task.AgentRunID`. */
+    AgentRunID?: string;
+};
+/**
+ * Delivers a finished graph's outcome, per its `continuation` mode.
+ *
+ * Abstracted for the same reason agent execution is: the dispatcher knows *when* a graph has
+ * settled and *what* it produced, but posting into a conversation and starting a fresh agent turn
+ * are host concerns. Injecting them keeps this package free of both the conversation layer and the
+ * agent framework — a dependency on the latter would be circular, since agents submit graphs.
+ *
+ * A host that implements neither still gets correct behavior: the dispatcher logs the outcome and
+ * marks it delivered, so a graph never silently repeats its completion.
+ */
+export type TaskContinuationDeliverer = {
+    /** Posts the results into the conversation the graph answers. */
+    PostMessage(params: TaskContinuationParams): Promise<void>;
+    /**
+     * Starts the submitting agent a fresh turn carrying the outcome.
+     *
+     * Optional: a host with no agent framework loaded (a worker, a test) legitimately cannot do
+     * this, and the dispatcher degrades to `PostMessage` rather than dropping the completion.
+     */
+    Reinvoke?(params: TaskContinuationParams): Promise<void>;
+};
+/** Everything a continuation needs to say what happened. */
+export type TaskContinuationParams = {
+    ParentTaskID: string;
+    WorkflowName: string;
+    /** Conversation the graph answers, when it came from a conversational channel. */
+    ConversationDetailID: string | null;
+    /** The agent run that emitted the graph — the target of a `reinvoke`. */
+    SubmittedByAgentRunID: string | null;
+    /** How many continuation hops preceded this one, so a re-submitted graph can carry depth + 1. */
+    ReinvokeDepth: number;
+    /**
+     * Per-task outcome. Deliberately carries a `summary` and an `outputRef`, not inline payloads —
+     * a ten-task graph's full outputs would swamp the continuation turn's context window, and the
+     * agent can pull what it actually needs by task ID.
+     */
+    Tasks: Array<{
+        TaskID: string;
+        Name: string;
+        Status: string;
+        Summary?: string;
+        ErrorMessage?: string;
+    }>;
+    /** One-line human-readable roll-up. */
+    Summary: string;
+};
+/** Tuning knobs for the durable dispatcher. */
+export type TaskGraphDispatcherConfig = {
+    /**
+     * Identifies this dispatcher instance in `Task.ClaimedBy`. Must be stable for the process
+     * lifetime and distinct per instance — it is what lets reconciliation tell "my orphaned work"
+     * from "another instance's live work".
+     */
+    InstanceID: string;
+    /**
+     * How long a claim is honored before reconciliation may reclaim the task.
+     *
+     * Generous by default: the cost of a too-short TTL is a *duplicate execution* (a healthy but
+     * slow task gets reclaimed while still running), whereas the cost of a too-long TTL is merely
+     * delayed recovery after a crash. Long-running tasks extend it by heartbeat, so the TTL only
+     * has to exceed the heartbeat interval by a comfortable margin.
+     */
+    ClaimTTLSeconds: number;
+    /** How often an in-flight task extends its own claim. Must be well below `ClaimTTLSeconds`. */
+    HeartbeatIntervalSeconds: number;
+    /** Maximum tasks executed concurrently by this instance. */
+    MaxConcurrentTasks: number;
+    /**
+     * How often to look for claimable work.
+     *
+     * Five seconds is the right production default — a graph's steps are agent runs measured in
+     * seconds to minutes, so polling faster buys latency nobody perceives and costs a query per
+     * instance per tick. It is configurable rather than fixed because the correct value genuinely
+     * differs by host: a test harness driving a graph to completion should not wait five seconds per
+     * node, and a deployment running many short tasks may want tighter latency.
+     */
+    PollIntervalSeconds: number;
+    /** How often the reconciliation sweep runs. */
+    ReconciliationIntervalSeconds: number;
+};
+/** Defaults chosen so a heartbeat has several chances to land before a claim lapses. */
+export declare const DEFAULT_DISPATCHER_CONFIG: Omit<TaskGraphDispatcherConfig, 'InstanceID'>;
+/** Why a reconciliation sweep touched a task — logged loudly, never silently corrected. */
+export type ReconciliationAction = 'ExpiredClaimReleased' | 'OrphanedInProgressReleased' | 'StaleClaimCleared';
+/** One normalization the sweep performed. */
+export type ReconciliationEvent = {
+    TaskID: string;
+    Action: ReconciliationAction;
+    Detail: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,9 @@
+/** Defaults chosen so a heartbeat has several chances to land before a claim lapses. */
+export const DEFAULT_DISPATCHER_CONFIG = {
+    ClaimTTLSeconds: 300,
+    HeartbeatIntervalSeconds: 60,
+    MaxConcurrentTasks: 5,
+    PollIntervalSeconds: 5,
+    ReconciliationIntervalSeconds: 120,
+};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AA2NA,wFAAwF;AACxF,MAAM,CAAC,MAAM,yBAAyB,GAAkD;IACpF,eAAe,EAAE,GAAG;IACpB,wBAAwB,EAAE,EAAE;IAC5B,kBAAkB,EAAE,CAAC;IACrB,mBAAmB,EAAE,CAAC;IACtB,6BAA6B,EAAE,GAAG;CACrC,CAAC"}

package/package.json

@@ -1,10 +1,35 @@
 {
   "name": "@memberjunction/task-graph",
-  "version": "0.0.0",
-  "description": "OIDC trusted publishing setup package for @memberjunction/task-graph",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "type": "module",
+  "version": "6.1.0-edge.1",
+  "description": "MemberJunction: Task Graph - producer-agnostic submission and durable execution of dependency-ordered task graphs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "author": "MemberJunction.com",
+  "license": "ISC",
+  "dependencies": {
+    "@memberjunction/ai-agents": "6.1.0-edge.1",
+    "@memberjunction/ai-core-plus": "6.1.0-edge.1",
+    "@memberjunction/core": "6.1.0-edge.1",
+    "@memberjunction/core-entities": "6.1.0-edge.1",
+    "@memberjunction/global": "6.1.0-edge.1",
+    "@memberjunction/notifications": "6.1.0-edge.1"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.11",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MemberJunction/MJ"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias -f",
+    "watch": "tsc --watch",
+    "test": "vitest run"
+  }
+}