@tt-a1i/openpi 0.1.0 → 0.2.0

package/extensions/tasks/index.ts

@@ -6,6 +6,10 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { Key, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
 import {
   TASKS_ENTRY_TYPE,
   TASKS_LIMITS,
@@ -97,6 +101,14 @@ export default function sessionTasks(pi: ExtensionAPI) {
   let taskWidgetExpanded = false;
   let ui: ExtensionContext["ui"] | undefined;
   let uiMode: ExtensionContext["mode"] | undefined;
+  const hideLifecycleTools = () =>
+    patchOwnedTools(pi, "tasks", {
+      disable: OPENPI_TOOL_SURFACE.tasks.deferred,
+    });
+  const showLifecycleTools = () =>
+    patchOwnedTools(pi, "tasks", {
+      enable: OPENPI_TOOL_SURFACE.tasks.deferred,
+    });
 
   const snapshot = () => tasks.snapshot();
 
@@ -199,13 +211,15 @@ export default function sessionTasks(pi: ExtensionAPI) {
     items,
     total: snapshot().items.length,
     revision: snapshot().revision,
-    // From the live snapshot, not `items`: a tools_update carries only the one
-    // row it touched, and a header counted from that would claim the batch is
-    // a single task.
     counts: taskCounts(snapshot().items),
     ...(batchClosed ? { batchClosed: true } : {}),
   });
 
+  const mutationResultText = (summary: string) => {
+    const current = snapshot();
+    return `${summary}\nCurrent task snapshot (${current.items.length} ${current.items.length === 1 ? "item" : "items"}):\n${tasks.render()}`;
+  };
+
   const registerTools = () => {
     if (toolsRegistered || conflict) return;
     toolsRegistered = true;
@@ -218,6 +232,7 @@ export default function sessionTasks(pi: ExtensionAPI) {
         "Add stable work-intent items to the current session tasks",
       promptGuidelines: [
         "Use tasks_add only for work spanning multiple agent runs or user turns, or when the user explicitly provides a task list; do not use it as a per-step scratchpad within one run.",
+        "Before starting each tracked item, call tasks_update to mark it in_progress; concurrent work may have multiple in_progress items.",
         "Task tools record advisory intent only; Subagents and Workflows execute work, while files, git, tests, tool results, artifacts, and user confirmation remain truth.",
       ],
       parameters: Type.Object({
@@ -239,14 +254,17 @@ export default function sessionTasks(pi: ExtensionAPI) {
         assertAvailable();
         const mutation = applyTaskAdd(snapshot(), params.items);
         persistThenCommit(mutation.snapshot);
+        showLifecycleTools();
         return Promise.resolve({
           content: [
             {
               type: "text" as const,
-              text: `Added ${mutation.items.map((item) => `T${item.id}`).join(", ")}.`,
+              text: mutationResultText(
+                `Added ${mutation.items.map((item) => `T${item.id}`).join(", ")}.`,
+              ),
             },
           ],
-          details: toolDetails("add", mutation.items),
+          details: toolDetails("add", snapshot().items),
         });
       },
       renderCall(args, theme) {
@@ -273,7 +291,9 @@ export default function sessionTasks(pi: ExtensionAPI) {
       description: `${TOOL_PURPOSE} Patch one task item by numeric ID. blocked, done, and dropped status changes require a fresh note explaining the blocker, observable evidence, or drop reason.`,
       promptSnippet: "Update one session task item by stable ID",
       promptGuidelines: [
-        "Keep tasks_update status current when tracked work materially changes, but avoid ceremonial status churn.",
+        "Immediately after each tracked item reaches a real outcome, call tasks_update to set done, blocked, or dropped before moving to the next tracked item.",
+        "Before sending a final answer, reconcile every task touched in the current request; do not leave completed work pending or in_progress.",
+        "A commit, passing test, or authorization is task-scoped evidence only; it does not by itself prove a task is done or identify which task to update.",
         "Before setting a task item to done, include a note citing an observable check, artifact, commit, tool result, or user confirmation; Tasks record this claim but do not verify it.",
       ],
       parameters: Type.Object({
@@ -305,18 +325,21 @@ export default function sessionTasks(pi: ExtensionAPI) {
         );
         const mutation = applyTaskUpdate(before, params);
         const changed = persistThenCommit(mutation.snapshot);
+        if (changed && closesBatch) hideLifecycleTools();
         return Promise.resolve({
           content: [
             {
               type: "text" as const,
-              text: changed
-                ? closesBatch
-                  ? `${params.status === "dropped" ? "Dropped" : "Completed"} T${params.id}. Task batch closed; the next tasks_add starts again at T1.`
-                  : `Updated T${params.id}.`
-                : `T${params.id} already has that state; no update recorded.`,
+              text: mutationResultText(
+                changed
+                  ? closesBatch
+                    ? `${params.status === "dropped" ? "Dropped" : "Completed"} T${params.id}. Task batch closed; the next tasks_add starts again at T1.`
+                    : `Updated T${params.id}.`
+                  : `T${params.id} already has that state; no update recorded.`,
+              ),
             },
           ],
-          details: toolDetails("update", mutation.items, closesBatch),
+          details: toolDetails("update", snapshot().items, closesBatch),
         });
       },
       renderCall(args, theme) {
@@ -448,12 +471,16 @@ export default function sessionTasks(pi: ExtensionAPI) {
     taskWidgetVisible = true;
     taskWidgetExpanded = false;
     registerTools();
+    if (hasActionableTasks()) showLifecycleTools();
+    else hideLifecycleTools();
     notifyProblem(ctx);
     updateTaskWidget(ctx);
   });
 
   pi.on("session_tree", (_event, ctx) => {
     restore(ctx);
+    if (hasActionableTasks()) showLifecycleTools();
+    else hideLifecycleTools();
     taskWidgetExpanded = false;
     coldRun = true;
     activeRun = false;

package/extensions/ui-customization/footer.ts

@@ -72,7 +72,12 @@ const MONO_COLORS: readonly PowerlineColors[] = [
 ];
 
 export type SegmentTone =
-  "text" | "muted" | "dim" | "warning" | "error" | "accent";
+  | "text"
+  | "muted"
+  | "dim"
+  | "warning"
+  | "error"
+  | "accent";
 
 export interface FooterSegment {
   readonly id: FooterItem;

package/extensions/workflows/artifacts.ts

@@ -1,4 +1,8 @@
-import type { TranscriptEntry, WorkflowDetails } from "./model.ts";
+import {
+  refreshWorkflowGraph,
+  type TranscriptEntry,
+  type WorkflowDetails,
+} from "./model.ts";
 import {
   boundedJournal,
   parseJournal,
@@ -101,6 +105,7 @@ export function persistWorkflowJson(
   details: WorkflowDetails,
   journal?: readonly JournalEntry[],
 ) {
+  refreshWorkflowGraph(details);
   const transcripts = Object.fromEntries(
     details.agents.map((agent) => [
       agent.index,

package/extensions/workflows/dashboard.ts

@@ -46,12 +46,19 @@ import {
   SQUARE,
   type Theme,
   type AgentRecord,
+  type AgentUsage,
   type PhaseGroup,
   type TranscriptEntry,
   type WorkflowDetails,
   type WorkflowLogEntry,
+  workflowGraphRecords,
 } from "./model.ts";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
+import { projectWorkflowGraph } from "./graph-projection.ts";
+import {
+  classifyInterruptedInvocation,
+  decodeInvocationRecord,
+} from "./invocation-ledger.ts";
 import { writeFileAtomic } from "./serialization.ts";
 
 const NOTICE_TTL_MS = 4000;
@@ -86,6 +93,30 @@ function isWorktreeCleanup(
   );
 }
 
+function normalizeUsage(value: unknown): AgentUsage {
+  const raw = value && typeof value === "object" ? value : {};
+  const record = raw as Record<string, unknown>;
+  const number = (field: string) => {
+    const candidate = record[field];
+    return typeof candidate === "number" &&
+      Number.isFinite(candidate) &&
+      candidate >= 0
+      ? candidate
+      : 0;
+  };
+  return {
+    input: number("input"),
+    output: number("output"),
+    cacheRead: number("cacheRead"),
+    cacheWrite: number("cacheWrite"),
+    cost: number("cost"),
+    ...(number("contextTokens") > 0
+      ? { contextTokens: number("contextTokens") }
+      : {}),
+    turns: number("turns"),
+  };
+}
+
 function normalizeTranscript(value: unknown): TranscriptEntry[] {
   if (!Array.isArray(value)) return [];
   const transcript: TranscriptEntry[] = [];
@@ -138,12 +169,46 @@ export function normalizePersistedWorkflowDetails(
         : a.state === "running"
           ? "running"
           : "done";
+    const index = typeof a.index === "number" ? a.index : agents.length + 1;
+    const decodedInvocation = decodeInvocationRecord(a.invocation);
+    const invocation =
+      decodedInvocation &&
+      decodedInvocation.executionState !== "settled" &&
+      decodedInvocation.executionState !== "uncertain"
+        ? classifyInterruptedInvocation(
+            decodedInvocation,
+            Math.max(
+              Date.now(),
+              decodedInvocation.requestedAt,
+              decodedInvocation.claimedAt ?? 0,
+              decodedInvocation.runningAt ?? 0,
+            ),
+          )
+        : decodedInvocation;
     agents.push({
-      index: typeof a.index === "number" ? a.index : agents.length + 1,
+      index,
+      ...(typeof a.callId === "string" && a.callId
+        ? { callId: sanitizeLine(a.callId, 256) }
+        : {}),
+      ...(invocation ? { invocation } : {}),
+      ...(typeof a.operatorKey === "string" && a.operatorKey
+        ? { operatorKey: sanitizeLine(a.operatorKey, 80) }
+        : {}),
+      ...(Array.isArray(a.inputCallIds)
+        ? {
+            inputCallIds: a.inputCallIds
+              .filter((value): value is string => typeof value === "string")
+              .slice(0, 64)
+              .map((value) => sanitizeLine(value, 256)),
+          }
+        : {}),
+      ...(typeof a.resultRef === "string" && a.resultRef
+        ? { resultRef: sanitizeLine(a.resultRef, 256) }
+        : {}),
       label:
         typeof a.label === "string"
-          ? sanitizeLine(a.label, 160) || `agent-${agents.length + 1}`
-          : `agent-${agents.length + 1}`,
+          ? sanitizeLine(a.label, 160) || `agent-${index}`
+          : `agent-${index}`,
       phase:
         typeof a.phase === "string"
           ? sanitizeLine(a.phase, 160) || undefined
@@ -167,15 +232,7 @@ export function normalizePersistedWorkflowDetails(
           : undefined,
       preview:
         typeof a.preview === "string" ? sanitizeLine(a.preview, 4_000) : "",
-      usage: {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        cost: 0,
-        turns: 0,
-        ...(a.usage && typeof a.usage === "object" ? (a.usage as object) : {}),
-      },
+      usage: normalizeUsage(a.usage),
       ...(a.replayed === true ? { replayed: true } : {}),
       ...(isAcceptanceLedger(a.acceptance) ? { acceptance: a.acceptance } : {}),
       ...(typeof a.worktreeBranch === "string"
@@ -263,6 +320,11 @@ export function normalizePersistedWorkflowDetails(
     ...(typeof record.logsDropped === "number" && record.logsDropped > 0
       ? { logsDropped: record.logsDropped }
       : {}),
+    ...(agents.some((agent) => agent.callId)
+      ? {
+          graph: projectWorkflowGraph(workflowGraphRecords(agents)),
+        }
+      : {}),
     result: record.result,
     resultArtifact:
       typeof record.resultArtifact === "string"
@@ -283,6 +345,25 @@ export function normalizePersistedWorkflowDetails(
   };
 }
 
+/** Reconcile durable facts from a run that has no live owner in this process. */
+export function recoverStaleWorkflowDetails(
+  details: WorkflowDetails,
+  recoveredAt = Date.now(),
+): WorkflowDetails {
+  if (details.status !== "running") return details;
+  details.status = "aborted";
+  details.finishedAt = details.finishedAt ?? recoveredAt;
+  details.error = details.error ?? "Recovered stale run that was not active";
+  for (const agent of details.agents) {
+    if (agent.state !== "running") continue;
+    agent.state = "error";
+    agent.error = agent.error ?? "Run ended before this agent settled";
+    agent.finishedAt = details.finishedAt;
+  }
+  details.graph = projectWorkflowGraph(workflowGraphRecords(details.agents));
+  return details;
+}
+
 export function sessionWorkflowRunIds(ctx: ExtensionContext): Set<string> {
   const runIds = new Set<string>();
   for (const entry of ctx.sessionManager.getEntries()) {
@@ -365,18 +446,7 @@ export function loadRunEntries(
             // Older or partially written artifacts simply lack transcripts.
           }
         }
-        if (details.status === "running") {
-          details.status = "aborted";
-          details.finishedAt = details.finishedAt ?? Date.now();
-          details.error =
-            details.error ?? "Recovered stale run that was not active";
-          for (const agent of details.agents) {
-            if (agent.state !== "running") continue;
-            agent.state = "error";
-            agent.error = agent.error ?? "Run ended before this agent settled";
-            agent.finishedAt = details.finishedAt;
-          }
-        }
+        recoverStaleWorkflowDetails(details);
         entries.push({ runId, details, live: false });
       }
     } catch {
@@ -386,7 +456,22 @@ export function loadRunEntries(
   return entries.sort((a, b) => b.details.startedAt - a.details.startedAt);
 }
 
-function buildReport(details: WorkflowDetails): string {
+export function workflowGraphSummary(
+  graph: NonNullable<WorkflowDetails["graph"]>,
+) {
+  const omitted = [
+    graph.omitted.nodes > 0 ? `${graph.omitted.nodes} nodes` : undefined,
+    graph.omitted.edges > 0 ? `${graph.omitted.edges} edges` : undefined,
+    graph.omitted.diagnostics > 0
+      ? `${graph.omitted.diagnostics} diagnostics`
+      : undefined,
+  ].filter(Boolean);
+  return `${graph.nodes.length} nodes · ${graph.edges.length} edges${
+    omitted.length > 0 ? ` · ${omitted.join(", ")} omitted` : ""
+  }`;
+}
+
+export function buildWorkflowReport(details: WorkflowDetails): string {
   const { done, failed } = countStates(details);
   const lines: string[] = [
     `# Workflow ${details.name ?? details.runId}`,
@@ -429,6 +514,26 @@ function buildReport(details: WorkflowDetails): string {
     }
   }
 
+  if (details.graph && details.graph.nodes.length > 0) {
+    const labels = new Map(
+      details.graph.nodes.map((node) => [node.callId, node.label] as const),
+    );
+    lines.push(
+      "",
+      "## Derived graph",
+      "",
+      `_observability only · ${workflowGraphSummary(details.graph)}_`,
+    );
+    for (const edge of details.graph.edges) {
+      lines.push(
+        `- ${labels.get(edge.source) ?? edge.source} → ${labels.get(edge.target) ?? edge.target}`,
+      );
+    }
+    for (const diagnostic of details.graph.diagnostics) {
+      lines.push(`- ⚠ ${diagnostic.code}: ${resultJson(diagnostic)}`);
+    }
+  }
+
   if (details.result !== undefined) {
     lines.push(
       "",
@@ -601,7 +706,7 @@ export class WorkflowDashboard {
     if (!entry) return;
     const target = path.join(runsDir(), entry.runId, "report.md");
     try {
-      writeFileAtomic(target, buildReport(entry.details));
+      writeFileAtomic(target, buildWorkflowReport(entry.details));
       this.notice = `saved ${shortenHome(target)}`;
     } catch (error) {
       this.notice = `save failed: ${error instanceof Error ? error.message : String(error)}`;
@@ -918,9 +1023,15 @@ export class WorkflowDashboard {
       ),
     );
     const totals = formatUsage(aggregateUsage(d.agents));
+    const graphSummary = d.graph ? workflowGraphSummary(d.graph) : undefined;
+    const subRight = [graphSummary, totals].filter(Boolean).join(" · ");
     const subLeft = " " + theme.fg("muted", d.description ?? d.runId);
     lines.push(
-      this.split(subLeft, totals ? theme.fg("dim", `${totals} `) : " ", width),
+      this.split(
+        subLeft,
+        subRight ? theme.fg("dim", `${subRight} `) : " ",
+        width,
+      ),
     );
 
     const groups = this.groups();

package/extensions/workflows/graph-projection.ts

@@ -0,0 +1,240 @@
+/**
+ * Read-only workflow lineage derived from persisted agent-like records.
+ * This projection is descriptive only; it must not drive admission or execution.
+ */
+
+export interface WorkflowGraphRecord {
+  readonly callId: string;
+  readonly index: number;
+  readonly label: string;
+  readonly state: string;
+  readonly admissionState?: string;
+  readonly executionState?: string;
+  readonly operatorKey?: string;
+  readonly inputCallIds?: readonly string[];
+  readonly resultRef?: string;
+}
+
+export interface WorkflowGraphNode {
+  callId: string;
+  index: number;
+  label: string;
+  state: string;
+  admissionState?: string;
+  executionState?: string;
+  operatorKey?: string;
+  resultRef?: string;
+}
+
+export interface WorkflowGraphEdge {
+  source: string;
+  target: string;
+}
+
+export type WorkflowGraphDiagnostic =
+  | {
+      code: "duplicate_call_id";
+      callId: string;
+      keptIndex: number;
+      duplicateIndex: number;
+    }
+  | { code: "missing_input_call"; source: string; target: string }
+  | { code: "duplicate_input_call"; source: string; target: string }
+  | { code: "cycle"; callIds: string[] };
+
+export interface WorkflowGraphProjectionLimits {
+  readonly maxNodes?: number;
+  readonly maxEdges?: number;
+  readonly maxDiagnostics?: number;
+}
+
+export const WORKFLOW_GRAPH_MAX_NODES = 1_000;
+export const WORKFLOW_GRAPH_MAX_EDGES = 4_000;
+export const WORKFLOW_GRAPH_MAX_DIAGNOSTICS = 256;
+
+function boundedLimit(value: number | undefined, maximum: number) {
+  if (value === undefined || !Number.isFinite(value)) return maximum;
+  return Math.max(0, Math.min(maximum, Math.floor(value)));
+}
+
+function compareRecords(left: WorkflowGraphRecord, right: WorkflowGraphRecord) {
+  const byIndex = left.index - right.index;
+  if (byIndex !== 0) return byIndex;
+  return left.callId < right.callId ? -1 : left.callId > right.callId ? 1 : 0;
+}
+
+function toNode(record: WorkflowGraphRecord): WorkflowGraphNode {
+  return {
+    callId: record.callId,
+    index: record.index,
+    label: record.label,
+    state: record.state,
+    ...(record.admissionState !== undefined
+      ? { admissionState: record.admissionState }
+      : {}),
+    ...(record.executionState !== undefined
+      ? { executionState: record.executionState }
+      : {}),
+    ...(record.operatorKey !== undefined
+      ? { operatorKey: record.operatorKey }
+      : {}),
+    ...(record.resultRef !== undefined ? { resultRef: record.resultRef } : {}),
+  };
+}
+
+function findCycles(
+  nodes: readonly WorkflowGraphNode[],
+  edges: readonly WorkflowGraphEdge[],
+) {
+  const order = new Map(nodes.map((node, index) => [node.callId, index]));
+  const adjacency = new Map(nodes.map((node) => [node.callId, [] as string[]]));
+  for (const edge of edges) adjacency.get(edge.source)?.push(edge.target);
+
+  let nextIndex = 0;
+  const indexes = new Map<string, number>();
+  const lowLinks = new Map<string, number>();
+  const stack: string[] = [];
+  const onStack = new Set<string>();
+  const cycles: string[][] = [];
+
+  const visit = (callId: string) => {
+    const index = nextIndex++;
+    indexes.set(callId, index);
+    lowLinks.set(callId, index);
+    stack.push(callId);
+    onStack.add(callId);
+
+    for (const target of adjacency.get(callId) ?? []) {
+      if (!indexes.has(target)) {
+        visit(target);
+        lowLinks.set(
+          callId,
+          Math.min(lowLinks.get(callId)!, lowLinks.get(target)!),
+        );
+      } else if (onStack.has(target)) {
+        lowLinks.set(
+          callId,
+          Math.min(lowLinks.get(callId)!, indexes.get(target)!),
+        );
+      }
+    }
+
+    if (lowLinks.get(callId) !== indexes.get(callId)) return;
+    const component: string[] = [];
+    let member: string;
+    do {
+      member = stack.pop()!;
+      onStack.delete(member);
+      component.push(member);
+    } while (member !== callId);
+
+    const selfLoop =
+      component.length === 1 && adjacency.get(callId)?.includes(callId);
+    if (component.length > 1 || selfLoop) {
+      component.sort((left, right) => order.get(left)! - order.get(right)!);
+      cycles.push(component);
+    }
+  };
+
+  for (const node of nodes) {
+    if (!indexes.has(node.callId)) visit(node.callId);
+  }
+  cycles.sort((left, right) => order.get(left[0]!)! - order.get(right[0]!)!);
+  return cycles.map(
+    (callIds): WorkflowGraphDiagnostic => ({
+      code: "cycle",
+      callIds,
+    }),
+  );
+}
+
+export function projectWorkflowGraph<Record extends WorkflowGraphRecord>(
+  records: readonly Record[],
+  limits: WorkflowGraphProjectionLimits = {},
+) {
+  const maxNodes = boundedLimit(limits.maxNodes, WORKFLOW_GRAPH_MAX_NODES);
+  const maxEdges = boundedLimit(limits.maxEdges, WORKFLOW_GRAPH_MAX_EDGES);
+  const maxDiagnostics = boundedLimit(
+    limits.maxDiagnostics,
+    WORKFLOW_GRAPH_MAX_DIAGNOSTICS,
+  );
+  const sorted = [...records].sort(compareRecords);
+  const diagnostics: WorkflowGraphDiagnostic[] = [];
+  let diagnosticCount = 0;
+  const addDiagnostic = (diagnostic: WorkflowGraphDiagnostic) => {
+    diagnosticCount++;
+    if (diagnostics.length < maxDiagnostics) diagnostics.push(diagnostic);
+  };
+  const canonical = new Map<string, WorkflowGraphRecord>();
+  for (const record of sorted) {
+    const kept = canonical.get(record.callId);
+    if (kept) {
+      addDiagnostic({
+        code: "duplicate_call_id",
+        callId: record.callId,
+        keptIndex: kept.index,
+        duplicateIndex: record.index,
+      });
+    } else {
+      canonical.set(record.callId, record);
+    }
+  }
+
+  const uniqueRecords = [...canonical.values()];
+  const nodes = uniqueRecords.slice(0, maxNodes).map(toNode);
+  const visibleCallIds = new Set(nodes.map((node) => node.callId));
+  const edges: WorkflowGraphEdge[] = [];
+  let edgeCount = 0;
+  for (const record of uniqueRecords) {
+    const seenInputs = new Set<string>();
+    for (const source of record.inputCallIds ?? []) {
+      if (seenInputs.has(source)) {
+        addDiagnostic({
+          code: "duplicate_input_call",
+          source,
+          target: record.callId,
+        });
+      } else if (!canonical.has(source)) {
+        addDiagnostic({
+          code: "missing_input_call",
+          source,
+          target: record.callId,
+        });
+      } else {
+        edgeCount++;
+        if (
+          edges.length < maxEdges &&
+          visibleCallIds.has(source) &&
+          visibleCallIds.has(record.callId)
+        ) {
+          edges.push({ source, target: record.callId });
+        }
+      }
+      seenInputs.add(source);
+    }
+  }
+  for (const cycle of findCycles(nodes, edges)) addDiagnostic(cycle);
+  const hasIncoming = new Set(edges.map((edge) => edge.target));
+  const hasOutgoing = new Set(edges.map((edge) => edge.source));
+
+  return {
+    schemaVersion: 1 as const,
+    coverage: "explicit_result_refs_only" as const,
+    nodes,
+    edges,
+    roots: nodes
+      .filter((node) => !hasIncoming.has(node.callId))
+      .map((node) => node.callId),
+    sinks: nodes
+      .filter((node) => !hasOutgoing.has(node.callId))
+      .map((node) => node.callId),
+    diagnostics,
+    omitted: {
+      nodes: uniqueRecords.length - nodes.length,
+      edges: edgeCount - edges.length,
+      diagnostics: diagnosticCount - diagnostics.length,
+    },
+  };
+}
+
+export type WorkflowGraphProjection = ReturnType<typeof projectWorkflowGraph>;