@contractspec/example.workflow-system 3.7.6 → 3.8.2

package/dist/browser/index.js

@@ -19,7 +19,7 @@ var ApprovalDecisionEnum = defineEnum("ApprovalDecision", [
 
 // src/approval/approval.event.ts
 import { defineEvent } from "@contractspec/lib.contracts-spec";
-import { ScalarTypeEnum, defineSchemaModel } from "@contractspec/lib.schema";
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
 var ApprovalRequestedPayload = defineSchemaModel({
   name: "ApprovalRequestedEventPayload",
   description: "Payload when approval is requested",
@@ -715,9 +715,19 @@ function rowToApproval(row) {
   };
 }
 function createWorkflowHandlers(db) {
+  function normalizeSql(sql) {
+    let placeholderIndex = 0;
+    return sql.replace(/\?/g, () => `$${++placeholderIndex}`);
+  }
+  async function queryRows(sql, params = []) {
+    return (await db.query(normalizeSql(sql), params)).rows;
+  }
+  async function execute(sql, params = []) {
+    await db.execute(normalizeSql(sql), params);
+  }
   async function listDefinitions(input) {
     const { projectId, status, search, limit = 20, offset = 0 } = input;
-    let whereClause = "WHERE projectId = ?";
+    let whereClause = 'WHERE "projectId" = ?';
     const params = [projectId];
     if (status && status !== "all") {
       whereClause += " AND status = ?";
@@ -727,9 +737,9 @@ function createWorkflowHandlers(db) {
       whereClause += " AND name LIKE ?";
       params.push(`%${search}%`);
     }
-    const countResult = (await db.query(`SELECT COUNT(*) as count FROM workflow_definition ${whereClause}`, params)).rows;
+    const countResult = await queryRows(`SELECT COUNT(*) as count FROM workflow_definition ${whereClause}`, params);
     const total = countResult[0]?.count ?? 0;
-    const rows = (await db.query(`SELECT * FROM workflow_definition ${whereClause} ORDER BY updatedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_definition ${whereClause} ORDER BY "updatedAt" DESC LIMIT ? OFFSET ?`, [...params, limit, offset]);
     return {
       definitions: rows.map(rowToDefinition),
       total
@@ -738,7 +748,7 @@ function createWorkflowHandlers(db) {
   async function createDefinition(input, context) {
     const id = generateId("wfdef");
     const now = new Date().toISOString();
-    await db.execute(`INSERT INTO workflow_definition (id, projectId, organizationId, name, description, type, status, createdAt, updatedAt)
+    await execute(`INSERT INTO workflow_definition (id, "projectId", "organizationId", name, description, type, status, "createdAt", "updatedAt")
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
       id,
       context.projectId,
@@ -750,15 +760,15 @@ function createWorkflowHandlers(db) {
       now,
       now
     ]);
-    const rows = (await db.query(`SELECT * FROM workflow_definition WHERE id = ?`, [id])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_definition WHERE id = ?`, [id]);
     return rowToDefinition(rows[0]);
   }
   async function addStep(input) {
     const id = generateId("wfstep");
     const now = new Date().toISOString();
-    const maxOrderResult = (await db.query(`SELECT MAX(stepOrder) as maxOrder FROM workflow_step WHERE definitionId = ?`, [input.definitionId])).rows;
+    const maxOrderResult = await queryRows(`SELECT MAX("stepOrder") as maxOrder FROM workflow_step WHERE "definitionId" = ?`, [input.definitionId]);
     const nextOrder = (maxOrderResult[0]?.maxOrder ?? 0) + 1;
-    await db.execute(`INSERT INTO workflow_step (id, definitionId, name, description, stepOrder, type, requiredRoles, autoApproveCondition, timeoutHours, createdAt)
+    await execute(`INSERT INTO workflow_step (id, "definitionId", name, description, "stepOrder", type, "requiredRoles", "autoApproveCondition", "timeoutHours", "createdAt")
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
       id,
       input.definitionId,
@@ -771,11 +781,11 @@ function createWorkflowHandlers(db) {
       input.timeoutHours ?? null,
       now
     ]);
-    const rows = (await db.query(`SELECT * FROM workflow_step WHERE id = ?`, [id])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_step WHERE id = ?`, [id]);
     return rowToStep(rows[0]);
   }
   async function getSteps(definitionId) {
-    const rows = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? ORDER BY stepOrder`, [definitionId])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_step WHERE "definitionId" = ? ORDER BY "stepOrder"`, [definitionId]);
     return rows.map(rowToStep);
   }
   async function listInstances(input) {
@@ -787,10 +797,10 @@ function createWorkflowHandlers(db) {
       limit = 20,
       offset = 0
     } = input;
-    let whereClause = "WHERE projectId = ?";
+    let whereClause = 'WHERE "projectId" = ?';
     const params = [projectId];
     if (definitionId) {
-      whereClause += " AND definitionId = ?";
+      whereClause += ' AND "definitionId" = ?';
       params.push(definitionId);
     }
     if (status && status !== "all") {
@@ -798,12 +808,12 @@ function createWorkflowHandlers(db) {
       params.push(status);
     }
     if (requestedBy) {
-      whereClause += " AND requestedBy = ?";
+      whereClause += ' AND "requestedBy" = ?';
       params.push(requestedBy);
     }
-    const countResult = (await db.query(`SELECT COUNT(*) as count FROM workflow_instance ${whereClause}`, params)).rows;
+    const countResult = await queryRows(`SELECT COUNT(*) as count FROM workflow_instance ${whereClause}`, params);
     const total = countResult[0]?.count ?? 0;
-    const rows = (await db.query(`SELECT * FROM workflow_instance ${whereClause} ORDER BY startedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_instance ${whereClause} ORDER BY "startedAt" DESC LIMIT ? OFFSET ?`, [...params, limit, offset]);
     return {
       instances: rows.map(rowToInstance),
       total
@@ -812,9 +822,9 @@ function createWorkflowHandlers(db) {
   async function startInstance(input, context) {
     const id = generateId("wfinst");
     const now = new Date().toISOString();
-    const steps = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? ORDER BY stepOrder LIMIT 1`, [input.definitionId])).rows;
+    const steps = await queryRows(`SELECT * FROM workflow_step WHERE "definitionId" = ? ORDER BY "stepOrder" LIMIT 1`, [input.definitionId]);
     const firstStepId = steps[0]?.id ?? null;
-    await db.execute(`INSERT INTO workflow_instance (id, projectId, definitionId, status, currentStepId, data, requestedBy, startedAt)
+    await execute(`INSERT INTO workflow_instance (id, "projectId", "definitionId", status, "currentStepId", data, "requestedBy", "startedAt")
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
       id,
       context.projectId,
@@ -826,36 +836,32 @@ function createWorkflowHandlers(db) {
       now
     ]);
     if (firstStepId) {
-      await db.execute(`INSERT INTO workflow_approval (id, instanceId, stepId, status, createdAt)
+      await execute(`INSERT INTO workflow_approval (id, "instanceId", "stepId", status, "createdAt")
          VALUES (?, ?, ?, ?, ?)`, [generateId("wfappr"), id, firstStepId, "PENDING", now]);
     }
-    const rows = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [id])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [id]);
     return rowToInstance(rows[0]);
   }
   async function approveStep(input, context) {
     const now = new Date().toISOString();
-    const instances = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
-      input.instanceId
-    ])).rows;
+    const instances = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [input.instanceId]);
     if (!instances[0]) {
       throw new Error("NOT_FOUND");
     }
     const instance = instances[0];
-    await db.execute(`UPDATE workflow_approval SET status = 'APPROVED', actorId = ?, comment = ?, decidedAt = ? 
-       WHERE instanceId = ? AND stepId = ? AND status = 'PENDING'`, [
+    await execute(`UPDATE workflow_approval SET status = 'APPROVED', "actorId" = ?, comment = ?, "decidedAt" = ? 
+       WHERE "instanceId" = ? AND "stepId" = ? AND status = 'PENDING'`, [
       context.actorId,
       input.comment ?? null,
       now,
       input.instanceId,
       instance.currentStepId
     ]);
-    const currentStep = (await db.query(`SELECT * FROM workflow_step WHERE id = ?`, [
-      instance.currentStepId
-    ])).rows;
-    const nextSteps = (await db.query(`SELECT * FROM workflow_step WHERE definitionId = ? AND stepOrder > ? ORDER BY stepOrder LIMIT 1`, [instance.definitionId, currentStep[0]?.stepOrder ?? 0])).rows;
+    const currentStep = await queryRows(`SELECT * FROM workflow_step WHERE id = ?`, [instance.currentStepId]);
+    const nextSteps = await queryRows(`SELECT * FROM workflow_step WHERE "definitionId" = ? AND "stepOrder" > ? ORDER BY "stepOrder" LIMIT 1`, [instance.definitionId, currentStep[0]?.stepOrder ?? 0]);
     if (nextSteps[0]) {
-      await db.execute(`UPDATE workflow_instance SET currentStepId = ? WHERE id = ?`, [nextSteps[0].id, input.instanceId]);
-      await db.execute(`INSERT INTO workflow_approval (id, instanceId, stepId, status, createdAt)
+      await execute(`UPDATE workflow_instance SET "currentStepId" = ? WHERE id = ?`, [nextSteps[0].id, input.instanceId]);
+      await execute(`INSERT INTO workflow_approval (id, "instanceId", "stepId", status, "createdAt")
          VALUES (?, ?, ?, ?, ?)`, [
         generateId("wfappr"),
         input.instanceId,
@@ -864,37 +870,31 @@ function createWorkflowHandlers(db) {
         now
       ]);
     } else {
-      await db.execute(`UPDATE workflow_instance SET status = 'COMPLETED', currentStepId = NULL, completedAt = ? WHERE id = ?`, [now, input.instanceId]);
+      await execute(`UPDATE workflow_instance SET status = 'COMPLETED', "currentStepId" = NULL, "completedAt" = ? WHERE id = ?`, [now, input.instanceId]);
     }
-    const updated = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
-      input.instanceId
-    ])).rows;
+    const updated = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [input.instanceId]);
     return rowToInstance(updated[0]);
   }
   async function rejectStep(input, context) {
     const now = new Date().toISOString();
-    const instances = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
-      input.instanceId
-    ])).rows;
+    const instances = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [input.instanceId]);
     if (!instances[0]) {
       throw new Error("NOT_FOUND");
     }
-    await db.execute(`UPDATE workflow_approval SET status = 'REJECTED', actorId = ?, comment = ?, decidedAt = ? 
-       WHERE instanceId = ? AND stepId = ? AND status = 'PENDING'`, [
+    await execute(`UPDATE workflow_approval SET status = 'REJECTED', "actorId" = ?, comment = ?, "decidedAt" = ? 
+       WHERE "instanceId" = ? AND "stepId" = ? AND status = 'PENDING'`, [
       context.actorId,
       input.reason,
       now,
       input.instanceId,
       instances[0].currentStepId
     ]);
-    await db.execute(`UPDATE workflow_instance SET status = 'REJECTED', completedAt = ? WHERE id = ?`, [now, input.instanceId]);
-    const updated = (await db.query(`SELECT * FROM workflow_instance WHERE id = ?`, [
-      input.instanceId
-    ])).rows;
+    await execute(`UPDATE workflow_instance SET status = 'REJECTED', "completedAt" = ? WHERE id = ?`, [now, input.instanceId]);
+    const updated = await queryRows(`SELECT * FROM workflow_instance WHERE id = ?`, [input.instanceId]);
     return rowToInstance(updated[0]);
   }
   async function getApprovals(instanceId) {
-    const rows = (await db.query(`SELECT * FROM workflow_approval WHERE instanceId = ? ORDER BY createdAt`, [instanceId])).rows;
+    const rows = await queryRows(`SELECT * FROM workflow_approval WHERE "instanceId" = ? ORDER BY "createdAt"`, [instanceId]);
     return rows.map(rowToApproval);
   }
   return {
@@ -910,398 +910,596 @@ function createWorkflowHandlers(db) {
   };
 }
 
-// src/workflow/workflow.enum.ts
+// src/instance/instance.enum.ts
 import { defineEnum as defineEnum2 } from "@contractspec/lib.schema";
-var WorkflowStatusEnum = defineEnum2("WorkflowStatus", [
-  "DRAFT",
-  "ACTIVE",
-  "DEPRECATED",
-  "ARCHIVED"
-]);
-var TriggerTypeEnum = defineEnum2("WorkflowTriggerType", [
-  "MANUAL",
-  "EVENT",
-  "SCHEDULED",
-  "API"
-]);
-var StepTypeEnum = defineEnum2("StepType", [
-  "START",
-  "APPROVAL",
-  "TASK",
-  "CONDITION",
-  "PARALLEL",
-  "WAIT",
-  "ACTION",
-  "END"
-]);
-var ApprovalModeEnum = defineEnum2("ApprovalMode", [
-  "ANY",
-  "ALL",
-  "MAJORITY",
-  "SEQUENTIAL"
+var InstanceStatusEnum = defineEnum2("InstanceStatus", [
+  "PENDING",
+  "RUNNING",
+  "WAITING",
+  "PAUSED",
+  "COMPLETED",
+  "CANCELLED",
+  "FAILED",
+  "TIMEOUT"
 ]);
 
-// src/workflow/workflow.schema.ts
+// src/instance/instance.event.ts
+import { defineEvent as defineEvent2 } from "@contractspec/lib.contracts-spec";
 import { defineSchemaModel as defineSchemaModel4, ScalarTypeEnum as ScalarTypeEnum4 } from "@contractspec/lib.schema";
-var WorkflowStepModel = defineSchemaModel4({
-  name: "WorkflowStepModel",
-  description: "A step in a workflow definition",
-  fields: {
-    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    key: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    type: { type: StepTypeEnum, isOptional: false },
-    position: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
-    transitions: { type: ScalarTypeEnum4.JSON(), isOptional: false },
-    approvalMode: { type: ApprovalModeEnum, isOptional: true },
-    approverRoles: {
-      type: ScalarTypeEnum4.String_unsecure(),
-      isArray: true,
-      isOptional: true
-    }
-  }
-});
-var WorkflowDefinitionModel = defineSchemaModel4({
-  name: "WorkflowDefinitionModel",
-  description: "A workflow definition",
+var InstanceEventPayload = defineSchemaModel4({
+  name: "InstanceEventPayload",
+  description: "Base payload for instance events",
   fields: {
-    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    key: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    version: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    status: { type: WorkflowStatusEnum, isOptional: false },
-    triggerType: { type: TriggerTypeEnum, isOptional: false },
-    initialStepId: {
-      type: ScalarTypeEnum4.String_unsecure(),
-      isOptional: true
-    },
-    featureFlagKey: {
+    instanceId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    workflowKey: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    referenceId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    referenceType: {
       type: ScalarTypeEnum4.String_unsecure(),
       isOptional: true
     },
+    triggeredBy: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
     organizationId: {
       type: ScalarTypeEnum4.String_unsecure(),
       isOptional: false
     },
-    createdAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
-    updatedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
-    steps: { type: WorkflowStepModel, isArray: true, isOptional: true }
+    timestamp: { type: ScalarTypeEnum4.DateTime(), isOptional: false }
   }
 });
-var CreateWorkflowInputModel = defineSchemaModel4({
-  name: "CreateWorkflowInput",
-  description: "Input for creating a workflow definition",
+var StepTransitionPayload = defineSchemaModel4({
+  name: "StepTransitionEventPayload",
+  description: "Payload for step transition events",
   fields: {
-    name: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
-    key: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
-    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    triggerType: { type: TriggerTypeEnum, isOptional: true },
-    triggerConfig: { type: ScalarTypeEnum4.JSON(), isOptional: true },
-    featureFlagKey: {
+    instanceId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    fromStepKey: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    toStepKey: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    action: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    executedBy: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum4.DateTime(), isOptional: false }
+  }
+});
+var InstanceCompletedPayload = defineSchemaModel4({
+  name: "InstanceCompletedEventPayload",
+  description: "Payload when instance completes",
+  fields: {
+    instanceId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    workflowKey: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    outcome: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    referenceId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    referenceType: {
       type: ScalarTypeEnum4.String_unsecure(),
       isOptional: true
     },
-    settings: { type: ScalarTypeEnum4.JSON(), isOptional: true }
+    duration: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum4.DateTime(), isOptional: false }
   }
 });
-var UpdateWorkflowInputModel = defineSchemaModel4({
-  name: "UpdateWorkflowInput",
-  description: "Input for updating a workflow definition",
+var InstanceStartedEvent = defineEvent2({
+  meta: {
+    key: "workflow.instance.started",
+    version: "1.0.0",
+    description: "A new workflow instance has been started.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "started"]
+  },
+  payload: InstanceEventPayload
+});
+var StepEnteredEvent = defineEvent2({
+  meta: {
+    key: "workflow.step.entered",
+    version: "1.0.0",
+    description: "A workflow instance has entered a new step.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "step", "entered"]
+  },
+  payload: StepTransitionPayload
+});
+var StepExitedEvent = defineEvent2({
+  meta: {
+    key: "workflow.step.exited",
+    version: "1.0.0",
+    description: "A workflow instance has exited a step.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "step", "exited"]
+  },
+  payload: StepTransitionPayload
+});
+var InstanceCompletedEvent = defineEvent2({
+  meta: {
+    key: "workflow.instance.completed",
+    version: "1.0.0",
+    description: "A workflow instance has completed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "completed"]
+  },
+  payload: InstanceCompletedPayload
+});
+var InstanceCancelledEvent = defineEvent2({
+  meta: {
+    key: "workflow.instance.cancelled",
+    version: "1.0.0",
+    description: "A workflow instance has been cancelled.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "cancelled"]
+  },
+  payload: InstanceEventPayload
+});
+var InstancePausedEvent = defineEvent2({
+  meta: {
+    key: "workflow.instance.paused",
+    version: "1.0.0",
+    description: "A workflow instance has been paused.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "paused"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceResumedEvent = defineEvent2({
+  meta: {
+    key: "workflow.instance.resumed",
+    version: "1.0.0",
+    description: "A workflow instance has been resumed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "resumed"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceFailedEvent = defineEvent2({
+  meta: {
+    key: "workflow.instance.failed",
+    version: "1.0.0",
+    description: "A workflow instance has failed.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "failed"]
+  },
+  payload: InstanceEventPayload
+});
+var InstanceTimedOutEvent = defineEvent2({
+  meta: {
+    key: "workflow.instance.timedOut",
+    version: "1.0.0",
+    description: "A workflow instance has timed out.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "timeout"]
+  },
+  payload: InstanceEventPayload
+});
+
+// src/instance/instance.schema.ts
+import { defineSchemaModel as defineSchemaModel5, ScalarTypeEnum as ScalarTypeEnum5 } from "@contractspec/lib.schema";
+var WorkflowInstanceModel = defineSchemaModel5({
+  name: "WorkflowInstanceModel",
+  description: "A running workflow instance",
   fields: {
-    workflowId: {
-      type: ScalarTypeEnum4.String_unsecure(),
+    id: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    workflowDefinitionId: {
+      type: ScalarTypeEnum5.String_unsecure(),
       isOptional: false
     },
-    name: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    triggerType: { type: TriggerTypeEnum, isOptional: true },
-    triggerConfig: { type: ScalarTypeEnum4.JSON(), isOptional: true },
-    featureFlagKey: {
-      type: ScalarTypeEnum4.String_unsecure(),
+    referenceId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum5.String_unsecure(),
+      isOptional: true
+    },
+    status: { type: InstanceStatusEnum, isOptional: false },
+    currentStepId: {
+      type: ScalarTypeEnum5.String_unsecure(),
+      isOptional: true
+    },
+    contextData: { type: ScalarTypeEnum5.JSON(), isOptional: true },
+    triggeredBy: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum5.String_unsecure(),
+      isOptional: false
+    },
+    priority: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false },
+    dueAt: { type: ScalarTypeEnum5.DateTime(), isOptional: true },
+    outcome: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+    resultData: { type: ScalarTypeEnum5.JSON(), isOptional: true },
+    errorMessage: {
+      type: ScalarTypeEnum5.String_unsecure(),
       isOptional: true
     },
-    settings: { type: ScalarTypeEnum4.JSON(), isOptional: true }
+    createdAt: { type: ScalarTypeEnum5.DateTime(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum5.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum5.DateTime(), isOptional: true }
   }
 });
-var AddStepInputModel = defineSchemaModel4({
-  name: "AddStepInput",
-  description: "Input for adding a step to a workflow",
+var StartWorkflowInputModel = defineSchemaModel5({
+  name: "StartWorkflowInput",
+  description: "Input for starting a workflow",
   fields: {
-    workflowId: {
-      type: ScalarTypeEnum4.String_unsecure(),
-      isOptional: false
+    workflowKey: { type: ScalarTypeEnum5.NonEmptyString(), isOptional: false },
+    contextData: { type: ScalarTypeEnum5.JSON(), isOptional: true },
+    referenceId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+    referenceType: {
+      type: ScalarTypeEnum5.String_unsecure(),
+      isOptional: true
     },
-    key: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
-    name: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
-    description: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    type: { type: StepTypeEnum, isOptional: false },
-    position: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true },
-    transitions: { type: ScalarTypeEnum4.JSON(), isOptional: false },
-    approvalMode: { type: ApprovalModeEnum, isOptional: true },
-    approverRoles: {
-      type: ScalarTypeEnum4.String_unsecure(),
-      isArray: true,
+    priority: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: true },
+    dueAt: { type: ScalarTypeEnum5.DateTime(), isOptional: true }
+  }
+});
+var TransitionInputModel = defineSchemaModel5({
+  name: "TransitionInput",
+  description: "Input for transitioning a workflow",
+  fields: {
+    instanceId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    action: { type: ScalarTypeEnum5.NonEmptyString(), isOptional: false },
+    data: { type: ScalarTypeEnum5.JSON(), isOptional: true },
+    comment: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true }
+  }
+});
+var TransitionResultModel = defineSchemaModel5({
+  name: "TransitionResult",
+  description: "Result of a workflow transition",
+  fields: {
+    success: { type: ScalarTypeEnum5.Boolean(), isOptional: false },
+    instance: { type: WorkflowInstanceModel, isOptional: false },
+    previousStepKey: {
+      type: ScalarTypeEnum5.String_unsecure(),
       isOptional: true
     },
-    approverUserIds: {
-      type: ScalarTypeEnum4.String_unsecure(),
-      isArray: true,
+    currentStepKey: {
+      type: ScalarTypeEnum5.String_unsecure(),
       isOptional: true
     },
-    timeoutSeconds: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true },
-    slaSeconds: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true }
+    message: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true }
   }
 });
 
-// src/workflow/workflow.operations.ts
+// src/instance/instance.operations.ts
 import {
   defineCommand as defineCommand2,
   defineQuery as defineQuery2
 } from "@contractspec/lib.contracts-spec/operations";
-import { defineSchemaModel as defineSchemaModel5, ScalarTypeEnum as ScalarTypeEnum5 } from "@contractspec/lib.schema";
+import { defineSchemaModel as defineSchemaModel6, ScalarTypeEnum as ScalarTypeEnum6 } from "@contractspec/lib.schema";
 var OWNERS2 = ["@example.workflow-system"];
-var CreateWorkflowContract = defineCommand2({
+var StartWorkflowContract = defineCommand2({
   meta: {
-    key: "workflow.definition.create",
+    key: "workflow.instance.start",
     version: "1.0.0",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["workflow", "definition", "create"],
-    description: "Create a new workflow definition.",
-    goal: "Allow users to define new workflow blueprints.",
-    context: "Workflow designer, admin panel."
+    tags: ["workflow", "instance", "start"],
+    description: "Start a new workflow instance.",
+    goal: "Initiate a workflow for a business process.",
+    context: "Order creation, request submission, etc."
   },
   io: {
-    input: CreateWorkflowInputModel,
-    output: WorkflowDefinitionModel
+    input: StartWorkflowInputModel,
+    output: WorkflowInstanceModel
   },
   policy: { auth: "user" },
   sideEffects: {
     emits: [
       {
-        key: "workflow.definition.created",
+        key: "workflow.instance.started",
         version: "1.0.0",
-        when: "Workflow is created",
-        payload: WorkflowDefinitionModel
+        when: "Workflow starts",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.step.entered",
+        version: "1.0.0",
+        when: "First step entered",
+        payload: WorkflowInstanceModel
       }
     ],
-    audit: ["workflow.definition.created"]
+    audit: ["workflow.instance.started"]
   },
   acceptance: {
     scenarios: [
       {
-        key: "create-workflow-happy-path",
-        given: ["User is admin"],
-        when: ["User creates new workflow definition"],
-        then: [
-          "Definition is created",
-          "WorkflowDefinitionCreated event is emitted"
-        ]
+        key: "start-workflow-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User starts workflow"],
+        then: ["Instance is created and started"]
       }
     ],
     examples: [
       {
-        key: "create-onboarding",
+        key: "start-onboarding",
         input: {
-          key: "onboarding-v1",
-          name: "Employee Onboarding",
-          version: "1.0.0"
+          workflowKey: "onboarding-v1",
+          context: { employeeId: "emp-123" }
         },
-        output: { id: "def-123", status: "draft" }
+        output: { id: "inst-456", status: "running" }
       }
     ]
   }
 });
-var UpdateWorkflowContract = defineCommand2({
+var TransitionWorkflowContract = defineCommand2({
   meta: {
-    key: "workflow.definition.update",
+    key: "workflow.instance.transition",
     version: "1.0.0",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["workflow", "definition", "update"],
-    description: "Update an existing workflow definition.",
-    goal: "Allow users to modify workflow blueprints.",
-    context: "Workflow designer."
+    tags: ["workflow", "instance", "transition", "state-machine"],
+    description: "Transition a workflow instance to the next step.",
+    goal: "Move workflow forward based on action.",
+    context: "Task completion, approval decisions."
   },
   io: {
-    input: UpdateWorkflowInputModel,
-    output: WorkflowDefinitionModel
+    input: TransitionInputModel,
+    output: TransitionResultModel
   },
   policy: { auth: "user" },
   sideEffects: {
     emits: [
       {
-        key: "workflow.definition.updated",
+        key: "workflow.step.exited",
         version: "1.0.0",
-        when: "Workflow is updated",
-        payload: WorkflowDefinitionModel
+        when: "Step is exited",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.step.entered",
+        version: "1.0.0",
+        when: "New step is entered",
+        payload: WorkflowInstanceModel
+      },
+      {
+        key: "workflow.instance.completed",
+        version: "1.0.0",
+        when: "Workflow reaches end",
+        payload: WorkflowInstanceModel
       }
     ],
-    audit: ["workflow.definition.updated"]
+    audit: ["workflow.instance.transitioned"]
   },
   acceptance: {
     scenarios: [
       {
-        key: "update-workflow-happy-path",
-        given: ["Workflow definition exists"],
-        when: ["User updates definition"],
-        then: [
-          "Definition is updated",
-          "WorkflowDefinitionUpdated event is emitted"
-        ]
+        key: "transition-workflow-happy-path",
+        given: ["Workflow instance is waiting at step"],
+        when: ["User provides input"],
+        then: ["Instance moves to next step"]
       }
     ],
     examples: [
       {
-        key: "update-name",
-        input: { workflowId: "def-123", name: "New Employee Onboarding" },
-        output: { id: "def-123", name: "New Employee Onboarding" }
+        key: "complete-task",
+        input: {
+          instanceId: "inst-456",
+          action: "complete",
+          data: { approved: true }
+        },
+        output: { success: true, nextStep: "notify-hr" }
       }
     ]
   }
 });
-var AddStepContract = defineCommand2({
+var PauseWorkflowContract = defineCommand2({
   meta: {
-    key: "workflow.step.add",
+    key: "workflow.instance.pause",
     version: "1.0.0",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["workflow", "step", "add"],
-    description: "Add a step to a workflow definition.",
-    goal: "Build workflow structure step by step.",
-    context: "Workflow designer."
+    tags: ["workflow", "instance", "pause"],
+    description: "Pause a running workflow instance.",
+    goal: "Temporarily halt workflow execution.",
+    context: "Administrative action, emergency stop."
   },
   io: {
-    input: AddStepInputModel,
-    output: WorkflowStepModel
+    input: defineSchemaModel6({
+      name: "PauseResumeInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum6.String_unsecure(),
+          isOptional: false
+        },
+        reason: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: WorkflowInstanceModel
   },
   policy: { auth: "user" },
   sideEffects: {
     emits: [
       {
-        key: "workflow.step.added",
+        key: "workflow.instance.paused",
         version: "1.0.0",
-        when: "Step is added",
-        payload: WorkflowStepModel
+        when: "Workflow is paused",
+        payload: WorkflowInstanceModel
       }
     ],
-    audit: ["workflow.step.added"]
+    audit: ["workflow.instance.paused"]
   },
   acceptance: {
     scenarios: [
       {
-        key: "add-step-happy-path",
-        given: ["Workflow definition exists"],
-        when: ["User adds a step"],
-        then: ["Step is added", "StepAdded event is emitted"]
+        key: "pause-workflow-happy-path",
+        given: ["Workflow is running"],
+        when: ["Admin pauses workflow"],
+        then: ["Instance status becomes PAUSED"]
       }
     ],
     examples: [
       {
-        key: "add-approval-step",
-        input: {
-          workflowId: "def-123",
-          stepKey: "approve-contract",
-          type: "approval"
+        key: "pause-maintenance",
+        input: { instanceId: "inst-456", reason: "System maintenance" },
+        output: { id: "inst-456", status: "paused" }
+      }
+    ]
+  }
+});
+var ResumeWorkflowContract = defineCommand2({
+  meta: {
+    key: "workflow.instance.resume",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["workflow", "instance", "resume"],
+    description: "Resume a paused workflow instance.",
+    goal: "Continue workflow execution.",
+    context: "Administrative action."
+  },
+  io: {
+    input: defineSchemaModel6({
+      name: "PauseResumeInput",
+      fields: {
+        instanceId: {
+          type: ScalarTypeEnum6.String_unsecure(),
+          isOptional: false
         },
-        output: { id: "step-456", key: "approve-contract" }
+        reason: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: WorkflowInstanceModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.instance.resumed",
+        version: "1.0.0",
+        when: "Workflow is resumed",
+        payload: WorkflowInstanceModel
+      }
+    ],
+    audit: ["workflow.instance.resumed"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "resume-workflow-happy-path",
+        given: ["Workflow is paused"],
+        when: ["Admin resumes workflow"],
+        then: ["Instance status becomes RUNNING"]
+      }
+    ],
+    examples: [
+      {
+        key: "resume-normal",
+        input: { instanceId: "inst-456", reason: "Issue resolved" },
+        output: { id: "inst-456", status: "running" }
       }
     ]
   }
 });
-var PublishWorkflowContract = defineCommand2({
+var CancelWorkflowContract = defineCommand2({
   meta: {
-    key: "workflow.definition.publish",
+    key: "workflow.instance.cancel",
     version: "1.0.0",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["workflow", "definition", "publish"],
-    description: "Publish a workflow definition to make it available for use.",
-    goal: "Activate workflow for production use.",
-    context: "Workflow designer, deployment."
+    tags: ["workflow", "instance", "cancel"],
+    description: "Cancel a workflow instance.",
+    goal: "Terminate workflow without completion.",
+    context: "User request, system cancellation."
   },
   io: {
-    input: defineSchemaModel5({
-      name: "PublishWorkflowInput",
+    input: defineSchemaModel6({
+      name: "CancelWorkflowInput",
       fields: {
-        workflowId: {
-          type: ScalarTypeEnum5.String_unsecure(),
+        instanceId: {
+          type: ScalarTypeEnum6.String_unsecure(),
+          isOptional: false
+        },
+        reason: {
+          type: ScalarTypeEnum6.String_unsecure(),
           isOptional: false
         }
       }
     }),
-    output: WorkflowDefinitionModel
+    output: WorkflowInstanceModel
   },
   policy: { auth: "user" },
   sideEffects: {
     emits: [
       {
-        key: "workflow.definition.published",
+        key: "workflow.instance.cancelled",
         version: "1.0.0",
-        when: "Workflow is published",
-        payload: WorkflowDefinitionModel
+        when: "Workflow is cancelled",
+        payload: WorkflowInstanceModel
       }
     ],
-    audit: ["workflow.definition.published"]
+    audit: ["workflow.instance.cancelled"]
   },
   acceptance: {
     scenarios: [
       {
-        key: "publish-workflow-happy-path",
-        given: ["Workflow definition is valid"],
-        when: ["User publishes workflow"],
-        then: ["Workflow becomes active", "WorkflowPublished event is emitted"]
+        key: "cancel-workflow-happy-path",
+        given: ["Workflow is running"],
+        when: ["User cancels workflow"],
+        then: ["Instance status becomes CANCELLED"]
       }
     ],
     examples: [
       {
-        key: "publish-onboarding",
-        input: { workflowId: "def-123" },
-        output: { id: "def-123", status: "published" }
+        key: "cancel-mistake",
+        input: { instanceId: "inst-456", reason: "Created by mistake" },
+        output: { id: "inst-456", status: "cancelled" }
       }
     ]
   }
 });
-var ListWorkflowsContract = defineQuery2({
+var ListInstancesContract = defineQuery2({
   meta: {
-    key: "workflow.definition.list",
+    key: "workflow.instance.list",
     version: "1.0.0",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["workflow", "definition", "list"],
-    description: "List workflow definitions with filtering.",
-    goal: "Browse and search available workflows.",
-    context: "Workflow list, search."
+    tags: ["workflow", "instance", "list"],
+    description: "List workflow instances with filtering.",
+    goal: "Browse and search running workflows.",
+    context: "Dashboard, monitoring."
   },
   io: {
-    input: defineSchemaModel5({
-      name: "ListWorkflowsInput",
+    input: defineSchemaModel6({
+      name: "ListInstancesInput",
       fields: {
-        status: { type: WorkflowStatusEnum, isOptional: true },
-        search: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+        workflowKey: {
+          type: ScalarTypeEnum6.String_unsecure(),
+          isOptional: true
+        },
+        status: { type: InstanceStatusEnum, isOptional: true },
+        referenceType: {
+          type: ScalarTypeEnum6.String_unsecure(),
+          isOptional: true
+        },
+        referenceId: {
+          type: ScalarTypeEnum6.String_unsecure(),
+          isOptional: true
+        },
+        triggeredBy: {
+          type: ScalarTypeEnum6.String_unsecure(),
+          isOptional: true
+        },
         limit: {
-          type: ScalarTypeEnum5.Int_unsecure(),
+          type: ScalarTypeEnum6.Int_unsecure(),
           isOptional: true,
           defaultValue: 20
         },
         offset: {
-          type: ScalarTypeEnum5.Int_unsecure(),
+          type: ScalarTypeEnum6.Int_unsecure(),
           isOptional: true,
           defaultValue: 0
         }
       }
     }),
-    output: defineSchemaModel5({
-      name: "ListWorkflowsOutput",
+    output: defineSchemaModel6({
+      name: "ListInstancesOutput",
       fields: {
-        workflows: {
-          type: WorkflowDefinitionModel,
+        instances: {
+          type: WorkflowInstanceModel,
           isArray: true,
           isOptional: false
         },
-        total: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false }
+        total: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: false }
       }
     })
   },
@@ -1309,1333 +1507,984 @@ var ListWorkflowsContract = defineQuery2({
   acceptance: {
     scenarios: [
       {
-        key: "list-workflows-happy-path",
-        given: ["Workflow definitions exist"],
-        when: ["User lists workflows"],
-        then: ["List of workflows is returned"]
+        key: "list-instances-happy-path",
+        given: ["Workflow instances exist"],
+        when: ["User lists instances"],
+        then: ["List of instances is returned"]
       }
     ],
     examples: [
       {
-        key: "list-all",
-        input: { limit: 10 },
-        output: { workflows: [], total: 5 }
+        key: "list-running",
+        input: { status: "running", limit: 10 },
+        output: { instances: [], total: 5 }
       }
     ]
   }
 });
-var GetWorkflowContract = defineQuery2({
+var GetInstanceContract = defineQuery2({
   meta: {
-    key: "workflow.definition.get",
+    key: "workflow.instance.get",
     version: "1.0.0",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["workflow", "definition", "get"],
-    description: "Get a workflow definition with all steps.",
-    goal: "View workflow details.",
-    context: "Workflow designer, detail view."
+    tags: ["workflow", "instance", "get"],
+    description: "Get a workflow instance with details.",
+    goal: "View workflow instance details.",
+    context: "Instance detail view."
   },
   io: {
-    input: defineSchemaModel5({
-      name: "GetWorkflowInput",
+    input: defineSchemaModel6({
+      name: "GetInstanceInput",
       fields: {
-        workflowId: {
-          type: ScalarTypeEnum5.String_unsecure(),
+        instanceId: {
+          type: ScalarTypeEnum6.String_unsecure(),
           isOptional: false
         }
       }
     }),
-    output: WorkflowDefinitionModel
+    output: WorkflowInstanceModel
   },
   policy: { auth: "user" },
   acceptance: {
     scenarios: [
       {
-        key: "get-workflow-happy-path",
-        given: ["Workflow definition exists"],
-        when: ["User requests workflow details"],
-        then: ["Workflow details are returned"]
+        key: "get-instance-happy-path",
+        given: ["Instance exists"],
+        when: ["User requests instance details"],
+        then: ["Instance details are returned"]
       }
     ],
     examples: [
       {
         key: "get-details",
-        input: { workflowId: "def-123" },
-        output: { id: "def-123", name: "Employee Onboarding" }
+        input: { instanceId: "inst-456" },
+        output: { id: "inst-456", workflowKey: "onboarding-v1" }
       }
     ]
   }
 });
-
-// src/workflow/workflow.event.ts
-import { defineEvent as defineEvent2 } from "@contractspec/lib.contracts-spec";
-import { ScalarTypeEnum as ScalarTypeEnum6, defineSchemaModel as defineSchemaModel6 } from "@contractspec/lib.schema";
-var WorkflowDefinitionPayload = defineSchemaModel6({
-  name: "WorkflowDefinitionEventPayload",
-  description: "Payload for workflow definition events",
-  fields: {
-    workflowId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    key: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    version: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum6.String_unsecure(),
-      isOptional: false
-    },
-    createdBy: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
-  }
-});
-var StepAddedPayload = defineSchemaModel6({
-  name: "StepAddedEventPayload",
-  description: "Payload when a step is added",
-  fields: {
-    stepId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    workflowId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    stepKey: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    stepType: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    position: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
-  }
-});
-var WorkflowCreatedEvent = defineEvent2({
-  meta: {
-    key: "workflow.definition.created",
-    version: "1.0.0",
-    description: "A new workflow definition has been created.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "definition", "created"]
-  },
-  payload: WorkflowDefinitionPayload
-});
-var WorkflowUpdatedEvent = defineEvent2({
-  meta: {
-    key: "workflow.definition.updated",
-    version: "1.0.0",
-    description: "A workflow definition has been updated.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "definition", "updated"]
-  },
-  payload: WorkflowDefinitionPayload
-});
-var WorkflowPublishedEvent = defineEvent2({
-  meta: {
-    key: "workflow.definition.published",
-    version: "1.0.0",
-    description: "A workflow definition has been published and is now active.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "definition", "published"]
-  },
-  payload: WorkflowDefinitionPayload
-});
-var StepAddedEvent = defineEvent2({
-  meta: {
-    key: "workflow.step.added",
-    version: "1.0.0",
-    description: "A step has been added to a workflow definition.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "step", "added"]
-  },
-  payload: StepAddedPayload
-});
-// src/instance/instance.enum.ts
+// src/workflow/workflow.enum.ts
 import { defineEnum as defineEnum3 } from "@contractspec/lib.schema";
-var InstanceStatusEnum = defineEnum3("InstanceStatus", [
-  "PENDING",
-  "RUNNING",
-  "WAITING",
-  "PAUSED",
-  "COMPLETED",
-  "CANCELLED",
-  "FAILED",
-  "TIMEOUT"
+var WorkflowStatusEnum = defineEnum3("WorkflowStatus", [
+  "DRAFT",
+  "ACTIVE",
+  "DEPRECATED",
+  "ARCHIVED"
+]);
+var TriggerTypeEnum = defineEnum3("WorkflowTriggerType", [
+  "MANUAL",
+  "EVENT",
+  "SCHEDULED",
+  "API"
+]);
+var StepTypeEnum = defineEnum3("StepType", [
+  "START",
+  "APPROVAL",
+  "TASK",
+  "CONDITION",
+  "PARALLEL",
+  "WAIT",
+  "ACTION",
+  "END"
+]);
+var ApprovalModeEnum = defineEnum3("ApprovalMode", [
+  "ANY",
+  "ALL",
+  "MAJORITY",
+  "SEQUENTIAL"
 ]);
 
-// src/instance/instance.schema.ts
+// src/workflow/workflow.schema.ts
 import { defineSchemaModel as defineSchemaModel7, ScalarTypeEnum as ScalarTypeEnum7 } from "@contractspec/lib.schema";
-var WorkflowInstanceModel = defineSchemaModel7({
-  name: "WorkflowInstanceModel",
-  description: "A running workflow instance",
+var WorkflowStepModel = defineSchemaModel7({
+  name: "WorkflowStepModel",
+  description: "A step in a workflow definition",
   fields: {
     id: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    workflowDefinitionId: {
+    key: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    type: { type: StepTypeEnum, isOptional: false },
+    position: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: false },
+    transitions: { type: ScalarTypeEnum7.JSON(), isOptional: false },
+    approvalMode: { type: ApprovalModeEnum, isOptional: true },
+    approverRoles: {
       type: ScalarTypeEnum7.String_unsecure(),
-      isOptional: false
-    },
-    referenceId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    referenceType: {
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var WorkflowDefinitionModel = defineSchemaModel7({
+  name: "WorkflowDefinitionModel",
+  description: "A workflow definition",
+  fields: {
+    id: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    key: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    version: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    status: { type: WorkflowStatusEnum, isOptional: false },
+    triggerType: { type: TriggerTypeEnum, isOptional: false },
+    initialStepId: {
       type: ScalarTypeEnum7.String_unsecure(),
       isOptional: true
     },
-    status: { type: InstanceStatusEnum, isOptional: false },
-    currentStepId: {
+    featureFlagKey: {
       type: ScalarTypeEnum7.String_unsecure(),
       isOptional: true
     },
-    contextData: { type: ScalarTypeEnum7.JSON(), isOptional: true },
-    triggeredBy: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
     organizationId: {
       type: ScalarTypeEnum7.String_unsecure(),
       isOptional: false
     },
-    priority: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: false },
-    dueAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true },
-    outcome: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    resultData: { type: ScalarTypeEnum7.JSON(), isOptional: true },
-    errorMessage: {
-      type: ScalarTypeEnum7.String_unsecure(),
-      isOptional: true
-    },
     createdAt: { type: ScalarTypeEnum7.DateTime(), isOptional: false },
-    startedAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true },
-    completedAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true }
+    updatedAt: { type: ScalarTypeEnum7.DateTime(), isOptional: false },
+    steps: { type: WorkflowStepModel, isArray: true, isOptional: true }
   }
 });
-var StartWorkflowInputModel = defineSchemaModel7({
-  name: "StartWorkflowInput",
-  description: "Input for starting a workflow",
+var CreateWorkflowInputModel = defineSchemaModel7({
+  name: "CreateWorkflowInput",
+  description: "Input for creating a workflow definition",
   fields: {
-    workflowKey: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
-    contextData: { type: ScalarTypeEnum7.JSON(), isOptional: true },
-    referenceId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    referenceType: {
+    name: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
+    key: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    triggerType: { type: TriggerTypeEnum, isOptional: true },
+    triggerConfig: { type: ScalarTypeEnum7.JSON(), isOptional: true },
+    featureFlagKey: {
       type: ScalarTypeEnum7.String_unsecure(),
       isOptional: true
     },
-    priority: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: true },
-    dueAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true }
+    settings: { type: ScalarTypeEnum7.JSON(), isOptional: true }
   }
 });
-var TransitionInputModel = defineSchemaModel7({
-  name: "TransitionInput",
-  description: "Input for transitioning a workflow",
+var UpdateWorkflowInputModel = defineSchemaModel7({
+  name: "UpdateWorkflowInput",
+  description: "Input for updating a workflow definition",
   fields: {
-    instanceId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    action: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
-    data: { type: ScalarTypeEnum7.JSON(), isOptional: true },
-    comment: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true }
+    workflowId: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    description: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    triggerType: { type: TriggerTypeEnum, isOptional: true },
+    triggerConfig: { type: ScalarTypeEnum7.JSON(), isOptional: true },
+    featureFlagKey: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: true
+    },
+    settings: { type: ScalarTypeEnum7.JSON(), isOptional: true }
   }
 });
-var TransitionResultModel = defineSchemaModel7({
-  name: "TransitionResult",
-  description: "Result of a workflow transition",
+var AddStepInputModel = defineSchemaModel7({
+  name: "AddStepInput",
+  description: "Input for adding a step to a workflow",
   fields: {
-    success: { type: ScalarTypeEnum7.Boolean(), isOptional: false },
-    instance: { type: WorkflowInstanceModel, isOptional: false },
-    previousStepKey: {
+    workflowId: {
+      type: ScalarTypeEnum7.String_unsecure(),
+      isOptional: false
+    },
+    key: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
+    name: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    type: { type: StepTypeEnum, isOptional: false },
+    position: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: true },
+    transitions: { type: ScalarTypeEnum7.JSON(), isOptional: false },
+    approvalMode: { type: ApprovalModeEnum, isOptional: true },
+    approverRoles: {
       type: ScalarTypeEnum7.String_unsecure(),
+      isArray: true,
       isOptional: true
     },
-    currentStepKey: {
+    approverUserIds: {
       type: ScalarTypeEnum7.String_unsecure(),
+      isArray: true,
       isOptional: true
     },
-    message: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true }
+    timeoutSeconds: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: true },
+    slaSeconds: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: true }
   }
 });
 
-// src/instance/instance.operations.ts
+// src/presentations/index.ts
 import {
-  defineCommand as defineCommand3,
-  defineQuery as defineQuery3
-} from "@contractspec/lib.contracts-spec/operations";
-import { defineSchemaModel as defineSchemaModel8, ScalarTypeEnum as ScalarTypeEnum8 } from "@contractspec/lib.schema";
-var OWNERS3 = ["@example.workflow-system"];
-var StartWorkflowContract = defineCommand3({
+  definePresentation,
+  StabilityEnum
+} from "@contractspec/lib.contracts-spec";
+var WorkflowDesignerPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.start",
+    key: "workflow.designer",
     version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS3],
-    tags: ["workflow", "instance", "start"],
-    description: "Start a new workflow instance.",
-    goal: "Initiate a workflow for a business process.",
-    context: "Order creation, request submission, etc."
+    title: "Workflow Designer",
+    description: "Visual workflow designer with drag-and-drop steps",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "designer", "admin"],
+    stability: StabilityEnum.Experimental,
+    goal: "Building and modifying workflow definitions",
+    context: "Workflow administration and setup"
   },
-  io: {
-    input: StartWorkflowInputModel,
-    output: WorkflowInstanceModel
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowDesigner",
+    props: WorkflowDefinitionModel
   },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "workflow.instance.started",
-        version: "1.0.0",
-        when: "Workflow starts",
-        payload: WorkflowInstanceModel
-      },
-      {
-        key: "workflow.step.entered",
-        version: "1.0.0",
-        when: "First step entered",
-        payload: WorkflowInstanceModel
-      }
-    ],
-    audit: ["workflow.instance.started"]
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.designer.enabled"]
+  }
+});
+var WorkflowListPresentation = definePresentation({
+  meta: {
+    key: "workflow.definition.viewList",
+    version: "1.0.0",
+    title: "Workflow List",
+    description: "List of workflow definitions with status and actions",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "list", "admin"],
+    stability: StabilityEnum.Experimental,
+    goal: "Overview of all defined workflows",
+    context: "Workflow management dashboard"
   },
-  acceptance: {
-    scenarios: [
-      {
-        key: "start-workflow-happy-path",
-        given: ["Workflow definition exists"],
-        when: ["User starts workflow"],
-        then: ["Instance is created and started"]
-      }
-    ],
-    examples: [
-      {
-        key: "start-onboarding",
-        input: {
-          workflowKey: "onboarding-v1",
-          context: { employeeId: "emp-123" }
-        },
-        output: { id: "inst-456", status: "running" }
-      }
-    ]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowDefinitionList",
+    props: WorkflowDefinitionModel
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
   }
 });
-var TransitionWorkflowContract = defineCommand3({
+var WorkflowDetailPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.transition",
+    key: "workflow.definition.detail",
     version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS3],
-    tags: ["workflow", "instance", "transition", "state-machine"],
-    description: "Transition a workflow instance to the next step.",
-    goal: "Move workflow forward based on action.",
-    context: "Task completion, approval decisions."
-  },
-  io: {
-    input: TransitionInputModel,
-    output: TransitionResultModel
+    title: "Workflow Details",
+    description: "Detailed view of a workflow definition with steps",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "detail"],
+    stability: StabilityEnum.Experimental,
+    goal: "Viewing technical details of a workflow definition",
+    context: "Workflow inspection and debugging"
   },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "workflow.step.exited",
-        version: "1.0.0",
-        when: "Step is exited",
-        payload: WorkflowInstanceModel
-      },
-      {
-        key: "workflow.step.entered",
-        version: "1.0.0",
-        when: "New step is entered",
-        payload: WorkflowInstanceModel
-      },
-      {
-        key: "workflow.instance.completed",
-        version: "1.0.0",
-        when: "Workflow reaches end",
-        payload: WorkflowInstanceModel
-      }
-    ],
-    audit: ["workflow.instance.transitioned"]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowDefinitionDetail",
+    props: WorkflowDefinitionModel
   },
-  acceptance: {
-    scenarios: [
-      {
-        key: "transition-workflow-happy-path",
-        given: ["Workflow instance is waiting at step"],
-        when: ["User provides input"],
-        then: ["Instance moves to next step"]
-      }
-    ],
-    examples: [
-      {
-        key: "complete-task",
-        input: {
-          instanceId: "inst-456",
-          action: "complete",
-          data: { approved: true }
-        },
-        output: { success: true, nextStep: "notify-hr" }
-      }
-    ]
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
   }
 });
-var PauseWorkflowContract = defineCommand3({
+var InstanceListPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.pause",
+    key: "workflow.instance.viewList",
     version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS3],
-    tags: ["workflow", "instance", "pause"],
-    description: "Pause a running workflow instance.",
-    goal: "Temporarily halt workflow execution.",
-    context: "Administrative action, emergency stop."
-  },
-  io: {
-    input: defineSchemaModel8({
-      name: "PauseResumeInput",
-      fields: {
-        instanceId: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: false
-        },
-        reason: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true }
-      }
-    }),
-    output: WorkflowInstanceModel
+    title: "Instance List",
+    description: "List of workflow instances with status and progress",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "list"],
+    stability: StabilityEnum.Experimental,
+    goal: "Monitoring active and past workflow executions",
+    context: "Operations monitoring"
   },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "workflow.instance.paused",
-        version: "1.0.0",
-        when: "Workflow is paused",
-        payload: WorkflowInstanceModel
-      }
-    ],
-    audit: ["workflow.instance.paused"]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowInstanceList",
+    props: WorkflowInstanceModel
   },
-  acceptance: {
-    scenarios: [
-      {
-        key: "pause-workflow-happy-path",
-        given: ["Workflow is running"],
-        when: ["Admin pauses workflow"],
-        then: ["Instance status becomes PAUSED"]
-      }
-    ],
-    examples: [
-      {
-        key: "pause-maintenance",
-        input: { instanceId: "inst-456", reason: "System maintenance" },
-        output: { id: "inst-456", status: "paused" }
-      }
-    ]
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
   }
 });
-var ResumeWorkflowContract = defineCommand3({
+var InstanceDetailPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.resume",
+    key: "workflow.instance.detail",
     version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS3],
-    tags: ["workflow", "instance", "resume"],
-    description: "Resume a paused workflow instance.",
-    goal: "Continue workflow execution.",
-    context: "Administrative action."
-  },
-  io: {
-    input: defineSchemaModel8({
-      name: "PauseResumeInput",
-      fields: {
-        instanceId: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: false
-        },
-        reason: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true }
-      }
-    }),
-    output: WorkflowInstanceModel
+    title: "Instance Details",
+    description: "Detailed view of a workflow instance with step timeline",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "instance", "detail", "timeline"],
+    stability: StabilityEnum.Experimental,
+    goal: "Detailed inspection of a specific workflow instance",
+    context: "Case management and troubleshooting"
   },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "workflow.instance.resumed",
-        version: "1.0.0",
-        when: "Workflow is resumed",
-        payload: WorkflowInstanceModel
-      }
-    ],
-    audit: ["workflow.instance.resumed"]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowInstanceDetail",
+    props: WorkflowInstanceModel
   },
-  acceptance: {
-    scenarios: [
-      {
-        key: "resume-workflow-happy-path",
-        given: ["Workflow is paused"],
-        when: ["Admin resumes workflow"],
-        then: ["Instance status becomes RUNNING"]
-      }
-    ],
-    examples: [
-      {
-        key: "resume-normal",
-        input: { instanceId: "inst-456", reason: "Issue resolved" },
-        output: { id: "inst-456", status: "running" }
-      }
-    ]
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
   }
 });
-var CancelWorkflowContract = defineCommand3({
+var ProgressTrackerPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.cancel",
+    key: "workflow.instance.progress",
     version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS3],
-    tags: ["workflow", "instance", "cancel"],
-    description: "Cancel a workflow instance.",
-    goal: "Terminate workflow without completion.",
-    context: "User request, system cancellation."
+    title: "Progress Tracker",
+    description: "Visual progress tracker showing current step in workflow",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "progress", "widget"],
+    stability: StabilityEnum.Experimental,
+    goal: "Quick view of current progress for a workflow",
+    context: "Embedded progress indicator in entity views"
   },
-  io: {
-    input: defineSchemaModel8({
-      name: "CancelWorkflowInput",
-      fields: {
-        instanceId: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: false
-        },
-        reason: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: false
-        }
-      }
-    }),
-    output: WorkflowInstanceModel
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowProgressTracker",
+    props: WorkflowInstanceModel
   },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "workflow.instance.cancelled",
-        version: "1.0.0",
-        when: "Workflow is cancelled",
-        payload: WorkflowInstanceModel
-      }
-    ],
-    audit: ["workflow.instance.cancelled"]
-  },
-  acceptance: {
-    scenarios: [
-      {
-        key: "cancel-workflow-happy-path",
-        given: ["Workflow is running"],
-        when: ["User cancels workflow"],
-        then: ["Instance status becomes CANCELLED"]
-      }
-    ],
-    examples: [
-      {
-        key: "cancel-mistake",
-        input: { instanceId: "inst-456", reason: "Created by mistake" },
-        output: { id: "inst-456", status: "cancelled" }
-      }
-    ]
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.enabled"]
   }
 });
-var ListInstancesContract = defineQuery3({
+var ApprovalInboxPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.list",
+    key: "workflow.approval.inbox",
     version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS3],
-    tags: ["workflow", "instance", "list"],
-    description: "List workflow instances with filtering.",
-    goal: "Browse and search running workflows.",
-    context: "Dashboard, monitoring."
+    title: "Approval Inbox",
+    description: "Inbox showing pending approval requests for current user",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "inbox"],
+    stability: StabilityEnum.Experimental,
+    goal: "Managing personal workload of approval requests",
+    context: "Personal task management"
   },
-  io: {
-    input: defineSchemaModel8({
-      name: "ListInstancesInput",
-      fields: {
-        workflowKey: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: true
-        },
-        status: { type: InstanceStatusEnum, isOptional: true },
-        referenceType: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: true
-        },
-        referenceId: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: true
-        },
-        triggeredBy: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: true
-        },
-        limit: {
-          type: ScalarTypeEnum8.Int_unsecure(),
-          isOptional: true,
-          defaultValue: 20
-        },
-        offset: {
-          type: ScalarTypeEnum8.Int_unsecure(),
-          isOptional: true,
-          defaultValue: 0
-        }
-      }
-    }),
-    output: defineSchemaModel8({
-      name: "ListInstancesOutput",
-      fields: {
-        instances: {
-          type: WorkflowInstanceModel,
-          isArray: true,
-          isOptional: false
-        },
-        total: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false }
-      }
-    })
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "ApprovalInbox",
+    props: ApprovalRequestModel
   },
-  policy: { auth: "user" },
-  acceptance: {
-    scenarios: [
-      {
-        key: "list-instances-happy-path",
-        given: ["Workflow instances exist"],
-        when: ["User lists instances"],
-        then: ["List of instances is returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "list-running",
-        input: { status: "running", limit: 10 },
-        output: { instances: [], total: 5 }
-      }
-    ]
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.approvals.enabled"]
   }
 });
-var GetInstanceContract = defineQuery3({
+var ApprovalDetailPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.get",
+    key: "workflow.approval.detail",
     version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS3],
-    tags: ["workflow", "instance", "get"],
-    description: "Get a workflow instance with details.",
-    goal: "View workflow instance details.",
-    context: "Instance detail view."
+    title: "Approval Details",
+    description: "Detailed approval request view with context and actions",
+    domain: "workflow-system",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "detail"],
+    stability: StabilityEnum.Experimental,
+    goal: "Decision support for an approval request",
+    context: "Specific approval action"
   },
-  io: {
-    input: defineSchemaModel8({
-      name: "GetInstanceInput",
-      fields: {
-        instanceId: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: false
-        }
-      }
-    }),
-    output: WorkflowInstanceModel
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "ApprovalRequestDetail",
+    props: ApprovalRequestModel
   },
-  policy: { auth: "user" },
-  acceptance: {
-    scenarios: [
-      {
-        key: "get-instance-happy-path",
-        given: ["Instance exists"],
-        when: ["User requests instance details"],
-        then: ["Instance details are returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "get-details",
-        input: { instanceId: "inst-456" },
-        output: { id: "inst-456", workflowKey: "onboarding-v1" }
-      }
-    ]
-  }
-});
-
-// src/instance/instance.event.ts
-import { defineEvent as defineEvent3 } from "@contractspec/lib.contracts-spec";
-import { ScalarTypeEnum as ScalarTypeEnum9, defineSchemaModel as defineSchemaModel9 } from "@contractspec/lib.schema";
-var InstanceEventPayload = defineSchemaModel9({
-  name: "InstanceEventPayload",
-  description: "Base payload for instance events",
-  fields: {
-    instanceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    workflowId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    workflowKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    status: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    referenceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    referenceType: {
-      type: ScalarTypeEnum9.String_unsecure(),
-      isOptional: true
-    },
-    triggeredBy: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum9.String_unsecure(),
-      isOptional: false
-    },
-    timestamp: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
-  }
-});
-var StepTransitionPayload = defineSchemaModel9({
-  name: "StepTransitionEventPayload",
-  description: "Payload for step transition events",
-  fields: {
-    instanceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    workflowId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    fromStepKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    toStepKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    action: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    executedBy: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
-  }
-});
-var InstanceCompletedPayload = defineSchemaModel9({
-  name: "InstanceCompletedEventPayload",
-  description: "Payload when instance completes",
-  fields: {
-    instanceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    workflowId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    workflowKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    outcome: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    referenceId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    referenceType: {
-      type: ScalarTypeEnum9.String_unsecure(),
-      isOptional: true
-    },
-    duration: { type: ScalarTypeEnum9.Int_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.approvals.enabled"]
   }
 });
-var InstanceStartedEvent = defineEvent3({
+var ApprovalFormPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.started",
+    key: "workflow.approval.form",
     version: "1.0.0",
-    description: "A new workflow instance has been started.",
-    stability: "stable",
+    title: "Approval Form",
+    description: "Form for submitting approval decisions",
+    domain: "workflow-system",
     owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "started"]
+    tags: ["workflow", "approval", "form"],
+    stability: StabilityEnum.Experimental,
+    goal: "Submitting a decision on an approval request",
+    context: "Approval decision dialog"
   },
-  payload: InstanceEventPayload
-});
-var StepEnteredEvent = defineEvent3({
-  meta: {
-    key: "workflow.step.entered",
-    version: "1.0.0",
-    description: "A workflow instance has entered a new step.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "step", "entered"]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "ApprovalDecisionForm"
   },
-  payload: StepTransitionPayload
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.approvals.enabled"]
+  }
 });
-var StepExitedEvent = defineEvent3({
+var PendingApprovalsBadgePresentation = definePresentation({
   meta: {
-    key: "workflow.step.exited",
+    key: "workflow.approval.badge",
     version: "1.0.0",
-    description: "A workflow instance has exited a step.",
-    stability: "stable",
+    title: "Pending Approvals Badge",
+    description: "Badge showing count of pending approvals",
+    domain: "workflow-system",
     owners: ["@workflow-team"],
-    tags: ["workflow", "step", "exited"]
+    tags: ["workflow", "approval", "badge", "widget"],
+    stability: StabilityEnum.Experimental,
+    goal: "Visual notification of pending approvals",
+    context: "Global navigation or sidebar"
   },
-  payload: StepTransitionPayload
-});
-var InstanceCompletedEvent = defineEvent3({
-  meta: {
-    key: "workflow.instance.completed",
-    version: "1.0.0",
-    description: "A workflow instance has completed.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "completed"]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "PendingApprovalsBadge"
   },
-  payload: InstanceCompletedPayload
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.approvals.enabled"]
+  }
 });
-var InstanceCancelledEvent = defineEvent3({
+var WorkflowMetricsPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.cancelled",
+    key: "workflow.metrics",
     version: "1.0.0",
-    description: "A workflow instance has been cancelled.",
-    stability: "stable",
+    title: "Workflow Metrics",
+    description: "Dashboard widget showing workflow metrics and statistics",
+    domain: "workflow-system",
     owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "cancelled"]
-  },
-  payload: InstanceEventPayload
-});
-var InstancePausedEvent = defineEvent3({
-  meta: {
-    key: "workflow.instance.paused",
-    version: "1.0.0",
-    description: "A workflow instance has been paused.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "paused"]
-  },
-  payload: InstanceEventPayload
-});
-var InstanceResumedEvent = defineEvent3({
-  meta: {
-    key: "workflow.instance.resumed",
-    version: "1.0.0",
-    description: "A workflow instance has been resumed.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "resumed"]
-  },
-  payload: InstanceEventPayload
-});
-var InstanceFailedEvent = defineEvent3({
-  meta: {
-    key: "workflow.instance.failed",
-    version: "1.0.0",
-    description: "A workflow instance has failed.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "failed"]
-  },
-  payload: InstanceEventPayload
-});
-var InstanceTimedOutEvent = defineEvent3({
-  meta: {
-    key: "workflow.instance.timedOut",
-    version: "1.0.0",
-    description: "A workflow instance has timed out.",
-    stability: "stable",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "timeout"]
-  },
-  payload: InstanceEventPayload
-});
-// src/presentations/index.ts
-import {
-  definePresentation,
-  StabilityEnum
-} from "@contractspec/lib.contracts-spec";
-var WorkflowDesignerPresentation = definePresentation({
-  meta: {
-    key: "workflow.designer",
-    version: "1.0.0",
-    title: "Workflow Designer",
-    description: "Visual workflow designer with drag-and-drop steps",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "designer", "admin"],
+    tags: ["workflow", "metrics", "dashboard"],
     stability: StabilityEnum.Experimental,
-    goal: "Building and modifying workflow definitions",
-    context: "Workflow administration and setup"
+    goal: "Monitoring throughput and bottlenecks",
+    context: "System performance dashboard"
   },
   source: {
     type: "component",
     framework: "react",
-    componentKey: "WorkflowDesigner",
-    props: WorkflowDefinitionModel
+    componentKey: "WorkflowMetricsDashboard"
   },
-  targets: ["react"],
+  targets: ["react", "markdown"],
   policy: {
-    flags: ["workflow.designer.enabled"]
+    flags: ["workflow.metrics.enabled"]
   }
 });
-var WorkflowListPresentation = definePresentation({
-  meta: {
-    key: "workflow.definition.viewList",
-    version: "1.0.0",
-    title: "Workflow List",
-    description: "List of workflow definitions with status and actions",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "list", "admin"],
-    stability: StabilityEnum.Experimental,
-    goal: "Overview of all defined workflows",
-    context: "Workflow management dashboard"
+var WorkflowSystemPresentations = {
+  WorkflowDesignerPresentation,
+  WorkflowListPresentation,
+  WorkflowDetailPresentation,
+  InstanceListPresentation,
+  InstanceDetailPresentation,
+  ProgressTrackerPresentation,
+  ApprovalInboxPresentation,
+  ApprovalDetailPresentation,
+  ApprovalFormPresentation,
+  PendingApprovalsBadgePresentation,
+  WorkflowMetricsPresentation
+};
+// src/ui/hooks/useWorkflowList.ts
+import { useTemplateRuntime } from "@contractspec/lib.example-shared-ui";
+import { useCallback, useEffect, useState } from "react";
+"use client";
+function useWorkflowList(projectIdOverride) {
+  const { handlers, projectId: runtimeProjectId } = useTemplateRuntime();
+  const projectId = projectIdOverride ?? runtimeProjectId;
+  const workflow = handlers.workflow;
+  const [definitions, setDefinitions] = useState([]);
+  const [instances, setInstances] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchData = useCallback(async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const [defResult, instResult] = await Promise.all([
+        workflow.listDefinitions({ projectId, limit: 100 }),
+        workflow.listInstances({ projectId, limit: 100 })
+      ]);
+      setDefinitions(defResult.definitions);
+      setInstances(instResult.instances);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to load workflows"));
+    } finally {
+      setLoading(false);
+    }
+  }, [projectId, workflow]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  const stats = {
+    totalDefinitions: definitions.length,
+    activeDefinitions: definitions.filter((d) => d.status === "ACTIVE").length,
+    totalInstances: instances.length,
+    pendingInstances: instances.filter((i) => i.status === "PENDING").length,
+    inProgressInstances: instances.filter((i) => i.status === "IN_PROGRESS").length,
+    completedInstances: instances.filter((i) => i.status === "COMPLETED").length,
+    rejectedInstances: instances.filter((i) => i.status === "REJECTED").length
+  };
+  return {
+    definitions,
+    instances,
+    loading,
+    error,
+    stats,
+    refetch: fetchData
+  };
+}
+
+// src/ui/hooks/index.ts
+"use client";
+
+// src/shared/demo-scenario.ts
+var WORKFLOW_SYSTEM_DEMO_PROJECT_ID = "workflow-system-demo";
+var WORKFLOW_SYSTEM_DEMO_ORGANIZATION_ID = "org_demo";
+var WORKFLOW_SYSTEM_DEMO_DEFINITIONS = [
+  {
+    id: "wf_expense",
+    name: "Expense Approval",
+    description: "Approve non-trivial spend before finance releases budget.",
+    type: "APPROVAL",
+    status: "ACTIVE",
+    createdAt: "2026-03-10T09:00:00.000Z",
+    updatedAt: "2026-03-20T08:15:00.000Z",
+    steps: [
+      {
+        id: "wfstep_expense_manager",
+        name: "Manager Review",
+        description: "Validate business value and team budget.",
+        stepOrder: 1,
+        type: "APPROVAL",
+        requiredRoles: ["manager"],
+        createdAt: "2026-03-10T09:00:00.000Z"
+      },
+      {
+        id: "wfstep_expense_finance",
+        name: "Finance Review",
+        description: "Confirm ledger coding and spending threshold.",
+        stepOrder: 2,
+        type: "APPROVAL",
+        requiredRoles: ["finance"],
+        createdAt: "2026-03-10T09:10:00.000Z"
+      }
+    ]
   },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowDefinitionList",
-    props: WorkflowDefinitionModel
+  {
+    id: "wf_vendor",
+    name: "Vendor Onboarding",
+    description: "Sequence security, procurement, and legal before activation.",
+    type: "SEQUENTIAL",
+    status: "ACTIVE",
+    createdAt: "2026-03-08T11:00:00.000Z",
+    updatedAt: "2026-03-19T13:10:00.000Z",
+    steps: [
+      {
+        id: "wfstep_vendor_security",
+        name: "Security Check",
+        description: "Review data access and integration scope.",
+        stepOrder: 1,
+        type: "APPROVAL",
+        requiredRoles: ["security"],
+        createdAt: "2026-03-08T11:00:00.000Z"
+      },
+      {
+        id: "wfstep_vendor_procurement",
+        name: "Procurement Check",
+        description: "Validate pricing, procurement policy, and owner.",
+        stepOrder: 2,
+        type: "APPROVAL",
+        requiredRoles: ["procurement"],
+        createdAt: "2026-03-08T11:05:00.000Z"
+      },
+      {
+        id: "wfstep_vendor_legal",
+        name: "Legal Sign-off",
+        description: "Approve terms before the vendor goes live.",
+        stepOrder: 3,
+        type: "APPROVAL",
+        requiredRoles: ["legal"],
+        createdAt: "2026-03-08T11:10:00.000Z"
+      }
+    ]
   },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.enabled"]
+  {
+    id: "wf_policy_exception",
+    name: "Policy Exception",
+    description: "Escalate a temporary exception through team lead and compliance.",
+    type: "APPROVAL",
+    status: "DRAFT",
+    createdAt: "2026-03-15T07:30:00.000Z",
+    updatedAt: "2026-03-18T11:20:00.000Z",
+    steps: [
+      {
+        id: "wfstep_policy_lead",
+        name: "Team Lead Review",
+        description: "Check urgency and expected blast radius.",
+        stepOrder: 1,
+        type: "APPROVAL",
+        requiredRoles: ["team-lead"],
+        createdAt: "2026-03-15T07:30:00.000Z"
+      },
+      {
+        id: "wfstep_policy_compliance",
+        name: "Compliance Review",
+        description: "Accept or reject the exception request.",
+        stepOrder: 2,
+        type: "APPROVAL",
+        requiredRoles: ["compliance"],
+        createdAt: "2026-03-15T07:40:00.000Z"
+      }
+    ]
   }
-});
-var WorkflowDetailPresentation = definePresentation({
-  meta: {
-    key: "workflow.definition.detail",
-    version: "1.0.0",
-    title: "Workflow Details",
-    description: "Detailed view of a workflow definition with steps",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "detail"],
-    stability: StabilityEnum.Experimental,
-    goal: "Viewing technical details of a workflow definition",
-    context: "Workflow inspection and debugging"
+];
+var WORKFLOW_SYSTEM_DEMO_INSTANCES = [
+  {
+    id: "wfinst_expense_open",
+    definitionId: "wf_expense",
+    status: "IN_PROGRESS",
+    currentStepId: "wfstep_expense_finance",
+    data: {
+      amount: 4200,
+      currency: "EUR",
+      vendor: "Nimbus AI"
+    },
+    requestedBy: "sarah@contractspec.io",
+    startedAt: "2026-03-20T08:00:00.000Z",
+    approvals: [
+      {
+        id: "wfappr_expense_manager",
+        stepId: "wfstep_expense_manager",
+        status: "APPROVED",
+        actorId: "manager.demo",
+        comment: "Approved for the Q2 automation budget.",
+        decidedAt: "2026-03-20T08:15:00.000Z",
+        createdAt: "2026-03-20T08:05:00.000Z"
+      },
+      {
+        id: "wfappr_expense_finance",
+        stepId: "wfstep_expense_finance",
+        status: "PENDING",
+        createdAt: "2026-03-20T08:15:00.000Z"
+      }
+    ]
   },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowDefinitionDetail",
-    props: WorkflowDefinitionModel
+  {
+    id: "wfinst_vendor_done",
+    definitionId: "wf_vendor",
+    status: "COMPLETED",
+    data: {
+      vendor: "Acme Cloud",
+      riskTier: "medium"
+    },
+    requestedBy: "leo@contractspec.io",
+    startedAt: "2026-03-19T09:30:00.000Z",
+    completedAt: "2026-03-19T13:10:00.000Z",
+    approvals: [
+      {
+        id: "wfappr_vendor_security",
+        stepId: "wfstep_vendor_security",
+        status: "APPROVED",
+        actorId: "security.demo",
+        comment: "SOC2 scope is acceptable.",
+        decidedAt: "2026-03-19T10:10:00.000Z",
+        createdAt: "2026-03-19T09:35:00.000Z"
+      },
+      {
+        id: "wfappr_vendor_procurement",
+        stepId: "wfstep_vendor_procurement",
+        status: "APPROVED",
+        actorId: "procurement.demo",
+        comment: "Commercial terms match the preferred vendor tier.",
+        decidedAt: "2026-03-19T11:25:00.000Z",
+        createdAt: "2026-03-19T10:15:00.000Z"
+      },
+      {
+        id: "wfappr_vendor_legal",
+        stepId: "wfstep_vendor_legal",
+        status: "APPROVED",
+        actorId: "legal.demo",
+        comment: "MSA redlines are complete.",
+        decidedAt: "2026-03-19T13:05:00.000Z",
+        createdAt: "2026-03-19T11:30:00.000Z"
+      }
+    ]
   },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.enabled"]
+  {
+    id: "wfinst_policy_rejected",
+    definitionId: "wf_policy_exception",
+    status: "REJECTED",
+    currentStepId: "wfstep_policy_compliance",
+    data: {
+      policy: "Model rollout freeze",
+      durationDays: 14
+    },
+    requestedBy: "maya@contractspec.io",
+    startedAt: "2026-03-18T10:00:00.000Z",
+    completedAt: "2026-03-18T11:20:00.000Z",
+    approvals: [
+      {
+        id: "wfappr_policy_lead",
+        stepId: "wfstep_policy_lead",
+        status: "APPROVED",
+        actorId: "lead.demo",
+        comment: "Escalation justified for the release train.",
+        decidedAt: "2026-03-18T10:30:00.000Z",
+        createdAt: "2026-03-18T10:05:00.000Z"
+      },
+      {
+        id: "wfappr_policy_compliance",
+        stepId: "wfstep_policy_compliance",
+        status: "REJECTED",
+        actorId: "compliance.demo",
+        comment: "Exception exceeds the allowed blast radius.",
+        decidedAt: "2026-03-18T11:15:00.000Z",
+        createdAt: "2026-03-18T10:35:00.000Z"
+      }
+    ]
   }
-});
-var InstanceListPresentation = definePresentation({
+];
+
+// src/visualizations/catalog.ts
+import {
+  defineVisualization,
+  VisualizationRegistry
+} from "@contractspec/lib.contracts-spec/visualizations";
+var INSTANCE_LIST_REF = {
+  key: "workflow.instance.list",
+  version: "1.0.0"
+};
+var META = {
+  version: "1.0.0",
+  domain: "workflow",
+  stability: "experimental",
+  owners: ["@example.workflow-system"],
+  tags: ["workflow", "visualization", "operations"]
+};
+var WorkflowInstanceStatusVisualization = defineVisualization({
   meta: {
-    key: "workflow.instance.viewList",
-    version: "1.0.0",
-    title: "Instance List",
-    description: "List of workflow instances with status and progress",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "list"],
-    stability: StabilityEnum.Experimental,
-    goal: "Monitoring active and past workflow executions",
-    context: "Operations monitoring"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowInstanceList",
-    props: WorkflowInstanceModel
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.enabled"]
+    ...META,
+    key: "workflow-system.visualization.instance-status",
+    title: "Instance Status Breakdown",
+    description: "Distribution of workflow instance states.",
+    goal: "Surface the current workload mix.",
+    context: "Workflow operations overview."
+  },
+  source: { primary: INSTANCE_LIST_REF, resultPath: "data" },
+  visualization: {
+    kind: "pie",
+    nameDimension: "status",
+    valueMeasure: "instances",
+    dimensions: [
+      { key: "status", label: "Status", dataPath: "status", type: "category" }
+    ],
+    measures: [
+      {
+        key: "instances",
+        label: "Instances",
+        dataPath: "instances",
+        format: "number"
+      }
+    ],
+    table: { caption: "Workflow instance counts by status." }
   }
 });
-var InstanceDetailPresentation = definePresentation({
+var WorkflowThroughputVisualization = defineVisualization({
   meta: {
-    key: "workflow.instance.detail",
-    version: "1.0.0",
-    title: "Instance Details",
-    description: "Detailed view of a workflow instance with step timeline",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "instance", "detail", "timeline"],
-    stability: StabilityEnum.Experimental,
-    goal: "Detailed inspection of a specific workflow instance",
-    context: "Case management and troubleshooting"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowInstanceDetail",
-    props: WorkflowInstanceModel
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.enabled"]
-  }
-});
-var ProgressTrackerPresentation = definePresentation({
-  meta: {
-    key: "workflow.instance.progress",
-    version: "1.0.0",
-    title: "Progress Tracker",
-    description: "Visual progress tracker showing current step in workflow",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "progress", "widget"],
-    stability: StabilityEnum.Experimental,
-    goal: "Quick view of current progress for a workflow",
-    context: "Embedded progress indicator in entity views"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowProgressTracker",
-    props: WorkflowInstanceModel
-  },
-  targets: ["react"],
-  policy: {
-    flags: ["workflow.enabled"]
-  }
-});
-var ApprovalInboxPresentation = definePresentation({
-  meta: {
-    key: "workflow.approval.inbox",
-    version: "1.0.0",
-    title: "Approval Inbox",
-    description: "Inbox showing pending approval requests for current user",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "approval", "inbox"],
-    stability: StabilityEnum.Experimental,
-    goal: "Managing personal workload of approval requests",
-    context: "Personal task management"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "ApprovalInbox",
-    props: ApprovalRequestModel
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.approvals.enabled"]
-  }
-});
-var ApprovalDetailPresentation = definePresentation({
-  meta: {
-    key: "workflow.approval.detail",
-    version: "1.0.0",
-    title: "Approval Details",
-    description: "Detailed approval request view with context and actions",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "approval", "detail"],
-    stability: StabilityEnum.Experimental,
-    goal: "Decision support for an approval request",
-    context: "Specific approval action"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "ApprovalRequestDetail",
-    props: ApprovalRequestModel
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.approvals.enabled"]
-  }
-});
-var ApprovalFormPresentation = definePresentation({
-  meta: {
-    key: "workflow.approval.form",
-    version: "1.0.0",
-    title: "Approval Form",
-    description: "Form for submitting approval decisions",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "approval", "form"],
-    stability: StabilityEnum.Experimental,
-    goal: "Submitting a decision on an approval request",
-    context: "Approval decision dialog"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "ApprovalDecisionForm"
-  },
-  targets: ["react"],
-  policy: {
-    flags: ["workflow.approvals.enabled"]
+    ...META,
+    key: "workflow-system.visualization.throughput",
+    title: "Run Throughput",
+    description: "Daily workflow instance starts.",
+    goal: "Show operational throughput over time.",
+    context: "Workflow trend monitoring."
+  },
+  source: { primary: INSTANCE_LIST_REF, resultPath: "data" },
+  visualization: {
+    kind: "cartesian",
+    variant: "line",
+    xDimension: "day",
+    yMeasures: ["instances"],
+    dimensions: [{ key: "day", label: "Day", dataPath: "day", type: "time" }],
+    measures: [
+      {
+        key: "instances",
+        label: "Instances",
+        dataPath: "instances",
+        format: "number",
+        color: "#0f766e"
+      }
+    ],
+    table: { caption: "Daily workflow instance starts." }
   }
 });
-var PendingApprovalsBadgePresentation = definePresentation({
+var WorkflowActiveMetricVisualization = defineVisualization({
   meta: {
-    key: "workflow.approval.badge",
-    version: "1.0.0",
-    title: "Pending Approvals Badge",
-    description: "Badge showing count of pending approvals",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "approval", "badge", "widget"],
-    stability: StabilityEnum.Experimental,
-    goal: "Visual notification of pending approvals",
-    context: "Global navigation or sidebar"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "PendingApprovalsBadge"
-  },
-  targets: ["react"],
-  policy: {
-    flags: ["workflow.approvals.enabled"]
+    ...META,
+    key: "workflow-system.visualization.active-work",
+    title: "Active Work",
+    description: "Current in-flight or pending workflow instances.",
+    goal: "Expose active operational workload.",
+    context: "Workflow workload comparison."
+  },
+  source: { primary: INSTANCE_LIST_REF, resultPath: "data" },
+  visualization: {
+    kind: "metric",
+    measure: "value",
+    measures: [
+      { key: "value", label: "Instances", dataPath: "value", format: "number" }
+    ],
+    table: { caption: "Active workflow count." }
   }
 });
-var WorkflowMetricsPresentation = definePresentation({
+var WorkflowCompletedMetricVisualization = defineVisualization({
   meta: {
-    key: "workflow.metrics",
-    version: "1.0.0",
-    title: "Workflow Metrics",
-    description: "Dashboard widget showing workflow metrics and statistics",
-    domain: "workflow-system",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "metrics", "dashboard"],
-    stability: StabilityEnum.Experimental,
-    goal: "Monitoring throughput and bottlenecks",
-    context: "System performance dashboard"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowMetricsDashboard"
-  },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.metrics.enabled"]
+    ...META,
+    key: "workflow-system.visualization.completed-work",
+    title: "Completed Work",
+    description: "Completed workflow instances in the current sample.",
+    goal: "Show output against active workload.",
+    context: "Workflow workload comparison."
+  },
+  source: { primary: INSTANCE_LIST_REF, resultPath: "data" },
+  visualization: {
+    kind: "metric",
+    measure: "value",
+    measures: [
+      { key: "value", label: "Instances", dataPath: "value", format: "number" }
+    ],
+    table: { caption: "Completed workflow count." }
   }
 });
-var WorkflowSystemPresentations = {
-  WorkflowDesignerPresentation,
-  WorkflowListPresentation,
-  WorkflowDetailPresentation,
-  InstanceListPresentation,
-  InstanceDetailPresentation,
-  ProgressTrackerPresentation,
-  ApprovalInboxPresentation,
-  ApprovalDetailPresentation,
-  ApprovalFormPresentation,
-  PendingApprovalsBadgePresentation,
-  WorkflowMetricsPresentation
-};
+var WorkflowVisualizationSpecs = [
+  WorkflowInstanceStatusVisualization,
+  WorkflowThroughputVisualization,
+  WorkflowActiveMetricVisualization,
+  WorkflowCompletedMetricVisualization
+];
+var WorkflowVisualizationRegistry = new VisualizationRegistry([
+  ...WorkflowVisualizationSpecs
+]);
+var WorkflowVisualizationRefs = WorkflowVisualizationSpecs.map((spec) => ({
+  key: spec.meta.key,
+  version: spec.meta.version
+}));
 
-// src/workflow-system.feature.ts
-import { defineFeature } from "@contractspec/lib.contracts-spec";
-var WorkflowSystemFeature = defineFeature({
-  meta: {
-    key: "workflow-system",
-    title: "Workflow & Approval System",
-    description: "State machine-based workflow engine with role-based approvals, delegation, and escalation",
-    domain: "workflow",
-    owners: ["@workflow-team"],
-    tags: ["workflow", "approval", "state-machine", "automation"],
-    stability: "experimental",
-    version: "1.0.0"
-  },
-  operations: [
-    { key: "workflow.definition.create", version: "1.0.0" },
-    { key: "workflow.definition.update", version: "1.0.0" },
-    { key: "workflow.step.add", version: "1.0.0" },
-    { key: "workflow.definition.publish", version: "1.0.0" },
-    { key: "workflow.definition.list", version: "1.0.0" },
-    { key: "workflow.definition.get", version: "1.0.0" },
-    { key: "workflow.instance.start", version: "1.0.0" },
-    { key: "workflow.instance.transition", version: "1.0.0" },
-    { key: "workflow.instance.pause", version: "1.0.0" },
-    { key: "workflow.instance.resume", version: "1.0.0" },
-    { key: "workflow.instance.cancel", version: "1.0.0" },
-    { key: "workflow.instance.list", version: "1.0.0" },
-    { key: "workflow.instance.get", version: "1.0.0" },
-    { key: "workflow.approval.decide", version: "1.0.0" },
-    { key: "workflow.approval.delegate", version: "1.0.0" },
-    { key: "workflow.approval.comment.add", version: "1.0.0" },
-    { key: "workflow.approval.list.mine", version: "1.0.0" },
-    { key: "workflow.approval.get", version: "1.0.0" }
-  ],
-  events: [
-    { key: "workflow.definition.created", version: "1.0.0" },
-    { key: "workflow.definition.updated", version: "1.0.0" },
-    { key: "workflow.definition.published", version: "1.0.0" },
-    { key: "workflow.step.added", version: "1.0.0" },
-    { key: "workflow.instance.started", version: "1.0.0" },
-    { key: "workflow.step.entered", version: "1.0.0" },
-    { key: "workflow.step.exited", version: "1.0.0" },
-    { key: "workflow.instance.completed", version: "1.0.0" },
-    { key: "workflow.instance.cancelled", version: "1.0.0" },
-    { key: "workflow.instance.paused", version: "1.0.0" },
-    { key: "workflow.instance.resumed", version: "1.0.0" },
-    { key: "workflow.instance.failed", version: "1.0.0" },
-    { key: "workflow.instance.timedOut", version: "1.0.0" },
-    { key: "workflow.approval.requested", version: "1.0.0" },
-    { key: "workflow.approval.decided", version: "1.0.0" },
-    { key: "workflow.approval.delegated", version: "1.0.0" },
-    { key: "workflow.approval.escalated", version: "1.0.0" }
-  ],
-  presentations: [
-    { key: "workflow.designer", version: "1.0.0" },
-    { key: "workflow.definition.viewList", version: "1.0.0" },
-    { key: "workflow.definition.detail", version: "1.0.0" },
-    { key: "workflow.instance.viewList", version: "1.0.0" },
-    { key: "workflow.instance.detail", version: "1.0.0" },
-    { key: "workflow.instance.progress", version: "1.0.0" },
-    { key: "workflow.approval.inbox", version: "1.0.0" },
-    { key: "workflow.approval.detail", version: "1.0.0" },
-    { key: "workflow.approval.form", version: "1.0.0" },
-    { key: "workflow.approval.badge", version: "1.0.0" },
-    { key: "workflow.metrics", version: "1.0.0" }
-  ],
-  opToPresentation: [
+// src/visualizations/selectors.ts
+function toDayKey(value) {
+  const date = value instanceof Date ? value : new Date(value);
+  return date.toISOString().slice(0, 10);
+}
+function createWorkflowVisualizationSections(instances) {
+  const statusCounts = new Map;
+  const throughput = new Map;
+  let activeCount = 0;
+  let completedCount = 0;
+  for (const instance of instances) {
+    statusCounts.set(instance.status, (statusCounts.get(instance.status) ?? 0) + 1);
+    const day = toDayKey(instance.startedAt);
+    throughput.set(day, (throughput.get(day) ?? 0) + 1);
+    if (instance.status === "PENDING" || instance.status === "IN_PROGRESS") {
+      activeCount += 1;
+    }
+    if (instance.status === "COMPLETED") {
+      completedCount += 1;
+    }
+  }
+  const primaryItems = [
     {
-      op: { key: "workflow.definition.list", version: "1.0.0" },
-      pres: { key: "workflow.definition.viewList", version: "1.0.0" }
+      key: "workflow-status",
+      spec: WorkflowInstanceStatusVisualization,
+      data: {
+        data: Array.from(statusCounts.entries()).map(([status, count]) => ({
+          status,
+          instances: count
+        }))
+      },
+      title: "Instance Status Breakdown",
+      description: "Status mix across workflow instances.",
+      height: 260
     },
     {
-      op: { key: "workflow.instance.list", version: "1.0.0" },
-      pres: { key: "workflow.instance.viewList", version: "1.0.0" }
-    },
+      key: "workflow-throughput",
+      spec: WorkflowThroughputVisualization,
+      data: {
+        data: Array.from(throughput.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([day, count]) => ({ day, instances: count }))
+      },
+      title: "Run Throughput",
+      description: "Daily workflow starts from current instances."
+    }
+  ];
+  const comparisonItems = [
     {
-      op: { key: "workflow.approval.list.mine", version: "1.0.0" },
-      pres: { key: "workflow.approval.inbox", version: "1.0.0" }
+      key: "workflow-active",
+      spec: WorkflowActiveMetricVisualization,
+      data: { data: [{ value: activeCount }] },
+      title: "Active Work",
+      description: "Pending and in-progress workflows.",
+      height: 200
     },
     {
-      op: { key: "workflow.approval.decide", version: "1.0.0" },
-      pres: { key: "workflow.approval.form", version: "1.0.0" }
-    }
-  ],
-  presentationsTargets: [
-    { key: "workflow.designer", version: "1.0.0", targets: ["react"] },
-    {
-      key: "workflow.definition.viewList",
-      version: "1.0.0",
-      targets: ["react", "markdown"]
-    },
-    {
-      key: "workflow.definition.detail",
-      version: "1.0.0",
-      targets: ["react", "markdown"]
-    },
-    {
-      key: "workflow.instance.viewList",
-      version: "1.0.0",
-      targets: ["react", "markdown"]
-    },
-    {
-      key: "workflow.instance.detail",
-      version: "1.0.0",
-      targets: ["react", "markdown"]
-    },
-    { key: "workflow.instance.progress", version: "1.0.0", targets: ["react"] },
-    {
-      key: "workflow.approval.inbox",
-      version: "1.0.0",
-      targets: ["react", "markdown"]
-    },
-    {
-      key: "workflow.approval.detail",
-      version: "1.0.0",
-      targets: ["react", "markdown"]
-    },
-    {
-      key: "workflow.metrics",
-      version: "1.0.0",
-      targets: ["react", "markdown"]
+      key: "workflow-completed",
+      spec: WorkflowCompletedMetricVisualization,
+      data: { data: [{ value: completedCount }] },
+      title: "Completed Work",
+      description: "Completed workflows in the current sample.",
+      height: 200
     }
-  ],
-  capabilities: {
-    requires: [
-      { key: "identity", version: "1.0.0" },
-      { key: "audit-trail", version: "1.0.0" },
-      { key: "notifications", version: "1.0.0" },
-      { key: "feature-flags", version: "1.0.0" }
-    ],
-    provides: [
-      { key: "workflow", version: "1.0.0" },
-      { key: "approval", version: "1.0.0" },
-      { key: "state-machine", version: "1.0.0" }
-    ]
-  },
-  workflows: [
-    { key: "workflow-system.workflow.approval-chain", version: "1.0.0" }
-  ],
-  telemetry: [{ key: "workflow-system.telemetry", version: "1.0.0" }],
-  jobs: [
-    { key: "workflow-system.job.instance-timeout", version: "1.0.0" },
-    { key: "workflow-system.job.escalation", version: "1.0.0" }
-  ],
-  docs: [
-    "docs.examples.workflow-system",
-    "docs.examples.workflow-system.goal",
-    "docs.examples.workflow-system.usage",
-    "docs.examples.workflow-system.constraints"
-  ]
-});
-
+  ];
+  return {
+    primaryItems,
+    comparisonItems
+  };
+}
 // src/ui/renderers/workflow.markdown.ts
-var mockWorkflowDefinitions = [
-  {
-    id: "wf-1",
-    name: "Purchase Approval",
-    type: "APPROVAL",
-    steps: [
-      {
-        id: "s1",
-        name: "Manager Review",
-        order: 1,
-        requiredRoles: ["manager"]
-      },
-      {
-        id: "s2",
-        name: "Finance Review",
-        order: 2,
-        requiredRoles: ["finance"]
-      },
-      { id: "s3", name: "Final Approval", order: 3, requiredRoles: ["admin"] }
-    ],
-    status: "ACTIVE"
-  },
-  {
-    id: "wf-2",
-    name: "Leave Request",
-    type: "APPROVAL",
-    steps: [
-      {
-        id: "s1",
-        name: "Supervisor Approval",
-        order: 1,
-        requiredRoles: ["supervisor"]
-      },
-      { id: "s2", name: "HR Review", order: 2, requiredRoles: ["hr"] }
-    ],
-    status: "ACTIVE"
-  },
-  {
-    id: "wf-3",
-    name: "Document Review",
-    type: "SEQUENTIAL",
-    steps: [
-      { id: "s1", name: "Author Review", order: 1, requiredRoles: ["author"] },
-      { id: "s2", name: "Peer Review", order: 2, requiredRoles: ["reviewer"] },
-      { id: "s3", name: "Publish", order: 3, requiredRoles: ["publisher"] }
-    ],
-    status: "DRAFT"
-  }
-];
-var mockWorkflowInstances = [
-  {
-    id: "inst-1",
-    definitionId: "wf-1",
-    definitionName: "Purchase Approval",
-    status: "IN_PROGRESS",
-    currentStepId: "s2",
-    startedAt: "2024-01-15T10:00:00Z",
-    requestedBy: "John Doe"
-  },
-  {
-    id: "inst-2",
-    definitionId: "wf-1",
-    definitionName: "Purchase Approval",
-    status: "COMPLETED",
-    currentStepId: null,
-    startedAt: "2024-01-10T09:00:00Z",
-    completedAt: "2024-01-12T14:00:00Z",
-    requestedBy: "Jane Smith"
-  },
-  {
-    id: "inst-3",
-    definitionId: "wf-2",
-    definitionName: "Leave Request",
-    status: "PENDING",
-    currentStepId: "s1",
-    startedAt: "2024-01-16T08:00:00Z",
-    requestedBy: "Bob Wilson"
-  }
-];
+var workflowDefinitions = WORKFLOW_SYSTEM_DEMO_DEFINITIONS;
+var workflowInstances = WORKFLOW_SYSTEM_DEMO_INSTANCES;
+var workflowDefinitionById = new Map(workflowDefinitions.map((definition) => [definition.id, definition]));
+function formatDate(value) {
+  return new Date(value).toISOString().slice(0, 10);
+}
 var workflowDashboardMarkdownRenderer = {
   target: "markdown",
   render: async (desc) => {
     if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowDashboard") {
       throw new Error("workflowDashboardMarkdownRenderer: not WorkflowDashboard");
     }
-    const definitions = mockWorkflowDefinitions;
-    const instances = mockWorkflowInstances;
+    const definitions = workflowDefinitions;
+    const instances = workflowInstances;
+    const visualizations = createWorkflowVisualizationSections(instances);
     const activeDefinitions = definitions.filter((d) => d.status === "ACTIVE");
-    const pendingInstances = instances.filter((i) => i.status === "PENDING");
-    const inProgressInstances = instances.filter((i) => i.status === "IN_PROGRESS");
-    const completedInstances = instances.filter((i) => i.status === "COMPLETED");
+    const awaitingActionInstances = instances.filter((i) => i.status === "PENDING" || i.status === "IN_PROGRESS");
     const lines = [
       "# Workflow Dashboard",
       "",
-      "> Workflow and approval management overview",
+      "> Seeded workflow and approval overview for the sandbox demo.",
       "",
       "## Summary",
       "",
       "| Metric | Value |",
       "|--------|-------|",
       `| Active Workflows | ${activeDefinitions.length} |`,
-      `| Pending Approvals | ${pendingInstances.length} |`,
-      `| In Progress | ${inProgressInstances.length} |`,
-      `| Completed | ${completedInstances.length} |`,
-      "",
-      "## Active Workflow Definitions",
+      `| Awaiting Action | ${awaitingActionInstances.length} |`,
+      `| Completed | ${instances.filter((i) => i.status === "COMPLETED").length} |`,
+      `| Rejected | ${instances.filter((i) => i.status === "REJECTED").length} |`,
       ""
     ];
+    lines.push("## Visualization Overview");
+    lines.push("");
+    for (const item of [
+      ...visualizations.primaryItems,
+      ...visualizations.comparisonItems
+    ]) {
+      lines.push(`- **${item.title}** via \`${item.spec.meta.key}\``);
+    }
+    lines.push("");
+    lines.push("## Active Workflow Definitions");
+    lines.push("");
     if (activeDefinitions.length === 0) {
       lines.push("_No active workflow definitions._");
     } else {
@@ -2654,8 +2503,9 @@ var workflowDashboardMarkdownRenderer = {
       lines.push("| Workflow | Requested By | Status | Started |");
       lines.push("|----------|--------------|--------|---------|");
       for (const inst of instances.slice(0, 10)) {
-        const startedDate = new Date(inst.startedAt).toLocaleDateString();
-        lines.push(`| ${inst.definitionName} | ${inst.requestedBy} | ${inst.status} | ${startedDate} |`);
+        const startedDate = formatDate(inst.startedAt);
+        const definitionName = workflowDefinitionById.get(inst.definitionId)?.name ?? inst.definitionId;
+        lines.push(`| ${definitionName} | ${inst.requestedBy} | ${inst.status} | ${startedDate} |`);
       }
     }
     return {
@@ -2671,7 +2521,7 @@ var workflowDefinitionListMarkdownRenderer = {
     if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowDefinitionList") {
       throw new Error("workflowDefinitionListMarkdownRenderer: not WorkflowDefinitionList");
     }
-    const definitions = mockWorkflowDefinitions;
+    const definitions = workflowDefinitions;
     const lines = [
       "# Workflow Definitions",
       "",
@@ -2686,7 +2536,7 @@ var workflowDefinitionListMarkdownRenderer = {
       lines.push("### Steps");
       lines.push("");
       for (const step of def.steps) {
-        lines.push(`${step.order}. **${step.name}** - Roles: ${step.requiredRoles.join(", ")}`);
+        lines.push(`${step.stepOrder}. **${step.name}** - Roles: ${step.requiredRoles.join(", ")}`);
       }
       lines.push("");
     }
@@ -2703,7 +2553,7 @@ var workflowInstanceDetailMarkdownRenderer = {
     if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowInstanceDetail") {
       throw new Error("workflowInstanceDetailMarkdownRenderer: not WorkflowInstanceDetail");
     }
-    const instance = mockWorkflowInstances[0];
+    const instance = workflowInstances.find((workflowInstance) => workflowInstance.status === "IN_PROGRESS") ?? workflowInstances[0];
     if (!instance) {
       return {
         mimeType: "text/markdown",
@@ -2712,14 +2562,14 @@ var workflowInstanceDetailMarkdownRenderer = {
 No workflow instances available.`
       };
     }
-    const definition = mockWorkflowDefinitions.find((d) => d.id === instance.definitionId);
+    const definition = workflowDefinitions.find((d) => d.id === instance.definitionId);
     const lines = [
-      `# Workflow: ${instance.definitionName}`,
+      `# Workflow: ${definition?.name ?? instance.definitionId}`,
       "",
       `**Instance ID:** ${instance.id}`,
       `**Status:** ${instance.status}`,
       `**Requested By:** ${instance.requestedBy}`,
-      `**Started:** ${new Date(instance.startedAt).toLocaleString()}`,
+      `**Started:** ${formatDate(instance.startedAt)}`,
       "",
       "## Steps Progress",
       ""
@@ -2740,7 +2590,7 @@ No workflow instances available.`
     lines.push("## Actions");
     lines.push("");
     lines.push("- **Approve** - Move to next step");
-    lines.push("- **Reject** - Reject and return");
+    lines.push("- **Reject** - End the workflow with a rejection outcome");
     lines.push("- **Delegate** - Assign to another approver");
     return {
       mimeType: "text/markdown",
@@ -2749,56 +2599,52 @@ No workflow instances available.`
     };
   }
 };
-// src/ui/hooks/useWorkflowList.ts
-import { useCallback, useEffect, useState } from "react";
-import { useTemplateRuntime } from "@contractspec/lib.example-shared-ui";
+// src/ui/WorkflowDashboard.visualizations.tsx
+import {
+  ComparisonView,
+  VisualizationCard,
+  VisualizationGrid
+} from "@contractspec/lib.design-system";
+import { jsxDEV } from "react/jsx-dev-runtime";
 "use client";
-function useWorkflowList(projectId = "local-project") {
-  const { handlers } = useTemplateRuntime();
-  const workflow = handlers.workflow;
-  const [definitions, setDefinitions] = useState([]);
-  const [instances, setInstances] = useState([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-  const fetchData = useCallback(async () => {
-    try {
-      setLoading(true);
-      setError(null);
-      const [defResult, instResult] = await Promise.all([
-        workflow.listDefinitions({ projectId, limit: 100 }),
-        workflow.listInstances({ projectId, limit: 100 })
-      ]);
-      setDefinitions(defResult.definitions);
-      setInstances(instResult.instances);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error("Failed to load workflows"));
-    } finally {
-      setLoading(false);
-    }
-  }, [handlers, projectId]);
-  useEffect(() => {
-    fetchData();
-  }, [fetchData]);
-  const stats = {
-    totalDefinitions: definitions.length,
-    activeDefinitions: definitions.filter((d) => d.status === "ACTIVE").length,
-    totalInstances: instances.length,
-    pendingInstances: instances.filter((i) => i.status === "PENDING").length,
-    completedInstances: instances.filter((i) => i.status === "COMPLETED").length,
-    rejectedInstances: instances.filter((i) => i.status === "REJECTED").length
-  };
-  return {
-    definitions,
-    instances,
-    loading,
-    error,
-    stats,
-    refetch: fetchData
-  };
+function WorkflowVisualizationOverview({
+  instances
+}) {
+  const { primaryItems, comparisonItems } = createWorkflowVisualizationSections(instances);
+  return /* @__PURE__ */ jsxDEV("section", {
+    className: "space-y-4",
+    children: [
+      /* @__PURE__ */ jsxDEV("div", {
+        children: [
+          /* @__PURE__ */ jsxDEV("h3", {
+            className: "font-semibold text-lg",
+            children: "Workflow Visualizations"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("p", {
+            className: "text-muted-foreground text-sm",
+            children: "Contract-backed charts for workflow health and throughput."
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV(VisualizationGrid, {
+        children: primaryItems.map((item) => /* @__PURE__ */ jsxDEV(VisualizationCard, {
+          data: item.data,
+          description: item.description,
+          height: item.height,
+          spec: item.spec,
+          title: item.title
+        }, item.key, false, undefined, this))
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(ComparisonView, {
+        description: "Shared comparison surface for active versus completed work.",
+        items: comparisonItems,
+        title: "Workload Comparison"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
 }
 
 // src/ui/WorkflowDashboard.tsx
-import { useState as useState2 } from "react";
 import {
   Button,
   ErrorState,
@@ -2806,7 +2652,8 @@ import {
   StatCard,
   StatCardGroup
 } from "@contractspec/lib.design-system";
-import { jsxDEV } from "react/jsx-dev-runtime";
+import { useState as useState2 } from "react";
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
 "use client";
 var STATUS_COLORS = {
   ACTIVE: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
@@ -2826,153 +2673,150 @@ function WorkflowDashboard() {
     { id: "instances", label: "Instances", icon: "\uD83D\uDD04" }
   ];
   if (loading) {
-    return /* @__PURE__ */ jsxDEV(LoaderBlock, {
+    return /* @__PURE__ */ jsxDEV2(LoaderBlock, {
       label: "Loading Workflows..."
     }, undefined, false, undefined, this);
   }
   if (error) {
-    return /* @__PURE__ */ jsxDEV(ErrorState, {
+    return /* @__PURE__ */ jsxDEV2(ErrorState, {
       title: "Failed to load Workflows",
       description: error.message,
       onRetry: refetch,
       retryLabel: "Retry"
     }, undefined, false, undefined, this);
   }
-  return /* @__PURE__ */ jsxDEV("div", {
+  return /* @__PURE__ */ jsxDEV2("div", {
     className: "space-y-6",
     children: [
-      /* @__PURE__ */ jsxDEV("div", {
+      /* @__PURE__ */ jsxDEV2("div", {
         className: "flex items-center justify-between",
         children: [
-          /* @__PURE__ */ jsxDEV("h2", {
-            className: "text-2xl font-bold",
+          /* @__PURE__ */ jsxDEV2("h2", {
+            className: "font-bold text-2xl",
             children: "Workflow System"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV(Button, {
-            onClick: () => alert("Create workflow modal"),
-            children: [
-              /* @__PURE__ */ jsxDEV("span", {
-                className: "mr-2",
-                children: "+"
-              }, undefined, false, undefined, this),
-              " New Workflow"
-            ]
-          }, undefined, true, undefined, this)
+          /* @__PURE__ */ jsxDEV2(Button, {
+            onClick: () => void refetch(),
+            children: "Refresh"
+          }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV(StatCardGroup, {
+      /* @__PURE__ */ jsxDEV2(StatCardGroup, {
         children: [
-          /* @__PURE__ */ jsxDEV(StatCard, {
+          /* @__PURE__ */ jsxDEV2(StatCard, {
             label: "Workflows",
             value: stats.totalDefinitions,
             hint: `${stats.activeDefinitions} active`
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV(StatCard, {
+          /* @__PURE__ */ jsxDEV2(StatCard, {
             label: "Instances",
             value: stats.totalInstances,
             hint: "total runs"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV(StatCard, {
-            label: "Pending",
-            value: stats.pendingInstances,
-            hint: "awaiting action"
+          /* @__PURE__ */ jsxDEV2(StatCard, {
+            label: "Awaiting Action",
+            value: stats.pendingInstances + stats.inProgressInstances,
+            hint: "open approvals"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV(StatCard, {
+          /* @__PURE__ */ jsxDEV2(StatCard, {
             label: "Completed",
             value: stats.completedInstances,
             hint: "finished"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV("nav", {
-        className: "bg-muted flex gap-1 rounded-lg p-1",
+      /* @__PURE__ */ jsxDEV2(WorkflowVisualizationOverview, {
+        instances
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV2("nav", {
+        className: "flex gap-1 rounded-lg bg-muted p-1",
         role: "tablist",
-        children: tabs.map((tab) => /* @__PURE__ */ jsxDEV(Button, {
+        children: tabs.map((tab) => /* @__PURE__ */ jsxDEV2(Button, {
           type: "button",
           role: "tab",
           "aria-selected": activeTab === tab.id,
           onClick: () => setActiveTab(tab.id),
-          className: `flex flex-1 items-center justify-center gap-2 rounded-md px-4 py-2 text-sm font-medium transition-colors ${activeTab === tab.id ? "bg-background text-foreground shadow-sm" : "text-muted-foreground hover:text-foreground"}`,
+          className: `flex flex-1 items-center justify-center gap-2 rounded-md px-4 py-2 font-medium text-sm transition-colors ${activeTab === tab.id ? "bg-background text-foreground shadow-sm" : "text-muted-foreground hover:text-foreground"}`,
           children: [
-            /* @__PURE__ */ jsxDEV("span", {
+            /* @__PURE__ */ jsxDEV2("span", {
               children: tab.icon
             }, undefined, false, undefined, this),
             tab.label
           ]
         }, tab.id, true, undefined, this))
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV("div", {
+      /* @__PURE__ */ jsxDEV2("div", {
         className: "min-h-[400px]",
         role: "tabpanel",
         children: [
-          activeTab === "definitions" && /* @__PURE__ */ jsxDEV("div", {
-            className: "border-border rounded-lg border",
-            children: /* @__PURE__ */ jsxDEV("table", {
+          activeTab === "definitions" && /* @__PURE__ */ jsxDEV2("div", {
+            className: "rounded-lg border border-border",
+            children: /* @__PURE__ */ jsxDEV2("table", {
               className: "w-full",
               children: [
-                /* @__PURE__ */ jsxDEV("thead", {
-                  className: "border-border bg-muted/30 border-b",
-                  children: /* @__PURE__ */ jsxDEV("tr", {
+                /* @__PURE__ */ jsxDEV2("thead", {
+                  className: "border-border border-b bg-muted/30",
+                  children: /* @__PURE__ */ jsxDEV2("tr", {
                     children: [
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                      /* @__PURE__ */ jsxDEV2("th", {
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Name"
                       }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                      /* @__PURE__ */ jsxDEV2("th", {
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Type"
                       }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                      /* @__PURE__ */ jsxDEV2("th", {
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Status"
                       }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                      /* @__PURE__ */ jsxDEV2("th", {
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Created"
                       }, undefined, false, undefined, this)
                     ]
                   }, undefined, true, undefined, this)
                 }, undefined, false, undefined, this),
-                /* @__PURE__ */ jsxDEV("tbody", {
-                  className: "divide-border divide-y",
+                /* @__PURE__ */ jsxDEV2("tbody", {
+                  className: "divide-y divide-border",
                   children: [
-                    definitions.map((def) => /* @__PURE__ */ jsxDEV("tr", {
+                    definitions.map((def) => /* @__PURE__ */ jsxDEV2("tr", {
                       className: "hover:bg-muted/50",
                       children: [
-                        /* @__PURE__ */ jsxDEV("td", {
+                        /* @__PURE__ */ jsxDEV2("td", {
                           className: "px-4 py-3",
                           children: [
-                            /* @__PURE__ */ jsxDEV("div", {
+                            /* @__PURE__ */ jsxDEV2("div", {
                               className: "font-medium",
                               children: def.name
                             }, undefined, false, undefined, this),
-                            /* @__PURE__ */ jsxDEV("div", {
+                            /* @__PURE__ */ jsxDEV2("div", {
                               className: "text-muted-foreground text-sm",
                               children: def.description
                             }, undefined, false, undefined, this)
                           ]
                         }, undefined, true, undefined, this),
-                        /* @__PURE__ */ jsxDEV("td", {
+                        /* @__PURE__ */ jsxDEV2("td", {
                           className: "px-4 py-3 font-mono text-sm",
                           children: def.type
                         }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("td", {
+                        /* @__PURE__ */ jsxDEV2("td", {
                           className: "px-4 py-3",
-                          children: /* @__PURE__ */ jsxDEV("span", {
-                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[def.status] ?? ""}`,
+                          children: /* @__PURE__ */ jsxDEV2("span", {
+                            className: `inline-flex rounded-full px-2 py-0.5 font-medium text-xs ${STATUS_COLORS[def.status] ?? ""}`,
                             children: def.status
                           }, undefined, false, undefined, this)
                         }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("td", {
-                          className: "text-muted-foreground px-4 py-3 text-sm",
+                        /* @__PURE__ */ jsxDEV2("td", {
+                          className: "px-4 py-3 text-muted-foreground text-sm",
                           children: def.createdAt.toLocaleDateString()
                         }, undefined, false, undefined, this)
                       ]
                     }, def.id, true, undefined, this)),
-                    definitions.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
-                      children: /* @__PURE__ */ jsxDEV("td", {
+                    definitions.length === 0 && /* @__PURE__ */ jsxDEV2("tr", {
+                      children: /* @__PURE__ */ jsxDEV2("td", {
                         colSpan: 4,
-                        className: "text-muted-foreground px-4 py-8 text-center",
+                        className: "px-4 py-8 text-center text-muted-foreground",
                         children: "No workflow definitions found"
                       }, undefined, false, undefined, this)
                     }, undefined, false, undefined, this)
@@ -2981,65 +2825,65 @@ function WorkflowDashboard() {
               ]
             }, undefined, true, undefined, this)
           }, undefined, false, undefined, this),
-          activeTab === "instances" && /* @__PURE__ */ jsxDEV("div", {
-            className: "border-border rounded-lg border",
-            children: /* @__PURE__ */ jsxDEV("table", {
+          activeTab === "instances" && /* @__PURE__ */ jsxDEV2("div", {
+            className: "rounded-lg border border-border",
+            children: /* @__PURE__ */ jsxDEV2("table", {
               className: "w-full",
               children: [
-                /* @__PURE__ */ jsxDEV("thead", {
-                  className: "border-border bg-muted/30 border-b",
-                  children: /* @__PURE__ */ jsxDEV("tr", {
+                /* @__PURE__ */ jsxDEV2("thead", {
+                  className: "border-border border-b bg-muted/30",
+                  children: /* @__PURE__ */ jsxDEV2("tr", {
                     children: [
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                      /* @__PURE__ */ jsxDEV2("th", {
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Instance ID"
                       }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                      /* @__PURE__ */ jsxDEV2("th", {
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Status"
                       }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                      /* @__PURE__ */ jsxDEV2("th", {
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Requested By"
                       }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                      /* @__PURE__ */ jsxDEV2("th", {
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Started"
                       }, undefined, false, undefined, this)
                     ]
                   }, undefined, true, undefined, this)
                 }, undefined, false, undefined, this),
-                /* @__PURE__ */ jsxDEV("tbody", {
-                  className: "divide-border divide-y",
+                /* @__PURE__ */ jsxDEV2("tbody", {
+                  className: "divide-y divide-border",
                   children: [
-                    instances.map((inst) => /* @__PURE__ */ jsxDEV("tr", {
+                    instances.map((inst) => /* @__PURE__ */ jsxDEV2("tr", {
                       className: "hover:bg-muted/50",
                       children: [
-                        /* @__PURE__ */ jsxDEV("td", {
+                        /* @__PURE__ */ jsxDEV2("td", {
                           className: "px-4 py-3 font-mono text-sm",
                           children: inst.id
                         }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("td", {
+                        /* @__PURE__ */ jsxDEV2("td", {
                           className: "px-4 py-3",
-                          children: /* @__PURE__ */ jsxDEV("span", {
-                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[inst.status] ?? ""}`,
+                          children: /* @__PURE__ */ jsxDEV2("span", {
+                            className: `inline-flex rounded-full px-2 py-0.5 font-medium text-xs ${STATUS_COLORS[inst.status] ?? ""}`,
                             children: inst.status
                           }, undefined, false, undefined, this)
                         }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("td", {
+                        /* @__PURE__ */ jsxDEV2("td", {
                           className: "px-4 py-3 text-sm",
                           children: inst.requestedBy
                         }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("td", {
-                          className: "text-muted-foreground px-4 py-3 text-sm",
+                        /* @__PURE__ */ jsxDEV2("td", {
+                          className: "px-4 py-3 text-muted-foreground text-sm",
                           children: inst.startedAt.toLocaleDateString()
                         }, undefined, false, undefined, this)
                       ]
                     }, inst.id, true, undefined, this)),
-                    instances.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
-                      children: /* @__PURE__ */ jsxDEV("td", {
+                    instances.length === 0 && /* @__PURE__ */ jsxDEV2("tr", {
+                      children: /* @__PURE__ */ jsxDEV2("td", {
                         colSpan: 4,
-                        className: "text-muted-foreground px-4 py-8 text-center",
+                        className: "px-4 py-8 text-center text-muted-foreground",
                         children: "No workflow instances found"
                       }, undefined, false, undefined, this)
                     }, undefined, false, undefined, this)
@@ -3053,20 +2897,560 @@ function WorkflowDashboard() {
     ]
   }, undefined, true, undefined, this);
 }
+// src/workflow/workflow.event.ts
+import { defineEvent as defineEvent3 } from "@contractspec/lib.contracts-spec";
+import { defineSchemaModel as defineSchemaModel8, ScalarTypeEnum as ScalarTypeEnum8 } from "@contractspec/lib.schema";
+var WorkflowDefinitionPayload = defineSchemaModel8({
+  name: "WorkflowDefinitionEventPayload",
+  description: "Payload for workflow definition events",
+  fields: {
+    workflowId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    key: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    version: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum8.String_unsecure(),
+      isOptional: false
+    },
+    createdBy: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum8.DateTime(), isOptional: false }
+  }
+});
+var StepAddedPayload = defineSchemaModel8({
+  name: "StepAddedEventPayload",
+  description: "Payload when a step is added",
+  fields: {
+    stepId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    workflowId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    stepKey: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    stepType: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    position: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum8.DateTime(), isOptional: false }
+  }
+});
+var WorkflowCreatedEvent = defineEvent3({
+  meta: {
+    key: "workflow.definition.created",
+    version: "1.0.0",
+    description: "A new workflow definition has been created.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "definition", "created"]
+  },
+  payload: WorkflowDefinitionPayload
+});
+var WorkflowUpdatedEvent = defineEvent3({
+  meta: {
+    key: "workflow.definition.updated",
+    version: "1.0.0",
+    description: "A workflow definition has been updated.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "definition", "updated"]
+  },
+  payload: WorkflowDefinitionPayload
+});
+var WorkflowPublishedEvent = defineEvent3({
+  meta: {
+    key: "workflow.definition.published",
+    version: "1.0.0",
+    description: "A workflow definition has been published and is now active.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "definition", "published"]
+  },
+  payload: WorkflowDefinitionPayload
+});
+var StepAddedEvent = defineEvent3({
+  meta: {
+    key: "workflow.step.added",
+    version: "1.0.0",
+    description: "A step has been added to a workflow definition.",
+    stability: "stable",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "step", "added"]
+  },
+  payload: StepAddedPayload
+});
 
-// src/ui/hooks/index.ts
-"use client";
+// src/workflow/workflow.operations.ts
+import {
+  defineCommand as defineCommand3,
+  defineQuery as defineQuery3
+} from "@contractspec/lib.contracts-spec/operations";
+import { defineSchemaModel as defineSchemaModel9, ScalarTypeEnum as ScalarTypeEnum9 } from "@contractspec/lib.schema";
+var OWNERS3 = ["@example.workflow-system"];
+var CreateWorkflowContract = defineCommand3({
+  meta: {
+    key: "workflow.definition.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "definition", "create"],
+    description: "Create a new workflow definition.",
+    goal: "Allow users to define new workflow blueprints.",
+    context: "Workflow designer, admin panel."
+  },
+  io: {
+    input: CreateWorkflowInputModel,
+    output: WorkflowDefinitionModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.definition.created",
+        version: "1.0.0",
+        when: "Workflow is created",
+        payload: WorkflowDefinitionModel
+      }
+    ],
+    audit: ["workflow.definition.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-workflow-happy-path",
+        given: ["User is admin"],
+        when: ["User creates new workflow definition"],
+        then: [
+          "Definition is created",
+          "WorkflowDefinitionCreated event is emitted"
+        ]
+      }
+    ],
+    examples: [
+      {
+        key: "create-onboarding",
+        input: {
+          key: "onboarding-v1",
+          name: "Employee Onboarding",
+          version: "1.0.0"
+        },
+        output: { id: "def-123", status: "draft" }
+      }
+    ]
+  }
+});
+var UpdateWorkflowContract = defineCommand3({
+  meta: {
+    key: "workflow.definition.update",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "definition", "update"],
+    description: "Update an existing workflow definition.",
+    goal: "Allow users to modify workflow blueprints.",
+    context: "Workflow designer."
+  },
+  io: {
+    input: UpdateWorkflowInputModel,
+    output: WorkflowDefinitionModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.definition.updated",
+        version: "1.0.0",
+        when: "Workflow is updated",
+        payload: WorkflowDefinitionModel
+      }
+    ],
+    audit: ["workflow.definition.updated"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "update-workflow-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User updates definition"],
+        then: [
+          "Definition is updated",
+          "WorkflowDefinitionUpdated event is emitted"
+        ]
+      }
+    ],
+    examples: [
+      {
+        key: "update-name",
+        input: { workflowId: "def-123", name: "New Employee Onboarding" },
+        output: { id: "def-123", name: "New Employee Onboarding" }
+      }
+    ]
+  }
+});
+var AddStepContract = defineCommand3({
+  meta: {
+    key: "workflow.step.add",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "step", "add"],
+    description: "Add a step to a workflow definition.",
+    goal: "Build workflow structure step by step.",
+    context: "Workflow designer."
+  },
+  io: {
+    input: AddStepInputModel,
+    output: WorkflowStepModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.step.added",
+        version: "1.0.0",
+        when: "Step is added",
+        payload: WorkflowStepModel
+      }
+    ],
+    audit: ["workflow.step.added"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "add-step-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User adds a step"],
+        then: ["Step is added", "StepAdded event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "add-approval-step",
+        input: {
+          workflowId: "def-123",
+          stepKey: "approve-contract",
+          type: "approval"
+        },
+        output: { id: "step-456", key: "approve-contract" }
+      }
+    ]
+  }
+});
+var PublishWorkflowContract = defineCommand3({
+  meta: {
+    key: "workflow.definition.publish",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "definition", "publish"],
+    description: "Publish a workflow definition to make it available for use.",
+    goal: "Activate workflow for production use.",
+    context: "Workflow designer, deployment."
+  },
+  io: {
+    input: defineSchemaModel9({
+      name: "PublishWorkflowInput",
+      fields: {
+        workflowId: {
+          type: ScalarTypeEnum9.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: WorkflowDefinitionModel
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "workflow.definition.published",
+        version: "1.0.0",
+        when: "Workflow is published",
+        payload: WorkflowDefinitionModel
+      }
+    ],
+    audit: ["workflow.definition.published"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "publish-workflow-happy-path",
+        given: ["Workflow definition is valid"],
+        when: ["User publishes workflow"],
+        then: ["Workflow becomes active", "WorkflowPublished event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "publish-onboarding",
+        input: { workflowId: "def-123" },
+        output: { id: "def-123", status: "published" }
+      }
+    ]
+  }
+});
+var ListWorkflowsContract = defineQuery3({
+  meta: {
+    key: "workflow.definition.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "definition", "list"],
+    description: "List workflow definitions with filtering.",
+    goal: "Browse and search available workflows.",
+    context: "Workflow list, search."
+  },
+  io: {
+    input: defineSchemaModel9({
+      name: "ListWorkflowsInput",
+      fields: {
+        status: { type: WorkflowStatusEnum, isOptional: true },
+        search: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum9.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum9.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel9({
+      name: "ListWorkflowsOutput",
+      fields: {
+        workflows: {
+          type: WorkflowDefinitionModel,
+          isArray: true,
+          isOptional: false
+        },
+        total: { type: ScalarTypeEnum9.Int_unsecure(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-workflows-happy-path",
+        given: ["Workflow definitions exist"],
+        when: ["User lists workflows"],
+        then: ["List of workflows is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-all",
+        input: { limit: 10 },
+        output: { workflows: [], total: 5 }
+      }
+    ]
+  }
+});
+var GetWorkflowContract = defineQuery3({
+  meta: {
+    key: "workflow.definition.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["workflow", "definition", "get"],
+    description: "Get a workflow definition with all steps.",
+    goal: "View workflow details.",
+    context: "Workflow designer, detail view."
+  },
+  io: {
+    input: defineSchemaModel9({
+      name: "GetWorkflowInput",
+      fields: {
+        workflowId: {
+          type: ScalarTypeEnum9.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: WorkflowDefinitionModel
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-workflow-happy-path",
+        given: ["Workflow definition exists"],
+        when: ["User requests workflow details"],
+        then: ["Workflow details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-details",
+        input: { workflowId: "def-123" },
+        output: { id: "def-123", name: "Employee Onboarding" }
+      }
+    ]
+  }
+});
+// src/workflow-system.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts-spec";
+var WorkflowSystemFeature = defineFeature({
+  meta: {
+    key: "workflow-system",
+    title: "Workflow & Approval System",
+    description: "State machine-based workflow engine with role-based approvals, delegation, and escalation",
+    domain: "workflow",
+    owners: ["@workflow-team"],
+    tags: ["workflow", "approval", "state-machine", "automation"],
+    stability: "experimental",
+    version: "1.0.0"
+  },
+  operations: [
+    { key: "workflow.definition.create", version: "1.0.0" },
+    { key: "workflow.definition.update", version: "1.0.0" },
+    { key: "workflow.step.add", version: "1.0.0" },
+    { key: "workflow.definition.publish", version: "1.0.0" },
+    { key: "workflow.definition.list", version: "1.0.0" },
+    { key: "workflow.definition.get", version: "1.0.0" },
+    { key: "workflow.instance.start", version: "1.0.0" },
+    { key: "workflow.instance.transition", version: "1.0.0" },
+    { key: "workflow.instance.pause", version: "1.0.0" },
+    { key: "workflow.instance.resume", version: "1.0.0" },
+    { key: "workflow.instance.cancel", version: "1.0.0" },
+    { key: "workflow.instance.list", version: "1.0.0" },
+    { key: "workflow.instance.get", version: "1.0.0" },
+    { key: "workflow.approval.decide", version: "1.0.0" },
+    { key: "workflow.approval.delegate", version: "1.0.0" },
+    { key: "workflow.approval.comment.add", version: "1.0.0" },
+    { key: "workflow.approval.list.mine", version: "1.0.0" },
+    { key: "workflow.approval.get", version: "1.0.0" }
+  ],
+  events: [
+    { key: "workflow.definition.created", version: "1.0.0" },
+    { key: "workflow.definition.updated", version: "1.0.0" },
+    { key: "workflow.definition.published", version: "1.0.0" },
+    { key: "workflow.step.added", version: "1.0.0" },
+    { key: "workflow.instance.started", version: "1.0.0" },
+    { key: "workflow.step.entered", version: "1.0.0" },
+    { key: "workflow.step.exited", version: "1.0.0" },
+    { key: "workflow.instance.completed", version: "1.0.0" },
+    { key: "workflow.instance.cancelled", version: "1.0.0" },
+    { key: "workflow.instance.paused", version: "1.0.0" },
+    { key: "workflow.instance.resumed", version: "1.0.0" },
+    { key: "workflow.instance.failed", version: "1.0.0" },
+    { key: "workflow.instance.timedOut", version: "1.0.0" },
+    { key: "workflow.approval.requested", version: "1.0.0" },
+    { key: "workflow.approval.decided", version: "1.0.0" },
+    { key: "workflow.approval.delegated", version: "1.0.0" },
+    { key: "workflow.approval.escalated", version: "1.0.0" }
+  ],
+  presentations: [
+    { key: "workflow.designer", version: "1.0.0" },
+    { key: "workflow.definition.viewList", version: "1.0.0" },
+    { key: "workflow.definition.detail", version: "1.0.0" },
+    { key: "workflow.instance.viewList", version: "1.0.0" },
+    { key: "workflow.instance.detail", version: "1.0.0" },
+    { key: "workflow.instance.progress", version: "1.0.0" },
+    { key: "workflow.approval.inbox", version: "1.0.0" },
+    { key: "workflow.approval.detail", version: "1.0.0" },
+    { key: "workflow.approval.form", version: "1.0.0" },
+    { key: "workflow.approval.badge", version: "1.0.0" },
+    { key: "workflow.metrics", version: "1.0.0" }
+  ],
+  opToPresentation: [
+    {
+      op: { key: "workflow.definition.list", version: "1.0.0" },
+      pres: { key: "workflow.definition.viewList", version: "1.0.0" }
+    },
+    {
+      op: { key: "workflow.instance.list", version: "1.0.0" },
+      pres: { key: "workflow.instance.viewList", version: "1.0.0" }
+    },
+    {
+      op: { key: "workflow.approval.list.mine", version: "1.0.0" },
+      pres: { key: "workflow.approval.inbox", version: "1.0.0" }
+    },
+    {
+      op: { key: "workflow.approval.decide", version: "1.0.0" },
+      pres: { key: "workflow.approval.form", version: "1.0.0" }
+    }
+  ],
+  presentationsTargets: [
+    { key: "workflow.designer", version: "1.0.0", targets: ["react"] },
+    {
+      key: "workflow.definition.viewList",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.definition.detail",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.instance.viewList",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.instance.detail",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    { key: "workflow.instance.progress", version: "1.0.0", targets: ["react"] },
+    {
+      key: "workflow.approval.inbox",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.approval.detail",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    },
+    {
+      key: "workflow.metrics",
+      version: "1.0.0",
+      targets: ["react", "markdown"]
+    }
+  ],
+  visualizations: WorkflowVisualizationRefs,
+  capabilities: {
+    requires: [
+      { key: "identity", version: "1.0.0" },
+      { key: "audit-trail", version: "1.0.0" },
+      { key: "notifications", version: "1.0.0" },
+      { key: "feature-flags", version: "1.0.0" }
+    ],
+    provides: [
+      { key: "workflow", version: "1.0.0" },
+      { key: "approval", version: "1.0.0" },
+      { key: "state-machine", version: "1.0.0" }
+    ]
+  },
+  workflows: [
+    { key: "workflow-system.workflow.approval-chain", version: "1.0.0" }
+  ],
+  telemetry: [{ key: "workflow-system.telemetry", version: "1.0.0" }],
+  jobs: [
+    { key: "workflow-system.job.instance-timeout", version: "1.0.0" },
+    { key: "workflow-system.job.escalation", version: "1.0.0" }
+  ],
+  docs: [
+    "docs.examples.workflow-system",
+    "docs.examples.workflow-system.goal",
+    "docs.examples.workflow-system.usage",
+    "docs.examples.workflow-system.constraints"
+  ]
+});
 export {
   workflowInstanceDetailMarkdownRenderer,
   workflowDefinitionListMarkdownRenderer,
   workflowDashboardMarkdownRenderer,
   useWorkflowList,
   mockDataStore,
+  createWorkflowVisualizationSections,
   createWorkflowHandlers,
   createStateMachineEngine,
   createInitialState,
   buildStateMachineDefinition,
+  WorkflowVisualizationSpecs,
+  WorkflowVisualizationRegistry,
+  WorkflowVisualizationRefs,
   WorkflowUpdatedEvent,
+  WorkflowThroughputVisualization,
   WorkflowSystemPresentations,
   WorkflowSystemFeature,
   WorkflowStepModel,
@@ -3074,12 +3458,15 @@ export {
   WorkflowPublishedEvent,
   WorkflowMetricsPresentation,
   WorkflowListPresentation,
+  WorkflowInstanceStatusVisualization,
   WorkflowInstanceModel,
   WorkflowDetailPresentation,
   WorkflowDesignerPresentation,
   WorkflowDefinitionModel,
   WorkflowDashboard,
   WorkflowCreatedEvent,
+  WorkflowCompletedMetricVisualization,
+  WorkflowActiveMetricVisualization,
   UpdateWorkflowInputModel,
   UpdateWorkflowContract,
   TriggerTypeEnum,