@contractspec/example.workflow-system 3.7.5 → 3.7.7

package/dist/index.js

@@ -20,7 +20,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",
@@ -911,398 +911,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 }
       }
     })
   },
@@ -1310,1753 +1508,1553 @@ 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."
-  },
-  io: {
-    input: StartWorkflowInputModel,
-    output: WorkflowInstanceModel
+    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"
   },
-  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"]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowDesigner",
+    props: WorkflowDefinitionModel
   },
-  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" }
-      }
-    ]
+  targets: ["react"],
+  policy: {
+    flags: ["workflow.designer.enabled"]
   }
 });
-var TransitionWorkflowContract = defineCommand3({
+var WorkflowListPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.transition",
+    key: "workflow.definition.viewList",
     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 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"
   },
-  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: "WorkflowDefinitionList",
+    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 WorkflowDetailPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.pause",
+    key: "workflow.definition.detail",
     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: "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.instance.paused",
-        version: "1.0.0",
-        when: "Workflow is paused",
-        payload: WorkflowInstanceModel
-      }
-    ],
-    audit: ["workflow.instance.paused"]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowDefinitionDetail",
+    props: WorkflowDefinitionModel
   },
-  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 InstanceListPresentation = definePresentation({
   meta: {
-    key: "workflow.instance.resume",
+    key: "workflow.instance.viewList",
     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."
+    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"
   },
-  io: {
-    input: defineSchemaModel8({
-      name: "PauseResumeInput",
-      fields: {
-        instanceId: {
-          type: ScalarTypeEnum8.String_unsecure(),
-          isOptional: false
-        },
-        reason: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true }
-      }
-    }),
-    output: WorkflowInstanceModel
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowInstanceList",
+    props: WorkflowInstanceModel
   },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "workflow.instance.resumed",
-        version: "1.0.0",
-        when: "Workflow is resumed",
-        payload: WorkflowInstanceModel
-      }
-    ],
-    audit: ["workflow.instance.resumed"]
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["workflow.enabled"]
+  }
+});
+var InstanceDetailPresentation = definePresentation({
+  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"
   },
-  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" }
-      }
-    ]
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "WorkflowInstanceDetail",
+    props: WorkflowInstanceModel
+  },
+  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"],
-    stability: StabilityEnum.Experimental,
-    goal: "Building and modifying workflow definitions",
-    context: "Workflow administration and setup"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowDesigner",
-    props: WorkflowDefinitionModel
-  },
-  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"],
+    tags: ["workflow", "metrics", "dashboard"],
     stability: StabilityEnum.Experimental,
-    goal: "Overview of all defined workflows",
-    context: "Workflow management dashboard"
+    goal: "Monitoring throughput and bottlenecks",
+    context: "System performance dashboard"
   },
   source: {
     type: "component",
     framework: "react",
-    componentKey: "WorkflowDefinitionList",
-    props: WorkflowDefinitionModel
+    componentKey: "WorkflowMetricsDashboard"
   },
   targets: ["react", "markdown"],
   policy: {
-    flags: ["workflow.enabled"]
+    flags: ["workflow.metrics.enabled"]
   }
 });
-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 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(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
+  };
+}
+
+// src/ui/hooks/index.ts
+"use client";
+
+// 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"
   },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowDefinitionDetail",
-    props: WorkflowDefinitionModel
+  {
+    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"
   },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.enabled"]
