task-manager-logic 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-manager-logic",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "private": false,
   "description": "Runtime-first TaskSpace transition processors and backend-neutral in-memory owner",
   "type": "module",

package/src/completionGraph.ts

@@ -0,0 +1,88 @@
+import type { TaskId, TaskSpaceDefinition } from 'task-manager-contract';
+
+export interface TaskCompletionGraph {
+  readonly predecessorIdsByTask: ReadonlyMap<TaskId, readonly TaskId[]>;
+  readonly authoritySuccessorIdsByTask: ReadonlyMap<TaskId, readonly TaskId[]>;
+}
+
+/**
+ * Builds the one completion graph used by admission and runtime readiness.
+ * Authority edges additionally include child -> parent containment because a
+ * group cannot complete before its descendants.
+ */
+export function buildTaskCompletionGraph(definition: TaskSpaceDefinition): TaskCompletionGraph {
+  const taskById = new Map(definition.tasks.map((task) => [task.taskId, task]));
+  const childrenByParent = new Map<TaskId, { readonly taskId: TaskId; readonly order: number }[]>();
+  for (const relation of definition.relations) {
+    if (relation.kind !== 'parent-child' || relation.parentTaskId === null) continue;
+    const children = childrenByParent.get(relation.parentTaskId) ?? [];
+    children.push({ taskId: relation.childTaskId, order: relation.order });
+    childrenByParent.set(relation.parentTaskId, children);
+  }
+  for (const children of childrenByParent.values()) {
+    children.sort((left, right) => left.order - right.order || left.taskId.localeCompare(right.taskId));
+  }
+
+  const descendantsByTask = new Map<TaskId, readonly TaskId[]>();
+  const descendants = (taskId: TaskId): readonly TaskId[] => {
+    const cached = descendantsByTask.get(taskId);
+    if (cached) return cached;
+    const result = (childrenByParent.get(taskId) ?? [])
+      .flatMap((child) => [child.taskId, ...descendants(child.taskId)]);
+    descendantsByTask.set(taskId, result);
+    return result;
+  };
+
+  const runtimeSuccessors = new Map<TaskId, Set<TaskId>>();
+  const addRuntimeEdge = (predecessor: TaskId, successor: TaskId): void => {
+    const successors = runtimeSuccessors.get(predecessor) ?? new Set<TaskId>();
+    successors.add(successor);
+    runtimeSuccessors.set(predecessor, successors);
+  };
+  for (const relation of definition.relations) {
+    if (relation.kind !== 'dependency') continue;
+    addRuntimeEdge(relation.predecessorTaskId, relation.successorTaskId);
+    if (taskById.get(relation.successorTaskId)?.kind === 'task-group') {
+      for (const descendant of descendants(relation.successorTaskId)) {
+        addRuntimeEdge(relation.predecessorTaskId, descendant);
+      }
+    }
+  }
+  for (const group of definition.tasks) {
+    if (group.kind !== 'task-group' || group.mode !== 'sequential') continue;
+    const children = childrenByParent.get(group.taskId) ?? [];
+    for (let index = 1; index < children.length; index += 1) {
+      const predecessor = children[index - 1]!.taskId;
+      const successor = children[index]!.taskId;
+      addRuntimeEdge(predecessor, successor);
+      for (const descendant of descendants(successor)) addRuntimeEdge(predecessor, descendant);
+    }
+  }
+
+  const predecessorSets = new Map<TaskId, Set<TaskId>>();
+  for (const [predecessor, successors] of runtimeSuccessors) {
+    for (const successor of successors) {
+      const predecessors = predecessorSets.get(successor) ?? new Set<TaskId>();
+      predecessors.add(predecessor);
+      predecessorSets.set(successor, predecessors);
+    }
+  }
+  const authoritySuccessors = new Map<TaskId, Set<TaskId>>(
+    [...runtimeSuccessors].map(([taskId, successors]) => [taskId, new Set(successors)]),
+  );
+  for (const [parent, children] of childrenByParent) {
+    for (const child of children) {
+      const successors = authoritySuccessors.get(child.taskId) ?? new Set<TaskId>();
+      successors.add(parent);
+      authoritySuccessors.set(child.taskId, successors);
+    }
+  }
+  return {
+    predecessorIdsByTask: new Map(
+      [...predecessorSets].map(([taskId, predecessors]) => [taskId, [...predecessors]]),
+    ),
+    authoritySuccessorIdsByTask: new Map(
+      [...authoritySuccessors].map(([taskId, successors]) => [taskId, [...successors]]),
+    ),
+  };
+}

