task-manager-logic 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-manager-logic",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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/index.ts

@@ -1,5 +1,6 @@
 export * from './errors.js';
 export * from './statusMachine.js';
 export * from './validation.js';
+export * from './owner-admission.js';
 export * from './memory-owner.js';
 export * from './processors.js';

package/src/memory-owner.ts

@@ -10,9 +10,12 @@ import type {
   TaskSpaceOwnerPort,
   TaskSpaceSnapshot,
 } from 'task-manager-contract';
-import { canonicalOwnDataDigest } from 'task-manager-contract';
 import { TaskManagerError } from './errors.js';
-import { assertArtifactBody, assertArtifactRef, deepImmutableClone } from './validation.js';
+import {
+  validateTaskSpaceCommitAdmission,
+  validateTaskSpaceCommitCommand,
+} from './owner-admission.js';
+import { deepImmutableClone } from './validation.js';
 
 interface MemoryTaskSpaceState {
   readonly snapshot: TaskSpaceSnapshot;
@@ -52,10 +55,11 @@ export class InMemoryTaskSpaceOwner implements TaskSpaceOwnerPort {
 
   async compareAndSwap(commit: TaskSpaceCommit): Promise<TaskSpaceCommitResult> {
     commit = deepImmutableClone(commit);
+    const submittedCommandDigest = validateTaskSpaceCommitCommand(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({
@@ -77,7 +81,10 @@ export class InMemoryTaskSpaceOwner implements TaskSpaceOwnerPort {
       });
     }
 
-    const receipt = validateCommit(commit, current);
+    const receipt = validateTaskSpaceCommitAdmission(commit, {
+      ...(current === undefined ? {} : { currentSnapshot: current.snapshot }),
+      existingArtifacts: current?.artifacts ?? new Map(),
+    });
     const receiptsByCommand = new Map(current?.receiptsByCommand ?? []);
     for (const candidate of commit.receipts) receiptsByCommand.set(candidate.commandId, deepImmutableClone(candidate));
     const artifacts = new Map(current?.artifacts ?? []);
@@ -105,79 +112,6 @@ export class InMemoryTaskSpaceOwner implements TaskSpaceOwnerPort {
   }
 }
 
-function validateCommit(
-  commit: TaskSpaceCommit,
-  current: MemoryTaskSpaceState | undefined,
-): TaskCommandReceipt {
-  const expectedNextRevision = commit.expectedRevision === null ? 0 : commit.expectedRevision + 1;
-  if (commit.kind !== 'task-space-commit'
-    || commit.command.commandId !== commit.commandId
-    || commit.command.taskSpaceId !== commit.taskSpaceId
-    || canonicalOwnDataDigest(commit.command) !== commit.commandDigest
-    || commit.snapshot.taskSpaceId !== commit.taskSpaceId
-    || commit.snapshot.definition.taskSpaceId !== commit.taskSpaceId
-    || commit.snapshot.revision !== expectedNextRevision) {
-    invalid('commit snapshot identity or revision is inconsistent');
-  }
-  if (commit.receipts.length !== 1) invalid('one command admission must contain exactly one receipt');
-  const receipt = commit.receipts[0];
-  if (!receipt
-    || receipt.commandId !== commit.commandId
-    || receipt.commandDigest !== commit.commandDigest
-    || receipt.taskSpaceId !== commit.taskSpaceId) {
-    invalid('commit receipt does not match command identity');
-  }
-  if (receipt.toRevision !== expectedNextRevision) invalid('receipt toRevision does not match snapshot');
-  if (receipt.fromRevision !== (commit.expectedRevision ?? 0)) invalid('receipt fromRevision does not match CAS');
-
-  const priorHistoryIds = current?.snapshot.historyEventIds ?? [];
-  const expectedHistoryIds = [...priorHistoryIds, ...commit.events.map(({ eventId }) => eventId)];
-  if (!sameStrings(commit.snapshot.historyEventIds, expectedHistoryIds)) invalid('snapshot history is not append-only');
-  const priorReceiptIds = current?.snapshot.issuedReceiptIds ?? [];
-  const expectedReceiptIds = [...priorReceiptIds, ...commit.receipts.map(({ receiptId }) => receiptId)];
-  if (!sameStrings(commit.snapshot.issuedReceiptIds, expectedReceiptIds)) invalid('snapshot receipt history is not append-only');
-
-  const seenEvents = new Set(priorHistoryIds);
-  for (let index = 0; index < commit.events.length; index += 1) {
-    const event = commit.events[index]!;
-    if (event.taskSpaceId !== commit.taskSpaceId
-      || event.commandId !== commit.commandId
-      || event.sequence !== priorHistoryIds.length + index
-      || event.fromRevision !== (commit.expectedRevision ?? 0)
-      || event.toRevision !== expectedNextRevision
-      || seenEvents.has(event.eventId)) {
-      invalid(`event ${event.eventId} violates append-only commit identity`);
-    }
-    seenEvents.add(event.eventId);
-  }
-  const availableArtifacts = new Map(current?.artifacts ?? []);
-  for (const body of commit.artifacts) {
-    assertArtifactBody(body, `artifact body ${body.digest}`);
-    const prior = availableArtifacts.get(body.digest);
-    if (prior && canonicalOwnDataDigest(prior) !== canonicalOwnDataDigest(body)) {
-      throw new TaskManagerError('artifact-conflict', `artifact ${body.digest} has conflicting content`);
-    }
-    availableArtifacts.set(body.digest, body);
-  }
-  const refs = [
-    ...commit.snapshot.definition.tasks.flatMap(({ inputArtifacts }) => inputArtifacts),
-    ...commit.snapshot.tasks.flatMap(({ outputArtifacts }) => outputArtifacts),
-  ];
-  for (const ref of refs) {
-    assertArtifactRef(ref, `artifact ref ${ref.digest}`);
-    const body = availableArtifacts.get(ref.digest);
-    if (!body) throw new TaskManagerError('artifact-not-found', `artifact ${ref.digest} is not present in owner CAS`);
-    if (body.mediaType !== ref.mediaType || body.sizeBytes !== ref.sizeBytes) {
-      throw new TaskManagerError('artifact-conflict', `artifact ${ref.digest} metadata disagrees with owner body`);
-    }
-  }
-  return receipt;
-}
-
-function sameStrings(left: readonly string[], right: readonly string[]): boolean {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-
 function sameArtifact(left: TaskArtifactBody, right: TaskArtifactBody): boolean {
   return left.digest === right.digest
     && left.mediaType === right.mediaType
@@ -185,7 +119,3 @@ function sameArtifact(left: TaskArtifactBody, right: TaskArtifactBody): boolean
     && left.encoding === right.encoding
     && left.data === right.data;
 }
-
-function invalid(message: string): never {
-  throw new TaskManagerError('invalid-commit', message);
-}

package/src/owner-admission.ts

@@ -0,0 +1,189 @@
+import type {
+  TaskArtifactBody,
+  TaskArtifactDigest,
+  TaskArtifactRef,
+  TaskCommandDigest,
+  TaskCommandReceipt,
+  TaskSpaceCommit,
+  TaskSpaceSnapshot,
+} from 'task-manager-contract';
+import { canonicalOwnDataDigest } from 'task-manager-contract';
+import { TaskManagerError } from './errors.js';
+import { assertArtifactBody, assertArtifactRef } from './validation.js';
+
+export interface TaskSpaceCommitAdmissionContext {
+  readonly currentSnapshot?: TaskSpaceSnapshot;
+  readonly existingArtifacts: ReadonlyMap<TaskArtifactDigest, TaskArtifactBody>;
+}
+
+/**
+ * Validates the command envelope before either owner performs replay lookup.
+ * This keeps replay authentication identical across backend adapters.
+ */
+export function validateTaskSpaceCommitCommand(commit: TaskSpaceCommit): TaskCommandDigest {
+  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;
+}
+
+/**
+ * Backend-neutral authority for a non-replay TaskSpace CAS admission.
+ * Storage implementations add only their own lock, containment, material and
+ * recovery checks around this shared identity/append-only/artifact validator.
+ */
+export function validateTaskSpaceCommitAdmission(
+  commit: TaskSpaceCommit,
+  context: TaskSpaceCommitAdmissionContext,
+): TaskCommandReceipt {
+  const commandDigest = validateTaskSpaceCommitCommand(commit);
+  const current = context.currentSnapshot;
+  const nextRevision = commit.expectedRevision === null ? 0 : commit.expectedRevision + 1;
+  if (commit.snapshot.taskSpaceId !== commit.taskSpaceId
+    || commit.snapshot.definition.taskSpaceId !== commit.taskSpaceId
+    || commit.snapshot.revision !== nextRevision) {
+    invalid('snapshot identity or revision disagrees with CAS');
+  }
+  assertSnapshotIdentity(commit.snapshot);
+
+  if (commit.receipts.length !== 1) invalid('one CAS command must issue exactly one receipt');
+  const receipt = commit.receipts[0]!;
+  if (receipt.commandId !== commit.commandId
+    || receipt.commandDigest !== commandDigest
+    || receipt.taskSpaceId !== commit.taskSpaceId
+    || receipt.fromRevision !== (commit.expectedRevision ?? 0)
+    || receipt.toRevision !== nextRevision) {
+    invalid('receipt identity or revision disagrees with CAS');
+  }
+
+  const priorHistoryIds = current?.historyEventIds ?? [];
+  const priorReceiptIds = current?.issuedReceiptIds ?? [];
+  const eventIds = commit.events.map(({ eventId }) => eventId);
+  if (!sameStrings(commit.snapshot.historyEventIds, [...priorHistoryIds, ...eventIds])) {
+    invalid('history prefix was rewritten');
+  }
+  if (!sameStrings(commit.snapshot.issuedReceiptIds, [...priorReceiptIds, receipt.receiptId])) {
+    invalid('receipt prefix was rewritten');
+  }
+  if (priorReceiptIds.includes(receipt.receiptId)) invalid(`receipt ${receipt.receiptId} is not append-only`);
+  if (!sameStrings(receipt.eventIds, eventIds)) invalid('receipt does not name the admitted event set');
+
+  const seenEvents = new Set(priorHistoryIds);
+  commit.events.forEach((event, index) => {
+    if (event.taskSpaceId !== commit.taskSpaceId
+      || event.commandId !== commit.commandId
+      || event.sequence !== priorHistoryIds.length + index
+      || event.fromRevision !== (commit.expectedRevision ?? 0)
+      || event.toRevision !== nextRevision
+      || seenEvents.has(event.eventId)) {
+      invalid(`event ${event.eventId} violates append-only admission`);
+    }
+    seenEvents.add(event.eventId);
+  });
+
+  validateArtifactAuthority(commit, context);
+  return receipt;
+}
+
+export function taskArtifactRefsOfSnapshot(snapshot: TaskSpaceSnapshot): readonly TaskArtifactRef[] {
+  return [
+    ...snapshot.definition.tasks.flatMap(({ inputArtifacts }) => inputArtifacts),
+    ...snapshot.tasks.flatMap(({ outputArtifacts }) => outputArtifacts),
+  ];
+}
+
+function assertSnapshotIdentity(snapshot: TaskSpaceSnapshot): void {
+  if (snapshot.kind !== 'task-space-snapshot') invalid('snapshot kind is invalid');
+  const definitions = new Map(snapshot.definition.tasks.map((task) => [task.taskId, task]));
+  if (definitions.size !== snapshot.definition.tasks.length || snapshot.tasks.length !== definitions.size) {
+    invalid('snapshot tree/task identity is invalid');
+  }
+  const seen = new Set<string>();
+  for (const task of snapshot.tasks) {
+    const definition = definitions.get(task.taskId);
+    if (task.taskSpaceId !== snapshot.taskSpaceId
+      || !definition
+      || seen.has(task.taskId)
+      || canonicalOwnDataDigest(definition) !== canonicalOwnDataDigest(task.definition)) {
+      invalid(`snapshot task ${task.taskId} disagrees with its tree definition`);
+    }
+    seen.add(task.taskId);
+  }
+}
+
+function validateArtifactAuthority(
+  commit: TaskSpaceCommit,
+  context: TaskSpaceCommitAdmissionContext,
+): void {
+  const availableArtifacts = new Map(context.existingArtifacts);
+  for (const body of commit.artifacts) {
+    assertArtifactBody(body, `artifact body ${body.digest}`);
+    const prior = availableArtifacts.get(body.digest);
+    if (prior && canonicalOwnDataDigest(prior) !== canonicalOwnDataDigest(body)) {
+      conflict(`artifact ${body.digest} has conflicting content`);
+    }
+    availableArtifacts.set(body.digest, body);
+  }
+
+  const priorRefs = refsByDigest(context.currentSnapshot ? taskArtifactRefsOfSnapshot(context.currentSnapshot) : []);
+  const nextRefs = refsByDigest(taskArtifactRefsOfSnapshot(commit.snapshot));
+  for (const [digest, nextRef] of nextRefs) {
+    const priorRef = priorRefs.get(digest);
+    if (priorRef && !sameArtifactRef(priorRef, nextRef)) {
+      conflict(`artifact ${digest} conflicts with the previously admitted reference`);
+    }
+    const body = availableArtifacts.get(digest);
+    if (!body) {
+      throw new TaskManagerError('artifact-not-found', `artifact ${digest} is not present in owner CAS`);
+    }
+    if (body.digest !== nextRef.digest
+      || body.mediaType !== nextRef.mediaType
+      || body.sizeBytes !== nextRef.sizeBytes) {
+      conflict(`artifact ${digest} metadata disagrees with owner body`);
+    }
+  }
+}
+
+function refsByDigest(refs: readonly TaskArtifactRef[]): Map<TaskArtifactDigest, TaskArtifactRef> {
+  const result = new Map<TaskArtifactDigest, TaskArtifactRef>();
+  for (const ref of refs) {
+    assertArtifactRef(ref, `artifact ref ${ref.digest}`);
+    const prior = result.get(ref.digest);
+    if (prior && !sameArtifactRef(prior, ref)) {
+      conflict(`artifact ${ref.digest} has conflicting complete references`);
+    }
+    result.set(ref.digest, ref);
+  }
+  return result;
+}
+
+function sameArtifactRef(left: TaskArtifactRef, right: TaskArtifactRef): boolean {
+  return left.digest === right.digest
+    && left.name === right.name
+    && left.mediaType === right.mediaType
+    && left.sizeBytes === right.sizeBytes;
+}
+
+function sameStrings(left: readonly string[], right: readonly string[]): boolean {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function invalid(message: string): never {
+  throw new TaskManagerError('invalid-commit', message);
+}
+
+function conflict(message: string): never {
+  throw new TaskManagerError('artifact-conflict', message);
+}

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 {