+  {
+    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 InstanceListPresentation = definePresentation({
-  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"
+];
+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"
   },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "WorkflowInstanceList",
-    props: WorkflowInstanceModel
+  {
+    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"
   },
-  targets: ["react", "markdown"],
-  policy: {
-    flags: ["workflow.enabled"]
-  }
-});
-var InstanceDetailPresentation = definePresentation({
-  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"]
+  {
+    id: "inst-3",
+    definitionId: "wf-2",
+    definitionName: "Leave Request",
+    status: "PENDING",
+    currentStepId: "s1",
+    startedAt: "2024-01-16T08:00:00Z",
+    requestedBy: "Bob Wilson"
   }
-});
-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 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 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 lines = [
+      "# Workflow Dashboard",
+      "",
+      "> Workflow and approval management overview",
+      "",
+      "## Summary",
+      "",
+      "| Metric | Value |",
+      "|--------|-------|",
+      `| Active Workflows | ${activeDefinitions.length} |`,
+      `| Pending Approvals | ${pendingInstances.length} |`,
+      `| In Progress | ${inProgressInstances.length} |`,
+      `| Completed | ${completedInstances.length} |`,
+      "",
+      "## Active Workflow Definitions",
+      ""
+    ];
+    if (activeDefinitions.length === 0) {
+      lines.push("_No active workflow definitions._");
+    } else {
+      lines.push("| Name | Type | Steps | Status |");
+      lines.push("|------|------|-------|--------|");
+      for (const def of activeDefinitions) {
+        lines.push(`| ${def.name} | ${def.type} | ${def.steps.length} | ${def.status} |`);
+      }
+    }
+    lines.push("");
+    lines.push("## Recent Instances");
+    lines.push("");
+    if (instances.length === 0) {
+      lines.push("_No workflow instances._");
+    } else {
+      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} |`);
+      }
+    }
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
   }
-});
-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 workflowDefinitionListMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowDefinitionList") {
+      throw new Error("workflowDefinitionListMarkdownRenderer: not WorkflowDefinitionList");
+    }
+    const definitions = mockWorkflowDefinitions;
+    const lines = [
+      "# Workflow Definitions",
+      "",
+      "> Configure automated approval and process workflows",
+      ""
+    ];
+    for (const def of definitions) {
+      lines.push(`## ${def.name}`);
+      lines.push("");
+      lines.push(`**Type:** ${def.type} | **Status:** ${def.status}`);
+      lines.push("");
+      lines.push("### Steps");
+      lines.push("");
+      for (const step of def.steps) {
+        lines.push(`${step.order}. **${step.name}** - Roles: ${step.requiredRoles.join(", ")}`);
+      }
+      lines.push("");
+    }
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
   }
-});
-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 workflowInstanceDetailMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowInstanceDetail") {
+      throw new Error("workflowInstanceDetailMarkdownRenderer: not WorkflowInstanceDetail");
+    }
+    const instance = mockWorkflowInstances[0];
+    if (!instance) {
+      return {
+        mimeType: "text/markdown",
+        body: `# No Workflow Instances
+
+No workflow instances available.`
+      };
+    }
+    const definition = mockWorkflowDefinitions.find((d) => d.id === instance.definitionId);
+    const lines = [
+      `# Workflow: ${instance.definitionName}`,
+      "",
+      `**Instance ID:** ${instance.id}`,
+      `**Status:** ${instance.status}`,
+      `**Requested By:** ${instance.requestedBy}`,
+      `**Started:** ${new Date(instance.startedAt).toLocaleString()}`,
+      "",
+      "## Steps Progress",
+      ""
+    ];
+    if (definition) {
+      for (const step of definition.steps) {
+        const isCurrent = step.id === instance.currentStepId;
+        const isCompleted = definition.steps.indexOf(step) < definition.steps.findIndex((s) => s.id === instance.currentStepId);
+        let status = "\u2B1C Pending";
+        if (isCompleted)
+          status = "\u2705 Completed";
+        if (isCurrent)
+          status = "\uD83D\uDD04 In Progress";
+        lines.push(`- ${status} **${step.name}**`);
+      }
+    }
+    lines.push("");
+    lines.push("## Actions");
+    lines.push("");
+    lines.push("- **Approve** - Move to next step");
+    lines.push("- **Reject** - Reject and return");
+    lines.push("- **Delegate** - Assign to another approver");
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
   }