package/src/memory-owner.ts

@@ -52,10 +52,11 @@ export class InMemoryTaskSpaceOwner implements TaskSpaceOwnerPort {
 
   async compareAndSwap(commit: TaskSpaceCommit): Promise<TaskSpaceCommitResult> {
     commit = deepImmutableClone(commit);
+    const submittedCommandDigest = validateSubmittedCommand(commit);
     const current = this.#spaces.get(commit.taskSpaceId);
     const replay = current?.receiptsByCommand.get(commit.commandId);
     if (current && replay) {
-      if (replay.commandDigest !== commit.commandDigest) {
+      if (replay.commandDigest !== submittedCommandDigest) {
         throw new TaskManagerError('command-receipt-mismatch', `command ${commit.commandId} digest does not match prior admission`);
       }
       return deepImmutableClone({
@@ -105,6 +106,22 @@ export class InMemoryTaskSpaceOwner implements TaskSpaceOwnerPort {
   }
 }
 
+function validateSubmittedCommand(commit: TaskSpaceCommit): `sha256:${string}` {
+  if (commit.kind !== 'task-space-commit'
+    || commit.command.commandId !== commit.commandId
+    || commit.command.taskSpaceId !== commit.taskSpaceId) {
+    throw new TaskManagerError('command-receipt-mismatch', 'submitted command identity does not match its CAS envelope');
+  }
+  const commandDigest = canonicalOwnDataDigest(commit.command);
+  if (commandDigest !== commit.commandDigest) {
+    throw new TaskManagerError(
+      'command-receipt-mismatch',
+      `command ${commit.commandId} digest does not match the submitted canonical command`,
+    );
+  }
+  return commandDigest;
+}
+
 function validateCommit(
   commit: TaskSpaceCommit,
   current: MemoryTaskSpaceState | undefined,

package/src/processors.ts

@@ -31,6 +31,7 @@ import type {
   WaitTaskCommand,
 } from 'task-manager-contract';
 import { canonicalOwnDataDigest } from 'task-manager-contract';
+import { buildTaskCompletionGraph, type TaskCompletionGraph } from './completionGraph.js';
 import { TaskManagerError } from './errors.js';
 import { assertTaskTransition, isTerminal } from './statusMachine.js';
 import {
@@ -40,7 +41,6 @@ import {
   assertArtifactRef,
   deepImmutableClone,
   normalizeTaskProcessorConfig,
-  predecessorIds,
   taskRecordById,
   validateTaskSpaceDefinition,
   validateTimestamp,
@@ -144,10 +144,16 @@ export async function patchTaskSpace<Profile extends TaskProfileEnvelope>(
       ...(patch.description === undefined ? {} : { description: patch.description }),
     };
   } else {
-    const hasArtifact = current.definition.inputArtifacts.some(({ digest }) => digest === patch.artifact.digest);
+    const priorArtifact = current.definition.inputArtifacts.find(({ digest }) => digest === patch.artifact.digest);
+    if (priorArtifact && canonicalOwnDataDigest(priorArtifact) !== canonicalOwnDataDigest(patch.artifact)) {
+      throw new TaskManagerError(
+        'artifact-conflict',
+        `artifact ${patch.artifact.digest} conflicts with the attached reference`,
+      );
+    }
     nextDefinition = {
       ...current.definition,
-      inputArtifacts: hasArtifact
+      inputArtifacts: priorArtifact
         ? current.definition.inputArtifacts
         : [...current.definition.inputArtifacts, patch.artifact],
     };
@@ -518,9 +524,10 @@ export async function replanTask(
       updatedAt: input.replannedAt,
     };
   });
+  const completionGraph = buildTaskCompletionGraph(definition);
   const nextTasks: TaskRecord[] = provisional.map((task) => {
     if (isTerminal(task.status) || task.activeClaim || task.status === 'Running' || task.status === 'Waiting') return task;
-    const status: TaskStatus = dependenciesSucceeded(definition, provisional, task.taskId) ? 'Ready' : 'Pending';
+    const status: TaskStatus = dependenciesSucceeded(completionGraph, provisional, task.taskId) ? 'Ready' : 'Pending';
     return { ...task, status };
   });
   const affectedTaskIds = [...new Set([...snapshot.tasks.map(({ taskId }) => taskId), ...nextTasks.map(({ taskId }) => taskId)])].sort();
@@ -708,11 +715,11 @@ function replaceTask(snapshot: TaskSpaceSnapshot, replacement: TaskRecord): Task
 }
 
 function dependenciesSucceeded(
-  definition: TaskSpaceDefinition,
+  completionGraph: TaskCompletionGraph,
   tasks: readonly TaskRecord[],
   taskId: TaskId,
 ): boolean {
-  const predecessors = effectivePredecessorIds(definition, taskId);
+  const predecessors = completionGraph.predecessorIdsByTask.get(taskId) ?? [];
   return predecessors.length === 0 || predecessors.every((predecessorId) =>
     tasks.find((task) => task.taskId === predecessorId)?.status === 'Succeeded');
 }
@@ -831,41 +838,12 @@ async function assertArtifactAuthority(
   }
 }
 
-function effectivePredecessorIds(definition: TaskSpaceDefinition, taskId: TaskId): readonly TaskId[] {
-  const result = new Set(predecessorIds(definition, taskId));
-  const parentByChild = new Map<TaskId, TaskId | null>();
-  const childrenByParent = new Map<TaskId, { readonly taskId: TaskId; readonly order: number }[]>();
-  for (const relation of definition.relations) {
-    if (relation.kind !== 'parent-child') continue;
-    parentByChild.set(relation.childTaskId, relation.parentTaskId);
-    if (relation.parentTaskId !== null) {
-      const children = childrenByParent.get(relation.parentTaskId) ?? [];
-      children.push({ taskId: relation.childTaskId, order: relation.order });
-      childrenByParent.set(relation.parentTaskId, children);
-    }
-  }
-  let current: TaskId | null | undefined = taskId;
-  while (current !== null && current !== undefined) {
-    const parent = parentByChild.get(current);
-    if (parent === null || parent === undefined) break;
-    for (const predecessor of predecessorIds(definition, parent)) result.add(predecessor);
-    const parentDefinition = definition.tasks.find(({ taskId: candidate }) => candidate === parent);
-    if (parentDefinition?.kind === 'task-group' && parentDefinition.mode === 'sequential') {
-      const siblings = [...(childrenByParent.get(parent) ?? [])]
-        .sort((left, right) => left.order - right.order || left.taskId.localeCompare(right.taskId));
-      const index = siblings.findIndex(({ taskId: candidate }) => candidate === current);
-      if (index > 0) result.add(siblings[index - 1]!.taskId);
-    }
-    current = parent;
-  }
-  return [...result];
-}
-
 function stabilizeTaskProjection(
   definition: TaskSpaceDefinition,
   inputTasks: readonly TaskRecord[],
   projectedAt?: TaskTimestamp,
 ): TaskRecord[] {
+  const completionGraph = buildTaskCompletionGraph(definition);
   let tasks = inputTasks.map((task) => ({ ...task }));
   const childrenByParent = new Map<TaskId, TaskId[]>();
   for (const relation of definition.relations) {
@@ -880,13 +858,13 @@ function stabilizeTaskProjection(
       let status = task.status;
       if (task.definition.kind === 'task') {
         if (status === 'Pending' || status === 'Ready') {
-          status = dependenciesSucceeded(definition, tasks, task.taskId) ? 'Ready' : 'Pending';
+          status = dependenciesSucceeded(completionGraph, tasks, task.taskId) ? 'Ready' : 'Pending';
         }
       } else {
         const childStatuses = (childrenByParent.get(task.taskId) ?? [])
           .map((childId) => tasks.find(({ taskId }) => taskId === childId)!.status);
         status = projectGroupStatus(task.definition.mode, childStatuses,
-          dependenciesSucceeded(definition, tasks, task.taskId));
+          dependenciesSucceeded(completionGraph, tasks, task.taskId));
         if (isTerminal(task.status) && status !== task.status) {
           throw new TaskManagerError('terminal-task-immutable', `task-group ${task.taskId} is terminal (${task.status})`);
         }

package/src/statusMachine.ts

@@ -12,18 +12,18 @@ export const TASK_TRANSITIONS: Readonly<Record<TaskStatus, readonly TaskStatus[]
   Cancelled: Object.freeze([] as const),
 });
 
-export const TERMINAL_STATUSES: ReadonlySet<TaskStatus> = new Set<TaskStatus>([
+const TERMINAL_STATUSES = Object.freeze([
   'Succeeded',
   'Failed',
   'Cancelled',
-]);
+] as const);
 
 export function canTransition(from: TaskStatus, to: TaskStatus): boolean {
   return TASK_TRANSITIONS[from].includes(to);
 }
 
 export function isTerminal(status: TaskStatus): status is Extract<TaskStatus, 'Succeeded' | 'Failed' | 'Cancelled'> {
-  return TERMINAL_STATUSES.has(status);
+  return (TERMINAL_STATUSES as readonly TaskStatus[]).includes(status);
 }
 
 export function assertTaskTransition(taskId: string, from: TaskStatus, to: TaskStatus): void {

package/src/validation.ts

@@ -7,12 +7,12 @@ import type {
   TaskNodeDefinition,
   TaskProfileEnvelope,
   TaskRecord,
-  TaskRelation,
   TaskSpaceDefinition,
   TaskSpaceSnapshot,
   TaskTimestamp,
 } from 'task-manager-contract';
 import { deepFrozenCanonicalOwnDataClone, sha256Hex } from 'task-manager-contract';
+import { buildTaskCompletionGraph } from './completionGraph.js';
 import { TaskManagerError } from './errors.js';
 
 export interface TaskProcessorConfig {
@@ -104,27 +104,8 @@ export function validateTaskSpaceDefinition(
       invalid(`task-group ${task.taskId} must contain at least one child`);
     }
   }
-  const authorityEdges = new Map<TaskId, TaskId[]>();
-  const addAuthorityEdge = (from: TaskId, to: TaskId): void => {
-    const outgoing = authorityEdges.get(from) ?? [];
-    outgoing.push(to);
-    authorityEdges.set(from, outgoing);
-  };
-  for (const [parent, children] of childrenByParent) {
-    for (const child of children) addAuthorityEdge(child, parent);
-  }
-  const descendants = (taskId: TaskId): TaskId[] => (childrenByParent.get(taskId) ?? [])
-    .flatMap((child) => [child, ...descendants(child)]);
-  for (const relation of definition.relations) {
-    if (relation.kind !== 'dependency') continue;
-    addAuthorityEdge(relation.predecessorTaskId, relation.successorTaskId);
-    if (tasks.get(relation.successorTaskId)?.kind === 'task-group') {
-      for (const descendant of descendants(relation.successorTaskId)) {
-        addAuthorityEdge(relation.predecessorTaskId, descendant);
-      }
-    }
-  }
-  assertAcyclic(tasks.keys(), (id) => authorityEdges.get(id) ?? []);
+  const completionGraph = buildTaskCompletionGraph(definition);
+  assertAcyclic(tasks.keys(), (id) => completionGraph.authoritySuccessorIdsByTask.get(id) ?? []);
 }
 
 export function taskDefinitionById(
@@ -139,10 +120,7 @@ export function taskRecordById(snapshot: TaskSpaceSnapshot, taskId: TaskId): Tas
 }
 
 export function predecessorIds(definition: TaskSpaceDefinition, taskId: TaskId): readonly TaskId[] {
-  return definition.relations
-    .filter((relation): relation is Extract<TaskRelation, { kind: 'dependency' }> =>
-      relation.kind === 'dependency' && relation.successorTaskId === taskId)
-    .map((relation) => relation.predecessorTaskId);
+  return buildTaskCompletionGraph(definition).predecessorIdsByTask.get(taskId) ?? [];
 }
 
 export function validateTimestamp(value: TaskTimestamp, field: string): number {