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

package/dist/TaskGraphService.d.ts

@@ -17,7 +17,19 @@
  */
 import { IMetadataProvider, UserInfo } from '@memberjunction/core';
 import { type MJTaskEntity_ITaskStepConfiguration } from '@memberjunction/core-entities';
-import { type TaskGraphSpec, type TaskGraphSpecNode, type ForEachOperation, type WhileOperation } from '@memberjunction/ai-core-plus';
+import { type TaskGraphInvocationEnvelope, type TaskGraphSpec, type TaskGraphSpecNode, type ForEachOperation, type WhileOperation } from '@memberjunction/ai-core-plus';
+import { type EdgeOverrideVerdict, type StepTarget, type TaskGraphDebugState } from './debug-state.js';
+/**
+ * Normalizes a caller-supplied reinvoke depth to a safe cap seed.
+ *
+ * The runaway-loop cap is a signed comparison over a persisted-verbatim seed, and the remote Submit
+ * operation is the one seam where the seed is caller-supplied rather than computed by the engine —
+ * a negative value would BUY hops (`-1000` turns a 5-hop cap into 1005). Clamped rather than
+ * refused so a stale client sending zero-adjacent noise keeps working, and no accepted value can
+ * ever weaken the cap. Exported pure because a boundary rule that cannot be tested directly is a
+ * boundary nobody will notice moving.
+ */
+export declare function ClampReinvokeDepth(value: unknown): number | undefined;
 /** Context a submission carries beyond the graph itself. */
 export type TaskGraphSubmitContext = {
     /** Environment the tasks belong to. */
@@ -35,6 +47,16 @@ export type TaskGraphSubmitContext = {
      * re-invoked by a finished graph carries its parent's depth + 1.
      */
     ReinvokeDepth?: number;
+    /**
+     * The invocation's runtime parameters, for the flow dialect's `data`/`context` roots (R3-3).
+     * Persisted on the parent because the instance evaluating a condition is routinely not the
+     * process that accepted the graph.
+     */
+    Invocation?: TaskGraphInvocationEnvelope;
+    /** Seed `$.debug` on the parent at insert. See `TaskGraphStartDebug`. */
+    Debug?: {
+        paused?: boolean;
+    };
 };
 /**
  * What the parent Task row remembers about the graph beyond its tasks.
@@ -75,6 +97,36 @@ export type TaskGraphParentMetadata = {
      * racing the same completion produce one winner rather than two notifications.
      */
     continuationDeliveredAt?: string;
+    /**
+     * HOW it was delivered — written by the same compare-and-swap that sets the timestamp.
+     *
+     * `'expired'` means the settlement was found after its delivery window, so the run and its cost
+     * were corrected but nothing was announced: posting a week-old "your workflow finished" into a
+     * live conversation, or starting a fresh billed turn for it, is worse than staying quiet. The
+     * distinction has to survive in the row, or an expired settlement is indistinguishable from a
+     * delivered one the moment anybody looks afterwards.
+     */
+    continuationDeliveredAs?: 'delivered' | 'expired' | 'cancelled';
+    /**
+     * Set, once and durably, when a step declares the workflow finished before its remaining steps.
+     *
+     * Read by `loadGraphState` so every instance's claim filter knows the remaining steps are about
+     * to be skipped. Without it the decision lives only in the deciding instance's memory, and a
+     * concurrent poll — including that same instance's, since task execution is not awaited — can
+     * claim and start a step the early finish is in the middle of skipping.
+     */
+    earlyFinishedAt?: string;
+    /**
+     * The invocation's `data` and `context`, as the flow dialect's roots of the same names (R3-3).
+     *
+     * Absent for a graph submitted without them, in which case those roots resolve to the same
+     * empty-but-readable value any absent data does — a condition on them reads false rather than
+     * throwing, exactly as the walker's would on a missing key.
+     */
+    invocation?: {
+        data?: unknown;
+        context?: unknown;
+    };
 };
 /**
  * Continuation chains are bounded separately from graph nesting.
@@ -98,6 +150,33 @@ export declare const MAX_REINVOKE_DEPTH = 5;
  * graph wanted" is still to tell the user their work finished.
  */
 export declare function ParseTaskGraphParentMetadata(raw: string | null | undefined): TaskGraphParentMetadata;