-});
-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"]
-  }
-});
-var PendingApprovalsBadgePresentation = definePresentation({
-  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"]
+};
+// src/ui/WorkflowDashboard.tsx
+import {
+  Button,
+  ErrorState,
+  LoaderBlock,
+  StatCard,
+  StatCardGroup
+} from "@contractspec/lib.design-system";
+import { useState as useState2 } from "react";
+import { jsxDEV } 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",
+  DRAFT: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400",
+  ARCHIVED: "bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400",
+  PENDING: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
+  IN_PROGRESS: "bg-indigo-100 text-indigo-700 dark:bg-indigo-900/30 dark:text-indigo-400",
+  COMPLETED: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+  REJECTED: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400",
+  CANCELLED: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400"
+};
+function WorkflowDashboard() {
+  const [activeTab, setActiveTab] = useState2("definitions");
+  const { definitions, instances, loading, error, stats, refetch } = useWorkflowList();
+  const tabs = [
+    { id: "definitions", label: "Definitions", icon: "\uD83D\uDCCB" },
+    { id: "instances", label: "Instances", icon: "\uD83D\uDD04" }
+  ];
+  if (loading) {
+    return /* @__PURE__ */ jsxDEV(LoaderBlock, {
+      label: "Loading Workflows..."
+    }, undefined, false, undefined, this);
   }
-});
-var WorkflowMetricsPresentation = definePresentation({
-  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"]
+  if (error) {
+    return /* @__PURE__ */ jsxDEV(ErrorState, {
+      title: "Failed to load Workflows",
+      description: error.message,
+      onRetry: refetch,
+      retryLabel: "Retry"
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV("div", {
+    className: "space-y-6",
+    children: [
+      /* @__PURE__ */ jsxDEV("div", {
+        className: "flex items-center justify-between",
+        children: [
+          /* @__PURE__ */ jsxDEV("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)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV(StatCardGroup, {
+        children: [
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Workflows",
+            value: stats.totalDefinitions,
+            hint: `${stats.activeDefinitions} active`
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Instances",
+            value: stats.totalInstances,
+            hint: "total runs"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Pending",
+            value: stats.pendingInstances,
+            hint: "awaiting action"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(StatCard, {
+            label: "Completed",
+            value: stats.completedInstances,
+            hint: "finished"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV("nav", {
+        className: "flex gap-1 rounded-lg bg-muted p-1",
+        role: "tablist",
+        children: tabs.map((tab) => /* @__PURE__ */ jsxDEV(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 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", {
+              children: tab.icon
+            }, undefined, false, undefined, this),
+            tab.label
+          ]
+        }, tab.id, true, undefined, this))
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV("div", {
+        className: "min-h-[400px]",
+        role: "tabpanel",
+        children: [
+          activeTab === "definitions" && /* @__PURE__ */ jsxDEV("div", {
+            className: "rounded-lg border border-border",
+            children: /* @__PURE__ */ jsxDEV("table", {
+              className: "w-full",
+              children: [
+                /* @__PURE__ */ jsxDEV("thead", {
+                  className: "border-border border-b bg-muted/30",
+                  children: /* @__PURE__ */ jsxDEV("tr", {
+                    children: [
+                      /* @__PURE__ */ jsxDEV("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 font-medium text-sm",
+                        children: "Type"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("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 font-medium text-sm",
+                        children: "Created"
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("tbody", {
+                  className: "divide-y divide-border",
+                  children: [
+                    definitions.map((def) => /* @__PURE__ */ jsxDEV("tr", {
+                      className: "hover:bg-muted/50",
+                      children: [
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: [
+                            /* @__PURE__ */ jsxDEV("div", {
+                              className: "font-medium",
+                              children: def.name
+                            }, undefined, false, undefined, this),
+                            /* @__PURE__ */ jsxDEV("div", {
+                              className: "text-muted-foreground text-sm",
+                              children: def.description
+                            }, undefined, false, undefined, this)
+                          ]
+                        }, undefined, true, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3 font-mono text-sm",
+                          children: def.type
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: /* @__PURE__ */ jsxDEV("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: "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", {
+                        colSpan: 4,
+                        className: "px-4 py-8 text-center text-muted-foreground",
+                        children: "No workflow definitions found"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          activeTab === "instances" && /* @__PURE__ */ jsxDEV("div", {
+            className: "rounded-lg border border-border",
+            children: /* @__PURE__ */ jsxDEV("table", {
+              className: "w-full",
+              children: [
+                /* @__PURE__ */ jsxDEV("thead", {
+                  className: "border-border border-b bg-muted/30",
+                  children: /* @__PURE__ */ jsxDEV("tr", {
+                    children: [
+                      /* @__PURE__ */ jsxDEV("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 font-medium text-sm",
+                        children: "Status"
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV("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 font-medium text-sm",
+                        children: "Started"
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV("tbody", {
+                  className: "divide-y divide-border",
+                  children: [
+                    instances.map((inst) => /* @__PURE__ */ jsxDEV("tr", {
+                      className: "hover:bg-muted/50",
+                      children: [
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3 font-mono text-sm",
+                          children: inst.id
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("td", {
+                          className: "px-4 py-3",
+                          children: /* @__PURE__ */ jsxDEV("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", {
+                          className: "px-4 py-3 text-sm",
+                          children: inst.requestedBy
+                        }, undefined, false, undefined, this),
+                        /* @__PURE__ */ jsxDEV("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", {
+                        colSpan: 4,
+                        className: "px-4 py-8 text-center text-muted-foreground",
+                        children: "No workflow instances found"
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, 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 WorkflowSystemPresentations = {
-  WorkflowDesignerPresentation,
-  WorkflowListPresentation,
-  WorkflowDetailPresentation,
-  InstanceListPresentation,
-  InstanceDetailPresentation,
-  ProgressTrackerPresentation,
-  ApprovalInboxPresentation,
-  ApprovalDetailPresentation,
-  ApprovalFormPresentation,
-  PendingApprovalsBadgePresentation,
-  WorkflowMetricsPresentation
-};
-
-// 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"]
-    }
-  ],
-  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"
-  ]
-});
-
-// 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 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 mockWorkflowInstances = [
-  {
-    id: "inst-1",
-    definitionId: "wf-1",
-    definitionName: "Purchase Approval",
-    status: "IN_PROGRESS",
-    currentStepId: "s2",
-    startedAt: "2024-01-15T10:00:00Z",
-    requestedBy: "John Doe"
+});
+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"]
   },
-  {
-    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"
+  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"]
   },
-  {
-    id: "inst-3",
-    definitionId: "wf-2",
-    definitionName: "Leave Request",
-    status: "PENDING",
-    currentStepId: "s1",
-    startedAt: "2024-01-16T08:00:00Z",
-    requestedBy: "Bob Wilson"
-  }
-];
-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 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 lines = [
-      "# Workflow Dashboard",
-      "",
-      "> Workflow and approval management overview",
-      "",
-      "## Summary",
-      "",
-      "| Metric | Value |",
-      "|--------|-------|",
-      `| Active Workflows | ${activeDefinitions.length} |`,
-      `| Pending Approvals | ${pendingInstances.length} |`,
-      `| In Progress | ${inProgressInstances.length} |`,
-      `| Completed | ${completedInstances.length} |`,
-      "",
-      "## Active Workflow Definitions",
-      ""
-    ];
-    if (activeDefinitions.length === 0) {
-      lines.push("_No active workflow definitions._");
-    } else {
-      lines.push("| Name | Type | Steps | Status |");
-      lines.push("|------|------|-------|--------|");
-      for (const def of activeDefinitions) {
-        lines.push(`| ${def.name} | ${def.type} | ${def.steps.length} | ${def.status} |`);
+  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/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
       }
-    }
-    lines.push("");
-    lines.push("## Recent Instances");
-    lines.push("");
-    if (instances.length === 0) {
-      lines.push("_No workflow instances._");
-    } else {
-      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} |`);
+    ],
+    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"
+        ]
       }
-    }
-    return {
-      mimeType: "text/markdown",
-      body: lines.join(`
-`)
-    };
+    ],
+    examples: [
+      {
+        key: "create-onboarding",
+        input: {
+          key: "onboarding-v1",
+          name: "Employee Onboarding",
+          version: "1.0.0"
+        },
+        output: { id: "def-123", status: "draft" }
+      }
+    ]
   }
-};
-var workflowDefinitionListMarkdownRenderer = {
-  target: "markdown",
-  render: async (desc) => {
-    if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowDefinitionList") {
-      throw new Error("workflowDefinitionListMarkdownRenderer: not WorkflowDefinitionList");
-    }
-    const definitions = mockWorkflowDefinitions;
-    const lines = [
-      "# Workflow Definitions",
-      "",
-      "> Configure automated approval and process workflows",
-      ""
-    ];
-    for (const def of definitions) {
-      lines.push(`## ${def.name}`);
-      lines.push("");
-      lines.push(`**Type:** ${def.type} | **Status:** ${def.status}`);
-      lines.push("");
-      lines.push("### Steps");
-      lines.push("");
-      for (const step of def.steps) {
-        lines.push(`${step.order}. **${step.name}** - Roles: ${step.requiredRoles.join(", ")}`);
+});
+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
       }
-      lines.push("");
-    }
-    return {
-      mimeType: "text/markdown",
-      body: lines.join(`
-`)
-    };
+    ],
+    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 workflowInstanceDetailMarkdownRenderer = {
-  target: "markdown",
-  render: async (desc) => {
-    if (desc.source.type !== "component" || desc.source.componentKey !== "WorkflowInstanceDetail") {
-      throw new Error("workflowInstanceDetailMarkdownRenderer: not WorkflowInstanceDetail");
-    }
-    const instance = mockWorkflowInstances[0];
-    if (!instance) {
-      return {
-        mimeType: "text/markdown",
-        body: `# No Workflow Instances
-
-No workflow instances available.`
-      };
-    }
-    const definition = mockWorkflowDefinitions.find((d) => d.id === instance.definitionId);
-    const lines = [
-      `# Workflow: ${instance.definitionName}`,
-      "",
-      `**Instance ID:** ${instance.id}`,
-      `**Status:** ${instance.status}`,
-      `**Requested By:** ${instance.requestedBy}`,
-      `**Started:** ${new Date(instance.startedAt).toLocaleString()}`,
-      "",
-      "## Steps Progress",
-      ""
-    ];
-    if (definition) {
-      for (const step of definition.steps) {
-        const isCurrent = step.id === instance.currentStepId;
-        const isCompleted = definition.steps.indexOf(step) < definition.steps.findIndex((s) => s.id === instance.currentStepId);
-        let status = "\u2B1C Pending";
-        if (isCompleted)
-          status = "\u2705 Completed";
-        if (isCurrent)
-          status = "\uD83D\uDD04 In Progress";
-        lines.push(`- ${status} **${step.name}**`);
+});
+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
       }
-    }
-    lines.push("");
-    lines.push("## Actions");
-    lines.push("");
-    lines.push("- **Approve** - Move to next step");
-    lines.push("- **Reject** - Reject and return");
-    lines.push("- **Delegate** - Assign to another approver");
-    return {
-      mimeType: "text/markdown",
-      body: lines.join(`
-`)
-    };
-  }
-};
-// src/ui/hooks/useWorkflowList.ts
-import { useCallback, useEffect, useState } from "react";
-import { useTemplateRuntime } from "@contractspec/lib.example-shared-ui";
-"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
-  };
-}
-
-// src/ui/WorkflowDashboard.tsx
-import { useState as useState2 } from "react";
-import {
-  Button,
-  ErrorState,
-  LoaderBlock,
-  StatCard,
-  StatCardGroup
-} from "@contractspec/lib.design-system";
-import { jsxDEV } 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",
-  DRAFT: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400",
-  ARCHIVED: "bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400",
-  PENDING: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
-  IN_PROGRESS: "bg-indigo-100 text-indigo-700 dark:bg-indigo-900/30 dark:text-indigo-400",
-  COMPLETED: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
-  REJECTED: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400",
-  CANCELLED: "bg-gray-100 text-gray-700 dark:bg-gray-900/30 dark:text-gray-400"
-};
-function WorkflowDashboard() {
-  const [activeTab, setActiveTab] = useState2("definitions");
-  const { definitions, instances, loading, error, stats, refetch } = useWorkflowList();
-  const tabs = [
-    { id: "definitions", label: "Definitions", icon: "\uD83D\uDCCB" },
-    { id: "instances", label: "Instances", icon: "\uD83D\uDD04" }
-  ];
-  if (loading) {
-    return /* @__PURE__ */ jsxDEV(LoaderBlock, {
-      label: "Loading Workflows..."
-    }, undefined, false, undefined, this);
+    ],
+    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" }
+      }
+    ]
   }
-  if (error) {
-    return /* @__PURE__ */ jsxDEV(ErrorState, {
-      title: "Failed to load Workflows",
-      description: error.message,
-      onRetry: refetch,
-      retryLabel: "Retry"
-    }, undefined, false, undefined, this);
+});
+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" }
+      }
+    ]
   }
-  return /* @__PURE__ */ jsxDEV("div", {
-    className: "space-y-6",
-    children: [
-      /* @__PURE__ */ jsxDEV("div", {
-        className: "flex items-center justify-between",
-        children: [
-          /* @__PURE__ */ jsxDEV("h2", {
-            className: "text-2xl font-bold",
-            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)
-        ]
-      }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV(StatCardGroup, {
-        children: [
-          /* @__PURE__ */ jsxDEV(StatCard, {
-            label: "Workflows",
-            value: stats.totalDefinitions,
-            hint: `${stats.activeDefinitions} active`
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV(StatCard, {
-            label: "Instances",
-            value: stats.totalInstances,
-            hint: "total runs"
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV(StatCard, {
-            label: "Pending",
-            value: stats.pendingInstances,
-            hint: "awaiting action"
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV(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",
-        role: "tablist",
-        children: tabs.map((tab) => /* @__PURE__ */ jsxDEV(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"}`,
-          children: [
-            /* @__PURE__ */ jsxDEV("span", {
-              children: tab.icon
-            }, undefined, false, undefined, this),
-            tab.label
-          ]
-        }, tab.id, true, undefined, this))
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV("div", {
-        className: "min-h-[400px]",
-        role: "tabpanel",
-        children: [
-          activeTab === "definitions" && /* @__PURE__ */ jsxDEV("div", {
-            className: "border-border rounded-lg border",
-            children: /* @__PURE__ */ jsxDEV("table", {
-              className: "w-full",
-              children: [
-                /* @__PURE__ */ jsxDEV("thead", {
-                  className: "border-border bg-muted/30 border-b",
-                  children: /* @__PURE__ */ jsxDEV("tr", {
-                    children: [
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
-                        children: "Name"
-                      }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
-                        children: "Type"
-                      }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
-                        children: "Status"
-                      }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
-                        children: "Created"
-                      }, undefined, false, undefined, this)
-                    ]
-                  }, undefined, true, undefined, this)
-                }, undefined, false, undefined, this),
-                /* @__PURE__ */ jsxDEV("tbody", {
-                  className: "divide-border divide-y",
-                  children: [
-                    definitions.map((def) => /* @__PURE__ */ jsxDEV("tr", {
-                      className: "hover:bg-muted/50",
-                      children: [
-                        /* @__PURE__ */ jsxDEV("td", {
-                          className: "px-4 py-3",
-                          children: [
-                            /* @__PURE__ */ jsxDEV("div", {
-                              className: "font-medium",
-                              children: def.name
-                            }, undefined, false, undefined, this),
-                            /* @__PURE__ */ jsxDEV("div", {
-                              className: "text-muted-foreground text-sm",
-                              children: def.description
-                            }, undefined, false, undefined, this)
-                          ]
-                        }, undefined, true, undefined, this),
-                        /* @__PURE__ */ jsxDEV("td", {
-                          className: "px-4 py-3 font-mono text-sm",
-                          children: def.type
-                        }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("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: def.status
-                          }, undefined, false, undefined, this)
-                        }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("td", {
-                          className: "text-muted-foreground px-4 py-3 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", {
-                        colSpan: 4,
-                        className: "text-muted-foreground px-4 py-8 text-center",
-                        children: "No workflow definitions found"
-                      }, undefined, false, undefined, this)
-                    }, undefined, false, undefined, this)
-                  ]
-                }, undefined, true, undefined, this)
-              ]
-            }, undefined, true, undefined, this)
-          }, undefined, false, undefined, this),
-          activeTab === "instances" && /* @__PURE__ */ jsxDEV("div", {
-            className: "border-border rounded-lg border",
-            children: /* @__PURE__ */ jsxDEV("table", {
-              className: "w-full",
-              children: [
-                /* @__PURE__ */ jsxDEV("thead", {
-                  className: "border-border bg-muted/30 border-b",
-                  children: /* @__PURE__ */ jsxDEV("tr", {
-                    children: [
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
-                        children: "Instance ID"
-                      }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
-                        children: "Status"
-                      }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
-                        children: "Requested By"
-                      }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
-                        children: "Started"
-                      }, undefined, false, undefined, this)
-                    ]
-                  }, undefined, true, undefined, this)
-                }, undefined, false, undefined, this),
-                /* @__PURE__ */ jsxDEV("tbody", {
-                  className: "divide-border divide-y",
-                  children: [
-                    instances.map((inst) => /* @__PURE__ */ jsxDEV("tr", {
-                      className: "hover:bg-muted/50",
-                      children: [
-                        /* @__PURE__ */ jsxDEV("td", {
-                          className: "px-4 py-3 font-mono text-sm",
-                          children: inst.id
-                        }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("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: inst.status
-                          }, undefined, false, undefined, this)
-                        }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("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",
-                          children: inst.startedAt.toLocaleDateString()
-                        }, undefined, false, undefined, this)
-                      ]
-                    }, inst.id, true, undefined, this)),
-                    instances.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
-                      children: /* @__PURE__ */ jsxDEV("td", {
-                        colSpan: 4,
-                        className: "text-muted-foreground px-4 py-8 text-center",
-                        children: "No workflow instances found"
-                      }, undefined, false, undefined, this)
-                    }, undefined, false, undefined, this)
-                  ]
-                }, undefined, true, undefined, this)
-              ]
-            }, undefined, true, undefined, this)
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this)
+});
+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 }
+      }
     ]
-  }, undefined, true, undefined, this);
-}
-
-// src/ui/hooks/index.ts
-"use client";
+  }
+});
+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"]
+    }
+  ],
+  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,