@signalridge/pi-workflows 0.2.0

package/src/rpc-client.ts

@@ -0,0 +1,364 @@
+import { randomUUID } from "node:crypto";
+import type {
+  ManagedSpawnResponse as ProtocolManagedSpawnResponse,
+  ManagedTerminalSnapshot as ProtocolManagedTerminalSnapshot,
+} from "@signalridge/pi-subagents-protocol";
+import {
+  PROTOCOL_VERSION,
+  parseManagedSpawnResponse,
+  parseProtocolPing,
+  requiredCapabilitiesMatch,
+  workflowTierCapabilityMatch,
+} from "@signalridge/pi-subagents-protocol";
+import type { WorkflowOwner } from "./journal.js";
+import type { WorkflowTask } from "./schema.js";
+
+export interface WorkflowEventBus {
+  on(event: string, handler: (data: unknown) => void): () => void;
+  emit(event: string, data: unknown): void;
+}
+
+type RpcSuccess<T> = { success: true; data?: T };
+type RpcFailure = { success: false; error: string };
+type RpcReply<T> = RpcSuccess<T> | RpcFailure;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isReply<T>(value: unknown): value is RpcReply<T> {
+  return isRecord(value) && typeof value.success === "boolean";
+}
+
+function requestId(): string {
+  return randomUUID();
+}
+
+function callRpc<T>(
+  events: WorkflowEventBus,
+  channel: string,
+  payload: Record<string, unknown>,
+  timeoutMs: number,
+  signal?: AbortSignal,
+): Promise<T> {
+  const id = typeof payload.requestId === "string" ? payload.requestId : requestId();
+  const replyChannel = `${channel}:reply:${id}`;
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let unsubscribe = () => {};
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      timer = undefined;
+      unsubscribe();
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const finish = (error: unknown, value?: T) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error) reject(error instanceof Error ? error : new Error(String(error)));
+      else resolve(value as T);
+    };
+    const onAbort = () => finish(new Error(`${channel} request aborted`));
+    try {
+      unsubscribe = events.on(replyChannel, (raw: unknown) => {
+        if (!isReply<T>(raw)) {
+          finish(new Error("Invalid subagents RPC reply"));
+          return;
+        }
+        if (!raw.success) finish(new Error(raw.error));
+        else finish(undefined, raw.data as T);
+      });
+      if (signal?.aborted) {
+        onAbort();
+        return;
+      }
+      signal?.addEventListener("abort", onAbort, { once: true });
+      timer = setTimeout(() => finish(new Error(`${channel} timed out after ${timeoutMs}ms`)), timeoutMs);
+      events.emit(channel, { ...payload, requestId: id });
+    } catch (error: unknown) {
+      finish(error);
+    }
+  });
+}
+
+export const REQUIRED_SUBAGENTS_PROTOCOL = PROTOCOL_VERSION;
+export const PROTOCOL_DIAGNOSTIC =
+  "@signalridge/pi-workflows requires @signalridge/pi-subagents protocol v3 with managedSpawn, lifecycleOwner, ownedStop, ownedQuiescence, and workflowTiers capabilities. " +
+  "Install @signalridge/pi-subagents and @signalridge/pi-workflows exactly once; Pi loads both from their configured pi.extensions manifests.";
+
+export const CHILD_CONTEXT_QUERY_TIMEOUT_MS = 250;
+
+/**
+ * Query the factory-time child-session marker owned by pi-subagents. A missing
+ * reply means the companion extension is absent; callers must retain the root
+ * surface and let the normal protocol diagnostic explain that configuration.
+ */
+export async function queryChildSessionContext(
+  events: WorkflowEventBus,
+  timeoutMs = CHILD_CONTEXT_QUERY_TIMEOUT_MS,
+): Promise<boolean | undefined> {
+  const id = requestId();
+  const channel = "subagents:rpc:context";
+  return new Promise<boolean | undefined>((resolve) => {
+    let settled = false;
+    const replyChannel = `${channel}:reply:${id}`;
+    let unsubscribe = () => {};
+    const timer = setTimeout(() => finish(undefined), timeoutMs);
+    const finish = (child: boolean | undefined) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      unsubscribe();
+      resolve(child);
+    };
+    unsubscribe = events.on(replyChannel, (raw: unknown) => {
+      if (!isReply(raw) || !raw.success || !isRecord(raw.data)) {
+        finish(undefined);
+        return;
+      }
+      finish(typeof raw.data.child === "boolean" ? raw.data.child : undefined);
+    });
+    try {
+      events.emit(channel, { requestId: id });
+    } catch {
+      finish(undefined);
+    }
+  });
+}
+/**
+ * Synchronous companion to the bounded async query. Pi's event bus dispatches
+ * handlers synchronously, so a child marker can be consumed before lifecycle
+ * registration without blocking a later extension's session_start.
+ */
+export function queryChildSessionContextImmediate(events: WorkflowEventBus): boolean | undefined {
+  const id = requestId();
+  const replyChannel = `subagents:rpc:context:reply:${id}`;
+  let child: boolean | undefined;
+  const unsubscribe = events.on(replyChannel, (raw: unknown) => {
+    if (!isReply(raw) || !raw.success || !isRecord(raw.data)) return;
+    if (typeof raw.data.child === "boolean") child = raw.data.child;
+  });
+  try {
+    events.emit("subagents:rpc:context", { requestId: id });
+  } finally {
+    unsubscribe();
+  }
+  return child;
+}
+
+/** Verify the separately configured pi-subagents package before workflow execution. */
+export async function checkManagedSpawnProtocol(events: WorkflowEventBus, signal?: AbortSignal): Promise<void> {
+  const id = requestId();
+  const reply = await new Promise<unknown>((resolve, reject) => {
+    const replyChannel = `subagents:rpc:ping:reply:${id}`;
+    let settled = false;
+    let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
+    let unsubscribeReply = () => {};
+    let unsubscribeReady = () => {};
+    const cleanup = () => {
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      unsubscribeReply();
+      unsubscribeReady();
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => finish(undefined, new Error("subagents protocol discovery aborted"));
+    const finish = (value: unknown, error?: Error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error) reject(error);
+      else resolve(value);
+    };
+    unsubscribeReply = events.on(replyChannel, (raw: unknown) => {
+      if (!isReply(raw)) {
+        finish(undefined, new Error("Invalid subagents protocol ping reply"));
+      } else if (!raw.success) {
+        finish(undefined, new Error(raw.error));
+      } else {
+        finish(raw.data);
+      }
+    });
+    unsubscribeReady = events.on("subagents:ready", (raw: unknown) => {
+      if (isRecord(raw) && typeof raw.version === "number") finish(raw);
+    });
+    const sendPing = () => {
+      try {
+        events.emit("subagents:rpc:ping", { requestId: id });
+      } catch (error: unknown) {
+        finish(undefined, error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    timeoutTimer = setTimeout(
+      () => finish(undefined, new Error("subagents protocol ping timed out after 2000ms")),
+      2_000,
+    );
+    // The two extensions may register their session_start handlers in either
+    // order. A synchronous ping handles the already-registered case; the
+    // readiness event handles a later session_start without emitting through a
+    // stale lifecycle context.
+    sendPing();
+  });
+  let ping: ReturnType<typeof parseProtocolPing>;
+  try {
+    ping = parseProtocolPing(reply);
+  } catch {
+    if (
+      !isRecord(reply) ||
+      typeof reply.version !== "number" ||
+      !isRecord(reply.capabilities) ||
+      reply.version < REQUIRED_SUBAGENTS_PROTOCOL ||
+      reply.capabilities.managedSpawn !== true ||
+      reply.capabilities.lifecycleOwner !== true ||
+      reply.capabilities.ownedStop !== true ||
+      reply.capabilities.ownedQuiescence !== true
+    ) {
+      throw new Error(
+        `subagents protocol v${REQUIRED_SUBAGENTS_PROTOCOL} with managed spawning, owned stop, and owned quiescence capability is required`,
+      );
+    }
+    throw new Error("subagents protocol ping did not return a valid version/capability envelope");
+  }
+  if (ping.version < REQUIRED_SUBAGENTS_PROTOCOL || !requiredCapabilitiesMatch(ping.capabilities)) {
+    throw new Error(
+      `subagents protocol v${REQUIRED_SUBAGENTS_PROTOCOL} with managed spawning, owned stop, and owned quiescence capability is required`,
+    );
+  }
+  if (!workflowTierCapabilityMatch(ping.capabilities)) {
+    throw new Error("subagents workflow tier capability is required before tiered managed spawning");
+  }
+}
+
+export type ManagedTerminalSnapshot = ProtocolManagedTerminalSnapshot;
+export type ManagedSpawnResponse = ProtocolManagedSpawnResponse;
+
+export interface ManagedSpawnClient {
+  /** String remains accepted for deterministic legacy fixtures; protocol v3 returns ManagedSpawnResponse. */
+  /**
+   * The fourth argument is the current attempt for protocol-v3 clients. The
+   * optional fifth argument is retained only for old in-process test/fixture
+   * clients that used the former context, attemptId shape; it is never a
+   * runtime context and is not sent over RPC.
+   */
+  spawn(
+    task: WorkflowTask,
+    runId: string,
+    nodeId: string,
+    attemptId?: string,
+    legacyAttemptId?: string,
+  ): Promise<ManagedSpawnResponse | string>;
+  /** Unscoped v2 stop, retained for existing callers. */
+  stop(agentId: string): Promise<void>;
+  /** Owner-scoped v3 stop used by workflow lifecycle operations. */
+  stopOwned?(agentId: string, owner: WorkflowOwner): Promise<void>;
+  quiesceOwned?(
+    runId: string,
+    agentIds: string[],
+    timeoutMs?: number,
+    owners?: WorkflowOwner[],
+  ): Promise<{ settled: boolean; pending: string[] }>;
+  /** Optional startup capability check; workflow execution remains event-bus-only. */
+  checkProtocol?: () => Promise<void>;
+}
+
+/** Event-bus-only client for the additive pi-subagents managed protocol. */
+export function createManagedSpawnClient(
+  events: WorkflowEventBus,
+  protocolSignal?: AbortSignal,
+  sessionSignal?: AbortSignal,
+): ManagedSpawnClient {
+  const call = <T>(
+    channel: string,
+    payload: Record<string, unknown>,
+    signal?: AbortSignal,
+    timeoutMs = 15_000,
+  ): Promise<T> => callRpc(events, channel, payload, timeoutMs, signal);
+
+  return {
+    async spawn(task, runId, nodeId, attemptId) {
+      const effectiveAttemptId = attemptId ?? `${runId}/${nodeId}/attempt-1`;
+      const data = await call<unknown>(
+        "subagents:rpc:spawn-managed",
+        {
+          requestId: requestId(),
+          spawnKey: `${runId}/${nodeId}/${effectiveAttemptId}`,
+          type: task.subagent_type,
+          prompt: task.prompt,
+          description: task.description,
+          ...(task.tier === undefined ? {} : { tier: task.tier }),
+          owner: {
+            extension: "pi-workflows",
+            runId,
+            nodeId,
+            attemptId: effectiveAttemptId,
+          },
+        },
+        sessionSignal,
+      );
+      if (!isRecord(data) || typeof data.id !== "string" || data.id.length === 0) {
+        throw new Error("subagents managed spawn returned an invalid agent id");
+      }
+      return parseManagedSpawnResponse(data);
+    },
+    async stop(agentId) {
+      await call<void>("subagents:rpc:stop", { requestId: requestId(), agentId }, sessionSignal);
+    },
+    async stopOwned(agentId, owner) {
+      await call<void>(
+        "subagents:rpc:stop-owned",
+        {
+          requestId: requestId(),
+          agentId,
+          owner,
+        },
+        sessionSignal,
+      );
+    },
+    async quiesceOwned(runId, agentIds, timeoutMs = 5_000, owners) {
+      const data = await call<unknown>(
+        "subagents:rpc:quiesce-owned",
+        {
+          requestId: requestId(),
+          owner: { extension: "pi-workflows", runId },
+          agentIds,
+          ...(owners ? { owners } : {}),
+          timeoutMs,
+        },
+        sessionSignal,
+        timeoutMs + 1_000,
+      );
+      if (!isRecord(data) || typeof data.settled !== "boolean" || !Array.isArray(data.pending)) {
+        throw new Error("subagents quiescence returned an invalid response");
+      }
+      const pending = data.pending.filter((id): id is string => typeof id === "string");
+      return { settled: data.settled, pending };
+    },
+    checkProtocol: () => checkManagedSpawnProtocol(events, protocolSignal),
+  };
+}
+
+export function registerLifecycleListener(
+  events: WorkflowEventBus,
+  handler: (eventName: string, data: Record<string, unknown>) => void,
+): () => void {
+  const unsubs = [
+    "subagents:created",
+    "subagents:started",
+    "subagents:completed",
+    "subagents:failed",
+    "subagents:compacted",
+  ].map((eventName) =>
+    events.on(eventName, (raw: unknown) => {
+      if (isRecord(raw)) handler(eventName, raw);
+    }),
+  );
+  return () => {
+    for (const unsubscribe of unsubs) unsubscribe();
+  };
+}

package/src/schema.ts

@@ -0,0 +1,186 @@
+export const WORKFLOW_SCHEMA_VERSION = 1;
+
+import type { WorkflowTier } from "@signalridge/pi-subagents-protocol";
+export const MAX_TASKS = 128;
+export const MAX_PHASES = 32;
+export const MAX_TEXT = 100_000;
+export const MAX_SHORT_TEXT = 512;
+
+export interface WorkflowPhase {
+  id: string;
+  title: string;
+}
+
+export interface WorkflowTask {
+  id: string;
+  phase?: string;
+  subagent_type: string;
+  description: string;
+  prompt: string;
+  tier?: WorkflowTier;
+  depends_on: string[];
+}
+
+export interface WorkflowSynthesis {
+  subagent_type: string;
+  prompt: string;
+  tier?: WorkflowTier;
+}
+
+export interface WorkflowDefinition {
+  name: string;
+  description?: string;
+  /** Default semantic tier for tasks and synthesis in this run. */
+  tier?: WorkflowTier;
+  phases: WorkflowPhase[];
+  tasks: WorkflowTask[];
+  synthesis?: WorkflowSynthesis;
+  background: boolean;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringField(value: unknown, label: string, max: number): string {
+  if (typeof value !== "string") throw new Error(`${label} must be a string`);
+  const normalized = value.trim();
+  if (normalized.length === 0) throw new Error(`${label} must not be empty`);
+  if (normalized.length > max) throw new Error(`${label} exceeds ${max} characters`);
+  return normalized;
+}
+
+function optionalString(value: unknown, label: string, max: number): string | undefined {
+  if (value === undefined) return undefined;
+  return stringField(value, label, max);
+}
+
+function optionalTier(value: unknown, label: string): WorkflowTier | undefined {
+  if (value === undefined) return undefined;
+  if (value !== "small" && value !== "medium" && value !== "large") {
+    throw new Error(`${label} must be one of small, medium, or large`);
+  }
+  return value;
+}
+
+function assertObjectKeys(value: Record<string, unknown>, allowed: readonly string[], label: string): void {
+  const allowedSet = new Set(allowed);
+  for (const key of Object.keys(value)) {
+    if (!allowedSet.has(key)) throw new Error(`${label} contains unsupported field "${key}"`);
+  }
+}
+
+function stringArray(value: unknown, label: string, maxItems: number, maxText: number): string[] {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
+  if (value.length > maxItems) throw new Error(`${label} has too many entries`);
+  return value.map((item, index) => stringField(item, `${label}[${index}]`, maxText));
+}
+
+function validateDag(tasks: WorkflowTask[]): void {
+  const ids = new Set(tasks.map((task) => task.id));
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+  const visit = (id: string): void => {
+    if (visiting.has(id)) throw new Error(`workflow dependencies contain a cycle at "${id}"`);
+    if (visited.has(id)) return;
+    visiting.add(id);
+    const task = tasks.find((candidate) => candidate.id === id);
+    if (!task) throw new Error(`unknown dependency "${id}"`);
+    for (const dependency of task.depends_on) visit(dependency);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  for (const task of tasks) {
+    for (const dependency of task.depends_on) {
+      if (!ids.has(dependency)) throw new Error(`task "${task.id}" depends on unknown task "${dependency}"`);
+    }
+    visit(task.id);
+  }
+}
+
+/** Validate the strict declarative workflow input and return a normalized copy. */
+export function validateWorkflow(input: unknown): WorkflowDefinition {
+  if (!isRecord(input)) throw new Error("workflow must be an object");
+  assertObjectKeys(input, ["name", "description", "tier", "phases", "tasks", "synthesis", "background"], "workflow");
+  const name = stringField(input.name, "name", MAX_SHORT_TEXT);
+  const description = optionalString(input.description, "description", MAX_TEXT);
+  const tier = optionalTier(input.tier, "tier");
+
+  const rawPhases = input.phases === undefined ? [] : input.phases;
+  if (!Array.isArray(rawPhases)) throw new Error("phases must be an array");
+  if (rawPhases.length > MAX_PHASES) throw new Error(`phases may contain at most ${MAX_PHASES} entries`);
+  const phases = rawPhases.map((raw, index) => {
+    if (!isRecord(raw)) throw new Error(`phases[${index}] must be an object`);
+    assertObjectKeys(raw, ["id", "title"], `phases[${index}]`);
+    return {
+      id: stringField(raw.id, `phases[${index}].id`, 128),
+      title: stringField(raw.title, `phases[${index}].title`, MAX_SHORT_TEXT),
+    };
+  });
+  const phaseIds = new Set<string>();
+  for (const phase of phases) {
+    if (phaseIds.has(phase.id)) throw new Error(`duplicate phase id "${phase.id}"`);
+    phaseIds.add(phase.id);
+  }
+
+  if (!Array.isArray(input.tasks)) throw new Error("tasks must be an array");
+  if (input.tasks.length === 0) throw new Error("tasks must contain at least one task");
+  if (input.tasks.length > MAX_TASKS) throw new Error(`tasks may contain at most ${MAX_TASKS} entries`);
+  const taskIds = new Set<string>();
+  const tasks = input.tasks.map((raw, index) => {
+    if (!isRecord(raw)) throw new Error(`tasks[${index}] must be an object`);
+    assertObjectKeys(
+      raw,
+      ["id", "phase", "tier", "subagent_type", "description", "prompt", "depends_on"],
+      `tasks[${index}]`,
+    );
+    const task: WorkflowTask = {
+      id: stringField(raw.id, `tasks[${index}].id`, 128),
+      phase: optionalString(raw.phase, `tasks[${index}].phase`, 128),
+      tier: optionalTier(raw.tier, `tasks[${index}].tier`),
+      subagent_type: stringField(raw.subagent_type, `tasks[${index}].subagent_type`, 128),
+      description: stringField(raw.description, `tasks[${index}].description`, MAX_SHORT_TEXT),
+      prompt: stringField(raw.prompt, `tasks[${index}].prompt`, MAX_TEXT),
+      depends_on: stringArray(raw.depends_on, `tasks[${index}].depends_on`, MAX_TASKS, 128),
+    };
+    if (taskIds.has(task.id)) throw new Error(`duplicate task id "${task.id}"`);
+    taskIds.add(task.id);
+    if (task.phase !== undefined && !phaseIds.has(task.phase)) {
+      throw new Error(`task "${task.id}" references unknown phase "${task.phase}"`);
+    }
+    return task;
+  });
+  validateDag(tasks);
+
+  let synthesis: WorkflowSynthesis | undefined;
+  if (input.synthesis !== undefined) {
+    if (!isRecord(input.synthesis)) throw new Error("synthesis must be an object");
+    assertObjectKeys(input.synthesis, ["subagent_type", "prompt", "tier"], "synthesis");
+    const tier = optionalTier(input.synthesis.tier, "synthesis.tier");
+    synthesis = {
+      ...(tier === undefined ? {} : { tier }),
+      subagent_type: stringField(input.synthesis.subagent_type, "synthesis.subagent_type", 128),
+      prompt: stringField(input.synthesis.prompt, "synthesis.prompt", MAX_TEXT),
+    };
+  }
+
+  if (input.background !== undefined && typeof input.background !== "boolean") {
+    throw new Error("background must be a boolean");
+  }
+  return {
+    name,
+    ...(description === undefined ? {} : { description }),
+    ...(tier === undefined ? {} : { tier }),
+    phases,
+    tasks,
+    ...(synthesis === undefined ? {} : { synthesis }),
+    background: input.background ?? false,
+  };
+}
+
+export function readyTaskIds(definition: WorkflowDefinition, completed: ReadonlySet<string>): string[] {
+  return definition.tasks
+    .filter((task) => !completed.has(task.id) && task.depends_on.every((dependency) => completed.has(dependency)))
+    .map((task) => task.id);
+}

package/src/state-machine.ts

@@ -0,0 +1,73 @@
+export type WorkflowStatus =
+  | "pending"
+  | "running"
+  | "pausing"
+  | "paused"
+  | "synthesizing"
+  | "stopping"
+  | "completed"
+  | "failed"
+  | "stopped"
+  | "interrupted";
+
+export type TaskStatus =
+  | "pending"
+  | "ready"
+  | "dispatching"
+  | "queued"
+  | "running"
+  | "completed"
+  | "failed"
+  | "stopped"
+  | "blocked";
+
+const workflowTransitions: Record<WorkflowStatus, readonly WorkflowStatus[]> = {
+  pending: ["running", "stopping", "stopped"],
+  running: ["pausing", "synthesizing", "stopping", "completed", "failed", "stopped", "interrupted"],
+  pausing: ["paused", "stopping", "failed", "stopped", "interrupted"],
+  paused: ["running", "stopping", "stopped", "interrupted"],
+  synthesizing: ["stopping", "completed", "failed", "stopped", "interrupted"],
+  stopping: ["completed", "failed", "stopped"],
+  completed: [],
+  failed: [],
+  stopped: [],
+  interrupted: ["running", "stopping", "stopped"],
+};
+
+const taskTransitions: Record<TaskStatus, readonly TaskStatus[]> = {
+  pending: ["ready", "blocked", "stopped"],
+  ready: ["dispatching", "blocked", "stopped"],
+  dispatching: ["ready", "queued", "running", "completed", "failed", "stopped", "blocked"],
+  queued: ["ready", "running", "completed", "failed", "stopped"],
+  running: ["ready", "completed", "failed", "stopped"],
+  completed: [],
+  failed: [],
+  stopped: [],
+  blocked: [],
+};
+
+export function canTransitionWorkflow(from: WorkflowStatus, to: WorkflowStatus): boolean {
+  return from === to || workflowTransitions[from].includes(to);
+}
+
+export function canTransitionTask(from: TaskStatus, to: TaskStatus): boolean {
+  return from === to || taskTransitions[from].includes(to);
+}
+
+export function transitionWorkflow(from: WorkflowStatus, to: WorkflowStatus): WorkflowStatus {
+  if (!canTransitionWorkflow(from, to)) throw new Error(`invalid workflow transition: ${from} -> ${to}`);
+  return to;
+}
+
+export function transitionTask(from: TaskStatus, to: TaskStatus): TaskStatus {
+  if (!canTransitionTask(from, to)) throw new Error(`invalid task transition: ${from} -> ${to}`);
+  return to;
+}
+
+export function isTerminalWorkflow(status: WorkflowStatus): boolean {
+  return status === "completed" || status === "failed" || status === "stopped";
+}
+
+export function isTerminalTask(status: TaskStatus): boolean {
+  return status === "completed" || status === "failed" || status === "stopped" || status === "blocked";
+}