+/**
+ * The JSON bag `persistParent` writes. Exported so start-paused is testable without a database —
+ * Pause-after-submit races the first dispatcher poll, so this bag is the only place `paused: true`
+ * is guaranteed to land before anyone claims.
+ */
+export declare function BuildTaskGraphParentInputPayload(args: {
+    continuation: TaskGraphParentMetadata['continuation'];
+    reinvokeDepth: number;
+    failureSemantics: NonNullable<TaskGraphParentMetadata['failureSemantics']>;
+    submittedByAgentRunID: string | null;
+    submittedByUserID: string | null;
+    invocation?: {
+        data?: unknown;
+        context?: unknown;
+    } | null;
+    startPaused?: boolean;
+}): Record<string, unknown>;
+/** What a cancellation actually managed to do. */
+export type TaskGraphCancelResult = {
+    /** False when anything the caller asked to stop is still running. */
+    Success: boolean;
+    /** True only when every non-terminal task in the graph — and its descendants — is Cancelled. */
+    Cancelled: boolean;
+    /** Named so the caller can say which parts of the workflow are still going. */
+    UncancelledTaskNames: string[];
+    ErrorMessage?: string;
+};
 /** True when a continuation chain has gone as far as it may. */
 export declare function IsReinvokeCapReached(meta: TaskGraphParentMetadata): boolean;
 export type TaskGraphSubmitResult = {
@@ -108,6 +187,8 @@ export type TaskGraphSubmitResult = {
     TaskIDMap?: Map<string, string>;
     ErrorMessage?: string;
 };
+/** Name of the task type used for agent-orchestrated graphs. */
+export declare const TASK_TYPE_NAME = "AI Workflow";
 /**
  * Reports the node kinds this dispatcher cannot execute, or `null` when the graph is fully runnable.
  *
@@ -162,6 +243,14 @@ export declare function FindUnrunnableKinds(spec: TaskGraphSpec): string | null;
  */
 export declare function FindCrossUserAssignments(spec: TaskGraphSpec, submitterUserID: string): string | null;
 export declare class TaskGraphService {
+    /**
+     * Guarded single-statement writes, shared with the dispatcher.
+     *
+     * The instance id is descriptive only — this service never CLAIMS anything, it only issues
+     * guarded transitions whose predicates are about the row's own status rather than about who
+     * holds it.
+     */
+    private readonly claims;
     /**
      * Validates and persists a task graph, returning as soon as it is durable.
      *
@@ -172,13 +261,44 @@ export declare class TaskGraphService {
      */
     Submit(spec: TaskGraphSpec, context: TaskGraphSubmitContext): Promise<TaskGraphSubmitResult>;
     /**
-     * Cancels a graph and everything in it that has not already settled.
+     * Cancels a graph, everything in it that has not already settled, and everything it started.
      *
      * Cancels children first: a parent marked `Cancelled` while children are still `Pending` would
      * leave the dispatcher free to pick those children up, which is the opposite of what the caller
      * asked for.
+     *
+     * **The verdict is the outcome, not the attempt** (R2-9). This returned `true` unconditionally
+     * while logging each child that failed to cancel — so one failed save left that child `Pending`,
+     * told the caller cancellation had succeeded, and let the dispatcher run the child afterwards.
+     * The graph could then settle `Complete` and ANNOUNCE ITS COMPLETION into the conversation of a
+     * workflow the user had cancelled. A partial cancel now says so and names what survived; the
+     * graph stays active, so retrying is meaningful rather than cosmetic.
+     */
+    Cancel(parentTaskID: string, context: TaskGraphSubmitContext): Promise<TaskGraphCancelResult>;
+    /**
+     * `Cancel`, carrying the recursion state the public entry point does not expose.
+     *
+     * **The depth cap was dead code** (R3-10): `Cancel` passed a literal 0, and the recursion
+     * re-entered through `this.Cancel`, which restarted at 0 — so the check could never fire and
+     * the "bounded by the reinvoke depth cap" promise was false. A hand-edited `AgentRunID` cycle
+     * recursed to stack overflow mid-cancel.
+     *
+     * The visited set is cheap armour on top: the cap bounds how DEEP a legitimate chain goes, and
+     * a cycle is not deep, it is circular. Arithmetic alone would eventually stop it; a visited set
+     * stops it immediately and covers linkage shapes the arithmetic does not anticipate.
+     */
+    private cancelWithDepth;
+    /**
+     * Cancels the graphs that this graph's own steps submitted, one level at a time.
+     *
+     * The linkage is `child task → AgentRunID → the graphs that run submitted`, which is exactly how
+     * the continuation chain finds its way back up; walking it downward is the same relation read the
+     * other way. Depth-capped by the same constant that caps reinvocation, so a self-referencing
+     * workflow cannot make cancellation recurse further than it could have spawned.
+     *
+     * @returns names of tasks in descendant graphs that could not be cancelled
      */
-    Cancel(parentTaskID: string, context: TaskGraphSubmitContext): Promise<boolean>;
+    private cancelNestedGraphs;
     /**
      * Closes the still-open requests raised for a set of tasks.
      *
@@ -199,7 +319,114 @@ export declare class TaskGraphService {
      * leaving them blocked would make the retry pointless, as the graph still could not progress
      * past this node.
      */
-    Retry(taskID: string, context: TaskGraphSubmitContext): Promise<boolean>;
+    Retry(taskID: string, context: TaskGraphSubmitContext, inputPayload?: unknown): Promise<boolean>;
+    /**
+     * Store for the guarded JSON_MODIFY writes. The instance identity and TTL are claim-protocol
+     * concerns this class never exercises — the debug writes are instance-free.
+     */
+    private readonly debugWrites;
+    /** Result shape shared by the control verbs: what happened, and the state that now holds. */
+    private controlResult;
+    /**
+     * Loads a graph parent and proves it IS a workflow graph before any debug write.
+     *
+     * Read with `BypassCache` for the same reason the dispatcher reads rows that way: the debug bag
+     * is written by direct `JSON_MODIFY` statements that fire no cache invalidation, so a cached
+     * read here could merge new state over a stale copy and silently resurrect a cleared flag.
+     */
+    private loadWorkflowParent;
+    /**
+     * Writes the debug-bag fields a verb OWNS, and reports the state that results.
+     *
+     * Field-scoped on purpose — see {@link TaskClaimStore.TryWriteDebugFields}. A verb declares the
+     * paths it is responsible for; everything else in the bag is left exactly as the database has
+     * it, so a concurrent step-consume, breakpoint edit, or override cannot be undone by a verb that
+     * was not talking about them.
+     *
+     * The returned state is this instance's best view (read + the fields just written) and is
+     * advisory — the same posture the console takes toward frames.
+     */
+    private writeDebugFields;
+    /**
+     * Pauses a graph: nothing new is claimed until it is resumed. In-flight steps finish naturally
+     * and their completions land — a pause gates claiming and never touches a live claim, which is
+     * why there is no "what happens to the claim" question to answer.
+     */
+    PauseGraph(parentTaskID: string, context: TaskGraphSubmitContext, pausedByUserID?: string | null): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /** Resumes a paused graph. Breakpoints and edge overrides survive — only the pause clears. */
+    ResumeGraph(parentTaskID: string, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Arms a one-shot step allowance on a paused graph: `'one'` releases the next eligible task,
+     * `'wave'` releases the current frontier, a task ID releases exactly that task. The dispatcher
+     * consumes the allowance CAS-style, so two instances stepping the same graph release work once.
+     */
+    StepGraph(parentTaskID: string, target: StepTarget, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Replaces the graph's breakpoint set. Every ID must name a child of this graph — a breakpoint
+     * on a task in some other graph would gate nothing and silently lie to the person who set it.
+     */
+    SetBreakpoints(parentTaskID: string, taskIDs: string[], context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Overrides one edge's condition verdict — the operator's answer for a path the engine cannot
+     * decide (a held graph) or decided wrongly (a broken guard). `'false'` reads as "branch not
+     * taken" and cascades skips; `'true'` opens the gate; `null` removes the override.
+     */
+    SetEdgeOverride(parentTaskID: string, edgeID: string, verdict: EdgeOverrideVerdict | null, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Declares a Pending step not-taken. Downstream dependents proceed — `Skipped` satisfies a
+     * prerequisite — and any open human request for the step is withdrawn so nobody keeps seeing an
+     * ask for work the operator decided against.
+     */
+    SkipTask(taskID: string, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Marks a step Complete with an operator-supplied output.
+     *
+     * Human steps are refused here on purpose: they already have a first-class completion path
+     * (`TaskGraph.CompleteTask`) with the assignee/elevation check, and this verb must not become
+     * the door that bypasses it.
+     */
+    ForceCompleteTask(taskID: string, outputPayload: unknown, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Replaces a Pending step's input — the "edit the brief before stepping" move at a breakpoint.
+     * Applies to this run only; the step must not have started.
+     *
+     * **A guarded statement, not load-check-save.** The in-memory `Status === 'Pending'` check plus
+     * `task.Save()` is an unconditional full-row UPDATE: a task claimed in the window between the
+     * load and the save has its claim columns reverted to the pre-claim snapshot *while its body
+     * runs*, and a second instance then claims it again — the step executes twice. See
+     * {@link TaskClaimStore.TryUpdateInputPayload}, which makes the check and the write one atomic
+     * operation whose rowcount is the answer.
+     */
+    UpdateTaskInput(taskID: string, inputPayload: unknown, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        ErrorMessage?: string;
+    }>;
     /** Maps every referenced agent name to its ID, or reports all unresolvable names at once. */
     private resolveAgents;
     /**
@@ -217,8 +444,31 @@ export declare class TaskGraphService {
      */
     private resolvePrompts;
     private resolveActions;
-    /** Finds or creates the task type used for orchestrated graphs. */
+    /**
+     * Finds or creates the task type used for orchestrated graphs — exactly one of it, ever.
+     *
+     * **This resolves the engine's discriminator, not a label** (R2-7). Round 1 scoped every sweep
+     * arm and both payload-writing guards to this type, so a second row sharing the name lets
+     * different processes bind different IDs — and a graph stamped with the other one is invisible
+     * to the sweep, never claimed, never settled, its submitting run `Paused` forever, with no
+     * error anywhere.
+     *
+     * Race-safe by INSERT-then-reselect rather than by checking harder. Two concurrent first-ever
+     * submissions both read "not there" and both insert; the unique index added in this round makes
+     * the loser's insert fail, and the loser then re-reads and finds the winner's row. Checking
+     * first is what created the window, so the fix cannot be a better check.
+     */
     private ensureTaskType;
+    /**
+     * The `AI Workflow` task type's ID, resolved deterministically.
+     *
+     * `ORDER BY` is not decoration: two rows sharing the name come back in whatever order the engine
+     * chooses, so an unordered `MaxRows: 1` lets two processes bind different IDs from the same
+     * data. The index this round adds makes duplicates impossible going forward; the ordering makes
+     * the resolution deterministic on a database that still has some, and the warning makes the
+     * situation visible rather than merely survivable.
+     */
+    private findTaskTypeID;
     /** Writes the parent task that represents the graph as a whole. */
     private persistParent;
     /** Writes each child task, returning the tempId -> real ID mapping edges will need. */

package/dist/TaskGraphService.d.ts.map

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